🌮 ↗️ ➡️ ROS: रास्पबेरी पाई "कम रक्त" पर गहराई का नक्शा 🧗🏻 👩🏾‍🤝‍👩🏽 🤳

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

1. रास्पबेरी पाई पर कोई आरओएस है?

सबसे पहले, मैंने यह पता लगाने का फैसला किया कि क्या रास्पबेरी पाई के लिए आरओएस का निर्माण करना संभव था। Google ने मुझे जो पहली चीज़ बताई थी, वह रास्पबेरी पाई पर ROS के विभिन्न संस्करणों को स्थापित करने के निर्देशों की एक सूची थी, अर्थात् यह ROS विकी पृष्ठ

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

2. क्या रास्पबेरी के लिए ROS के साथ कोई तैयार माइक्रोएसडी कार्ड चित्र हैं?

यह पता चला कि इस मुद्दे को पहले से ही कई विकास टीमों द्वारा हल किया गया है। यदि आप उत्साही लोगों द्वारा एक बार का निर्माण नहीं करते हैं, तो एक-दो चित्र बाहर खड़े हैं जो लगातार ओएस और आरओएस के नए संस्करणों की रिहाई के साथ अपडेट किए जाते हैं।

पहला विकल्प आरओएस को रोसबॉट्स टीम से देशी रास्पियन ओएस पर स्थापित किया गया है, यहां एक पृष्ठ है जिसमें एक अद्यतन छवि लिंक है: रेडी-टू-यूज़-इमेज-रास्पियन-स्ट्रेच-रो-ओपेनेंव

दूसरा ubuntu पर Ubiquiti रोबोटिक्स से छवियाँ है ।

खैर, दूसरा सवाल भी काफी जल्दी बंद हो गया। यह गहरा गोता लगाने का समय है।

3. रास्प रास्पबेरी पाई कैमरे के साथ कैसे काम करता है?

और कौन से स्टीरियो कैमरों को आमतौर पर आरओएस में समर्थित किया जाता है? मैंने स्टीरियो कैमरों वाले पृष्ठ को देखा, जिसके लिए आरओएस के लिए तैयार ड्राइवरों की उपलब्धता घोषित की गई थी, यह एक:

wiki.ros.org/Sensors

दो खंड थे:
2.3 3D सेंसर (रेंज फाइंडर्स और RGB-D कैमरे)
2.5 कैमरा
यह पता चला कि पहले खंड में न केवल स्टीरियो कैमरे, बल्कि टीओएफ सेंसर, और स्कैनिंग लिडार भी सूचीबद्ध हैं - सामान्य तौर पर, सब कुछ जो तुरंत 3 डी में जानकारी दे सकता है। और दूसरे में पहले से ही स्टीरियो कैमरे हैं। कई स्टीरियो कैमरों के लिए ड्राइवरों को देखने की कोशिश ने मेरी खुशी को नहीं बढ़ाया, क्योंकि यह कोड में एक गंभीर विसर्जन पर संकेत दिया था।

ठीक है, एक कदम पीछे हटो। आरओएस में सिंगल रास्पबेरी पाई कैमरा के साथ यह कैसे काम करता है?

तीन सुखद आश्चर्य मुझे यहाँ इंतजार कर रहे हैं:

यह पता चला है कि आरओएस के लिए रास्पबेरी पाई कैमरा के साथ काम करने के लिए एक विशेष रास्पिकैम_नोड नोड है
गिथुब पर नोड झूठ के प्रकार, कोड सक्रिय रूप से बनाए रखा गया है और अच्छी तरह से प्रलेखित है: github.com/UbiquityRobotics/raspicam_node
रोहन अग्रवाल नोड ( @Rohbotics ) के लेखक एक ऐसी कंपनी के लिए काम करते हैं जो रास्पबेरी पाई के लिए तैयार छवियों में से एक का सक्रिय रूप से समर्थन करती है

मैंने github रिपॉजिटरी raspicam_node को देखा और मुद्दों पर ध्यान दिया। वहाँ मुझे जवाब और टिप्पणियों के बिना, लगभग सात महीने पहले कैपेसिटिव नाम "स्टीरियो मोड" के साथ एक खुला मुद्दा मिला। दरअसल, इसमें सभी घटनाएं आगे विकसित हुईं।

4. कट्टर या नहीं?

लेखकों से बच्चों के सवाल न पूछने के लिए, मैंने स्रोत कोड को देखने और स्टीरियो मोड को जोड़ने के खतरे का मूल्यांकन करने का निर्णय लिया। मुझे यहाँ सिस्टम भाग में अधिक दिलचस्पी थी: github.com/UbiquityRobotics/raspicam_node/tree/kinetic/src
खैर, लोगों ने ड्राइवर को एमएमएएल स्तर पर गिरते हुए लिखा। मुझे यह भी याद आया कि स्टीरियो मोड में रसभरी के लिए स्रोत कोड भी खुला है (विकास रास्पबेरी मंच पर यहां पता लगाया जा सकता है), और एक पूर्ण-स्टीरियो स्टीरियो ड्राइवर लिखने का कार्य हल करने योग्य है, लेकिन बड़े पैमाने पर। अन्य कैमरों के ड्राइवरों के विवरण को देखते हुए, मैंने महसूस किया कि न केवल बाएं और दाएं चित्रों को प्रकाशित करना आवश्यक था, बल्कि दोनों कैमरों के पैरामीटर भी दे सकते थे, एक-दूसरे पर अंशांकन परिणाम लागू करते थे, और कई अन्य चीजें करते थे। इसने एक या दो महीने लंबे प्रयोगों को आकर्षित किया। इसलिए, मैंने दृष्टिकोण को समानांतर बनाने का फैसला किया, अर्थात्: लेखक को स्टीरियो समर्थन के बारे में एक प्रश्न लिखें, और एक सरल, लेकिन स्वयं समाधान की तलाश करें।

5. लेखक के साथ संवाद

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

रोहन ने आश्चर्यजनक रूप से जल्दी से जवाब दिया, यह कहते हुए कि उनके डिस्टर्ब एक रास्पबेरी कर्नेल का उपयोग करते हैं और सब कुछ काम करना चाहिए। और अपनी एक असेंबली पर इसे जाँचने के लिए कहा।

रास्पबेरी कोर! हुर्रे! सैद्धांतिक रूप से, एक स्टीरियो तस्वीर को एक डफ के साथ डांस किए बिना कैप्चर किया जाना चाहिए!

मैंने रोहन से एक लिंक का उपयोग करके उनकी नवीनतम छवि को डाउनलोड और तैनात किया और एक स्टीरियो जोड़ी को पकड़ने के लिए एक साधारण अजगर स्क्रिप्ट चलाई। यह काम किया!

उसके बाद, रोहन ने लिखा कि वह स्टीरियो मोड के लिए ड्राइवर कोड को देखेगा, और कुछ प्रश्न लिखेगा। उदाहरण के लिए, हमारे स्टीरियो मोड में एक चिपके हुए चित्र का निर्माण होता है, और हमें इसे दो - बाएं और दाएं में काटने की आवश्यकता होगी। और प्रत्येक कैमरे के अंशांकन मापदंडों के बारे में दूसरा सवाल यह है कि इससे कैसे निपटें।

मैंने कहा कि पहले कदम के रूप में, आप स्वतंत्र रूप से कैमरों से तस्वीरें ले सकते हैं। हां, उन्हें कैप्चर टाइम और सेटिंग्स (जैसे ब्राइट-कॉन्ट्रास्ट-व्हाइट बैलेंस) में सिंक नहीं किया जाएगा, लेकिन पहले कदम के रूप में, यह अच्छी तरह से नीचे आ सकता है।

रोहन ने तुरंत एक पैच रोल किया जो आपको सीधे आरओएस से निर्दिष्ट करने की अनुमति देता है कि किस कैमरा से चित्र लेना है। मैंने इसे चेक किया - एक कैमरा काम को चुनना, यह पहले से ही एक उत्कृष्ट परिणाम है।

6. अप्रत्याशित मदद

और फिर Wezzoid उपयोगकर्ता की एक टिप्पणी थ्रेड में दिखाई देती है। उन्होंने कहा कि वह रास्पबेरी डिबोर्डों का उपयोग करके पाई कंप्यूट 3 पर स्टीरियो कैमरा पर आधारित एक परियोजना कर रहे थे। उनके चार पैरों वाले चलने वाले रोबोट ने अंतरिक्ष में एक वस्तु की स्थिति को ट्रैक किया, कैमरों की स्थिति को बदल दिया और इसे एक पूर्वनिर्धारित दूरी पर रखा (परियोजना यहां हैकडाय.यो पर पोस्ट की गई है )।

और उन्होंने उस कोड को साझा किया जिसमें उन्होंने तस्वीर को पकड़ा, उसे अजगर के साथ आधे में काट दिया और इसे बाएं और दाएं कैमरों के नोड्स की तरह साझा किया।
इन मामलों में अजगर बहुत तेज़ दोस्त नहीं है, इसलिए उसने 320x240 के कम रिज़ॉल्यूशन और एक अच्छे जीवन हैक का उपयोग किया। यदि हम एक साइड-बाय-सिब स्टीरियो इमेज (एक कैमरा स्टीरियो इमेज के बाईं ओर, दूसरा दायीं तरफ) को पकड़ते हैं, तो अजगर को 240 में से हर एक लाइन को आधा काटना चाहिए। लेकिन अगर आप एक ऊपर-नीचे की तस्वीर बनाते हैं (बाएं कैमरा फ्रेम के ऊपरी आधे हिस्से में है, दाईं ओर नीचे है), तो अजगर एक ऑपरेशन में आधे में सरणी काटता है। जिसे सफलतापूर्वक Wezzoid द्वारा उपयोगकर्ता द्वारा किया गया था।
साथ ही, उन्होंने पास्टेबिन पर अपना अजगर कोड पोस्ट किया, जिसने यह ऑपरेशन किया। यहाँ यह है:

एक स्टीरियो जोड़ी से दो कैमरों के नोड्स के प्रकाशन के लिए वेज़ॉइड कोड

#!/usr/bin/env python # picamera stereo ROS node using dual CSI Pi CS3 board # Wes Freeman 2018 # modified from code by Adrian Rosebrock, pyimagesearch.com # and jensenb, https://gist.github.com/jensenb/7303362 from picamera.array import PiRGBArray from picamera import PiCamera import time import rospy from sensor_msgs.msg import CameraInfo, Image import yaml import io import signal # for ctrl-C handling import sys def parse_calibration_yaml(calib_file): with file(calib_file, 'r') as f: params = yaml.load(f) cam_info = CameraInfo() cam_info.height = params['image_height'] cam_info.width = params['image_width'] cam_info.distortion_model = params['distortion_model'] cam_info.K = params['camera_matrix']['data'] cam_info.D = params['distortion_coefficients']['data'] cam_info.R = params['rectification_matrix']['data'] cam_info.P = params['projection_matrix']['data'] return cam_info # cam resolution res_x = 320 #320 # per camera res_y = 240 #240 target_FPS = 15 # initialize the camera print "Init camera..." camera = PiCamera(stereo_mode = 'top-bottom',stereo_decimate=False) camera.resolution = (res_x, res_y*2) # top-bottom stereo camera.framerate = target_FPS # using several camera options can cause instability, hangs after a while camera.exposure_mode = 'antishake' #camera.video_stabilization = True # fussy about res? stream = io.BytesIO() # ---------------------------------------------------------- #setup the publishers print "init publishers" # queue_size should be roughly equal to FPS or that causes lag? left_img_pub = rospy.Publisher('left/image_raw', Image, queue_size=1) right_img_pub = rospy.Publisher('right/image_raw', Image, queue_size=1) left_cam_pub = rospy.Publisher('left/camera_info', CameraInfo, queue_size=1) right_cam_pub = rospy.Publisher('right/camera_info', CameraInfo, queue_size=1) rospy.init_node('stereo_pub') # init messages left_img_msg = Image() left_img_msg.height = res_y left_img_msg.width = res_x left_img_msg.step = res_x*3 # bytes per row: pixels * channels * bytes per channel (1 normally) left_img_msg.encoding = 'rgb8' left_img_msg.header.frame_id = 'stereo_camera' # TF frame right_img_msg = Image() right_img_msg.height = res_y right_img_msg.width = res_x right_img_msg.step = res_x*3 right_img_msg.encoding = 'rgb8' right_img_msg.header.frame_id = 'stereo_camera' imageBytes = res_x*res_y*3 # parse the left and right camera calibration yaml files left_cam_info = parse_calibration_yaml('/home/pi/catkin_ws/src/mmstereocam/camera_info/left.yaml') right_cam_info = parse_calibration_yaml('/home/pi/catkin_ws/src/mmstereocam/camera_info/right.yaml') # --------------------------------------------------------------- # this is supposed to shut down gracefully on CTRL-C but doesn't quite work: def signal_handler(signal, frame): print 'CTRL-C caught' print 'closing camera' camera.close() time.sleep(1) print 'camera closed' sys.exit(0) signal.signal(signal.SIGINT, signal_handler) #----------------------------------------------------------- print "Setup done, entering main loop" framecount=0 frametimer=time.time() toggle = True # capture frames from the camera for frame in camera.capture_continuous(stream, format="rgb", use_video_port=True): framecount +=1 stamp = rospy.Time.now() left_img_msg.header.stamp = stamp right_img_msg.header.stamp = stamp left_cam_info.header.stamp = stamp right_cam_info.header.stamp = stamp left_cam_pub.publish(left_cam_info) right_cam_pub.publish(right_cam_info) frameBytes = stream.getvalue() left_img_msg.data = frameBytes[:imageBytes] right_img_msg.data = frameBytes[imageBytes:] #publish the image pair left_img_pub.publish(left_img_msg) right_img_pub.publish(right_img_msg) # console info if time.time() > frametimer +1.0: if toggle: indicator = ' o' # just so it's obviously alive if values aren't changing else: indicator = ' -' toggle = not toggle print 'approx publish rate:', framecount, 'target FPS:', target_FPS, indicator frametimer=time.time() framecount=0 # clear the stream ready for next frame stream.truncate(0) stream.seek(0)

7. बाएं और दाएं कैमरे के नोड्स को प्रकाशित करना शुरू करें

पहली शुरुआत में, कोड ने शाप दिया कि कैमरा मापदंडों के साथ वाईएमएल फ़ाइलों तक कोई पहुंच नहीं है। मैंने रास्पबेरी के रंग वाले V2 कैमरों का इस्तेमाल किया और याद किया कि अलग-अलग कैमरा मॉडल के लिए कैलिब्रेशन के परिणाम के साथ तैयार फाइलें github पर raspicam_node में आईं : github.com/UbiquityRobotics/raspicam_node/tree/kinetic/camera_info
मैंने उनमें से एक को लिया, दो प्रतियां बनाईं और इसे बचे हुए नाम के साथ सहेजा। iym और right.yml, उनमें लेखक के स्क्रिप्ट से कैमरा रिज़ॉल्यूशन लिखा। यहां देखें बाएं कैमरे के लिए क्या हुआ:

left.yml

 image_width: 320 image_height: 240 camera_name: left camera_matrix: rows: 3 cols: 3 data: [1276.704618338571, 0, 634.8876509199106, 0, 1274.342831275509, 379.8318028940378, 0, 0, 1] distortion_model: plumb_bob distortion_coefficients: rows: 1 cols: 5 data: [0.1465167016954302, -0.2847343180128725, 0.00134017721235817, -0.004309553450829512, 0] rectification_matrix: rows: 3 cols: 3 data: [1, 0, 0, 0, 1, 0, 0, 0, 1] projection_matrix: rows: 3 cols: 4 data: [1300.127197265625, 0, 630.215390285608, 0, 0, 1300.670166015625, 380.1702884455881, 0, 0, 0, 1, 0]

दाईं ओर, कैमरा नाम को दाईं ओर से बदल दिया जाता है, और फ़ाइल का नाम दाईं ओर रखा जाता है। फ़ाइल का शेष भाग समान है।

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

यह केवल यह देखने के लिए बना रहा कि आखिरकार हमारे बाएं और दाएं कैमरों द्वारा क्या प्रकाशित किया गया था। ऐसा करने के लिए, मैंने rtt_image_view लॉन्च किया। ड्रॉप-डाउन मेनू में आइटम / बाएं / छवि_प्रकाश और / दाईं / छवि_वह दिखाई दिए। जब मैंने उन्हें चुना, तो मैंने बाएं और दाएं कैमरों से छवियां देखीं।

खैर, यह बात अर्जित की है! अब मजा हिस्सा है।

8. हम गहराई के नक्शे को देखते हैं।

गहराई के नक्शे को देखने के लिए, मैं अपने दृष्टिकोण के साथ नहीं आया और स्टीरियो पैरामीटर सेट करने के लिए क्लासिक आरओएस मैनुअल पर चला गया।
वहां से, मुझे पता चला कि दोनों नोड्स को एक विशिष्ट नाम स्थान में प्रकाशित करना अच्छा होगा, और रूट में नहीं जैसा कि वेवॉयड ने किया। परिणामस्वरूप, प्रपत्र के प्रकाशन की पुरानी लाइनें

 left_img_pub = rospy.Publisher('left/image_raw', Image, queue_size=1)

इस तरह दिखना शुरू हुआ:

 left_img_pub = rospy.Publisher('stereo/right/image_raw', Image, queue_size=1)

उसके बाद, हम stere_image_proc स्टीरियो मोड प्रोसेसिंग नोड लॉन्च करते हैं:

 ROS_NAMESPACE=stereo rosrun stereo_image_proc stereo_ige_proc

खैर, हम भी परिणाम देखना चाहते हैं, इसलिए हम चौकीदार शुरू करते हैं:

 rosrun image_view stereo_view stereo:=/stereo image:=image_rect_color

और गहराई के नक्शे के मापदंडों को कॉन्फ़िगर करने के लिए, कॉन्फ़िगरेशन उपयोगिता चलाएं:

 rosrun rqt_reconfigure rqt_reconfigure

नतीजतन, हम लेख की शुरुआत में तस्वीर देखते हैं। यहाँ थोड़ा बड़ा है:

मेरे द्वारा github पर पोस्ट की गई सभी फाइलें: github.com/realizator/StereoPi-ROS-depth-map-test

9. तत्काल योजना

गीथब पर एक चर्चा में परिणाम के मेरे प्रकाशन के बाद, रोहन ने लिखा "कूल! मुझे अपना स्टीरियो लेने जाना होगा। ” हमने उसे मेल से लिखा, मैंने उसे एक शुल्क भेजा। मुझे उम्मीद है कि उसके हाथों में काम करने वाले हार्डवेयर के साथ आरओएस और रास्पबेरी के लिए एक पूर्ण स्टीरियो ड्राइवर को खत्म करना और डिबग करना आसान होगा।

10. सारांश

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

खैर, मज़ेदार से: परिणाम प्राप्त करने के बाद, मैंने देखा कि वेज़ॉइड, जिसने अपने समाधान का प्रस्ताव किया था, दो स्टीरियो चित्रों के प्रकाशन के बारे में सवाल का लेखक था। उसने खुद से पूछा, उसने फैसला किया।

ROS: रास्पबेरी पाई "कम रक्त" पर गहराई का नक्शा