OpenCV आधारित लाइन निम्नलिखित

कारों के लिए ऑटोपिलॉट बनाने पर अब बहुत लोकप्रिय पाठ्यक्रम। उडनेस से यह नैनो-डिग्री संभवतः सबसे प्रसिद्ध विकल्प है।

बहुत से लोग इससे सीखते हैं और अपने फैसले पोस्ट करते हैं। मैं भी, पास होकर नहीं जा सका।

अंतर यह है कि पाठ्यक्रम में प्रदान किए गए डेटा के आधार पर एक एल्गोरिथ्म का विकास शामिल है, और मैंने अपने रोबोट के लिए सब कुछ किया।

पहला कार्य जो कंप्यूटर दृष्टि का अध्ययन करते समय पाठ्यक्रम के छात्रों का सामना करना पड़ता है, वह सड़क पर लाइन का पालन करना है। इस विषय पर कई लेख लिखे गए हैं, यहाँ कुछ सबसे विस्तृत हैं:

• Habr
• डेटा साइंस की ओर
• मध्यम
• Hackster
  

उनमें से सभी काफी सरल हैं और काम की योजना कई बिंदुओं तक कम हो गई है:

• रंग द्वारा फ़िल्टर करें।
• चेहरे का चयन करें
• चित्र के अवांछित भागों को ट्रिम करें
• Hough रूपांतर का उपयोग कर लाइनों का पता लगाएं।

मैंने फर्श पर सफेद टेप चिपका दिया और व्यापार में उतर गया।



ऊपर वर्णित कार्यों में, आपका काम पीले रंग की रेखा को खोजना था, इसलिए उन्होंने एचएलएस और एचएसवी रंगों के साथ काम किया। चूंकि मेरी लाइन केवल सफेद थी, इसलिए मैंने इस से परेशान नहीं होने का फैसला किया और खुद को एक काले और सफेद फिल्टर तक सीमित कर लिया।

ज्यामिति

ज्यामिति के साथ समस्याएं तुरंत शुरू हुईं। चित्रों में छात्रों के लिए, तीर के साथ पट्टी क्षितिज में जाती है। और फिर भी, इस पर बहुत सारी पंक्तियों का पता लगाया जाता है, जिसे लेखकों को संयोजित करना था। हालांकि, उनकी लाइनें अच्छी तरह से निर्देशित थीं और चित्रों में कोई मलबा नहीं था।

मेरे पास एक पूरी तरह से अलग तस्वीर है। विद्युत टेप की पट्टी की ज्यामिति सीधे से बहुत दूर थी। फर्श पर चकाचौंध ने शोर उत्पन्न किया।

कैनी लगाने के बाद, यह हुआ:



और हूप लाइनें इस तरह थीं:



मानदंडों को मजबूत करते हुए, कचरे को बाहर करना संभव था, लेकिन पट्टी पर पाई जाने वाली लगभग सभी लाइनें गायब हो गईं। ऐसे छोटे खंडों पर भरोसा करना मूर्खतापूर्ण होगा।



सामान्य तौर पर, परिणाम बेहद अस्थिर थे, और यह मेरे लिए एक अलग दृष्टिकोण की कोशिश करने के लिए हुआ।

लाइनों के बजाय, मैंने समोच्च की तलाश शुरू कर दी। इस धारणा को बनाने के बाद कि सबसे बड़ा सर्किट विद्युत टेप है, हम कचरे से छुटकारा पाने में कामयाब रहे। (फिर यह पता चला कि बड़े सफेद बेसबोर्ड ने बिजली के टेप की तुलना में फ्रेम में अधिक जगह घेर ली है। मुझे इसे सोफे के कुशन के साथ कवर करना था)।
यदि हम समोच्च को बांधने वाली न्यूनतम आयत लेते हैं, तो मध्य अनुदैर्ध्य रेखा गति वेक्टर की भूमिका के लिए बहुत अच्छी तरह से अनुकूल है।

प्रकाश

दूसरी समस्या प्रकाश की थी। मैंने सोफे के साए में ट्रैक के एक तरफ बहुत सफलतापूर्वक रखा था और एक ही सेटिंग्स के साथ पूरे ट्रैक की तस्वीरों को संसाधित करना पूरी तरह से असंभव था। नतीजतन, मुझे एक काले और सफेद फिल्टर पर गतिशील कटऑफ लागू करना पड़ा। एल्गोरिदम यह है: यदि चित्र में फिल्टर लगाने के बाद बहुत अधिक सफेद (10% से अधिक) है, तो थ्रेशोल्ड को उठाया जाना चाहिए। यदि बहुत कम (3% से कम) - छोड़ दें। अभ्यास से पता चला है कि 3-4 पुनरावृत्तियों के लिए औसतन इष्टतम कटऑफ को खोजना संभव है।

मैजिक नंबरों को एक अलग कॉन्फ़िगरेशन में रखा गया है (नीचे देखें), आप इष्टतम की तलाश में उनके साथ खेल सकते हैं।

def balance_pic(image): global T ret = None direction = 0 for i in range(0, tconf.th_iterations): rc, gray = cv.threshold(image, T, 255, 0) crop = Roi.crop_roi(gray) nwh = cv.countNonZero(crop) perc = int(100 * nwh / Roi.get_area()) logging.debug(("balance attempt", i, T, perc)) if perc > tconf.white_max: if T > tconf.threshold_max: break if direction == -1: ret = crop break T += 10 direction = 1 elif perc < tconf.white_min: if T < tconf.threshold_min: break if direction == 1: ret = crop break T -= 10 direction = -1 else: ret = crop break return ret 

समायोजित मशीन की दृष्टि से, वास्तविक आंदोलन पर आगे बढ़ना संभव था। एल्गोरिथ्म इस प्रकार था:

• 0.5 सेकंड सीधे ड्राइव करते हैं
• एक तस्वीर ले लो
• वेक्टर खोजें
• यदि वेक्टर की शुरुआत तस्वीर के केंद्र के सापेक्ष स्थानांतरित हो जाती है, तो हम सही दिशा में थोड़ा टैक्सी करते हैं
• यदि वेक्टर के झुकाव का कोण आवश्यक से अधिक ऊर्ध्वाधर से विचलन करता है - हम सही दिशा में आगे बढ़ते हैं
• यदि यह अचानक हुआ कि पट्टी फ्रेम से गायब हो गई है, तो हम यह अनुमान लगाते हैं कि हमने एक मोड़ दिया और पिछले चरण में वेक्टर के अंतिम स्टीयरिंग या झुकाव की दिशा में मुड़ना शुरू कर दिया।

कोड का छोटा संस्करण (पूर्ण - जीथब पर):

 def check_shift_turn(angle, shift): turn_state = 0 if angle < tconf.turn_angle or angle > 180 - tconf.turn_angle: turn_state = np.sign(90 - angle) shift_state = 0 if abs(shift) > tconf.shift_max: shift_state = np.sign(shift) return turn_state, shift_state def get_turn(turn_state, shift_state): turn_dir = 0 turn_val = 0 if shift_state != 0: turn_dir = shift_state turn_val = tconf.shift_step if shift_state != turn_state else tconf.turn_step elif turn_state != 0: turn_dir = turn_state turn_val = tconf.turn_step return turn_dir, turn_val def follow(iterations): tanq.set_motors("ff") try: last_turn = 0 last_angle = 0 for i in range(0, iterations): a, shift = get_vector() if a is None: if last_turn != 0: a, shift = find_line(last_turn) if a is None: break elif last_angle != 0: logging.debug(("Looking for line by angle", last_angle)) turn(np.sign(90 - last_angle), tconf.turn_step) continue else: break turn_state, shift_state = check_shift_turn(a, shift) turn_dir, turn_val = get_turn(turn_state, shift_state) if turn_dir != 0: turn(turn_dir, turn_val) last_turn = turn_dir else: time.sleep(tconf.straight_run) last_turn = 0 last_angle = a finally: tanq.set_motors("ss") 

परिणाम

असमान रूप से, लेकिन आत्मविश्वास से, टैंक प्रक्षेपवक्र के साथ रेंग रहा है:



और यहाँ डीबगिंग ग्राफिक्स से एक GIF है:

एल्गोरिथम सेटिंग्स

 ## Picture settings # initial grayscale threshold threshold = 120 # max grayscale threshold threshold_max = 180 #min grayscale threshold threshold_min = 40 # iterations to find balanced threshold th_iterations = 10 # min % of white in roi white_min=3 # max % of white in roi white_max=12 ## Driving settings # line angle to make a turn turn_angle = 45 # line shift to make an adjustment shift_max = 20 # turning time of shift adjustment shift_step = 0.125 # turning time of turn turn_step = 0.25 # time of straight run straight_run = 0.5 # attempts to find the line if lost find_turn_attempts = 5 # turn step to find the line if lost find_turn_step = 0.2 # max # of iterations of the whole tracking max_steps = 100 

गिथब कोड।