सामग्री पर जाएं

ROS (रोबोट ऑपरेटिंग सिस्टम) क्विकस्टार्ट गाइड

Ros परिचय (कैप्शन) Vimeo पर ओपन रोबोटिक्स से।

आरओएस क्या है?

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

आरओएस की मुख्य विशेषताएं

  1. मॉड्यूलर आर्किटेक्चर: आरओएस में एक मॉड्यूलर आर्किटेक्चर है, जो डेवलपर्स को नोड्स नामक छोटे, पुन: प्रयोज्य घटकों को मिलाकर जटिल सिस्टम बनाने की अनुमति देता है। प्रत्येक नोड आमतौर पर एक विशिष्ट कार्य करता है, और नोड्स विषयों या सेवाओं पर संदेशों का उपयोग करके एक दूसरे के साथ संवाद करते हैं

  2. संचार मिडलवेयर: आरओएस एक मजबूत संचार बुनियादी ढांचा प्रदान करता है जो अंतर-प्रक्रिया संचार और वितरित कंप्यूटिंग का समर्थन करता है। यह डेटा स्ट्रीम (विषयों) के लिए एक प्रकाशन-सदस्यता मॉडल और सेवा कॉल के लिए अनुरोध-उत्तर मॉडल के माध्यम से प्राप्त किया जाता है।

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

  4. उपकरण और उपयोगिताएँ: आरओएस विज़ुअलाइज़ेशन, डिबगिंग और सिमुलेशन के लिए उपकरणों और उपयोगिताओं के एक समृद्ध सेट के साथ आता है। उदाहरण के लिए, RViz का उपयोग सेंसर डेटा और रोबोट स्थिति की जानकारी की कल्पना करने के लिए किया जाता है, जबकि गज़ेबो एल्गोरिदम और रोबोट डिज़ाइन के परीक्षण के लिए एक शक्तिशाली सिमुलेशन वातावरण प्रदान करता है।

  5. व्यापक पारिस्थितिकी तंत्र: आरओएस पारिस्थितिकी तंत्र विशाल और लगातार बढ़ रहा है, जिसमें नेविगेशन, हेरफेर, धारणा और बहुत कुछ सहित विभिन्न रोबोट अनुप्रयोगों के लिए कई पैकेज उपलब्ध हैं। समुदाय इन पैकेजों के विकास और रखरखाव में सक्रिय रूप से योगदान देता है।

आरओएस संस्करणों का विकास

2007 में इसके विकास के बाद से, आरओएस कई संस्करणों के माध्यम से विकसित हुआ है, प्रत्येक रोबोटिक्स समुदाय की बढ़ती जरूरतों को पूरा करने के लिए नई सुविधाओं और सुधारों को पेश करता है। आरओएस के विकास को दो मुख्य श्रृंखलाओं में वर्गीकृत किया जा सकता है: आरओएस 1 और आरओएस 2। यह मार्गदर्शिका ROS 1 के दीर्घकालिक समर्थन (LTS) संस्करण पर केंद्रित है, जिसे ROS Noetic Ninjemys के रूप में जाना जाता है, कोड को पहले के संस्करणों के साथ भी काम करना चाहिए।

आरओएस 1 बनाम आरओएस 2

जबकि आरओएस 1 ने रोबोट विकास के लिए एक ठोस आधार प्रदान किया, आरओएस 2 पेशकश करके अपनी कमियों को संबोधित करता है:

  • वास्तविक समय प्रदर्शन: वास्तविक समय प्रणालियों और नियतात्मक व्यवहार के लिए बेहतर समर्थन।
  • सुरक्षा: विभिन्न वातावरणों में सुरक्षित और विश्वसनीय संचालन के लिए बढ़ी हुई सुरक्षा सुविधाएँ।
  • अनुमापकता: मल्टी-रोबोट सिस्टम और बड़े पैमाने पर तैनाती के लिए बेहतर समर्थन।
  • क्रॉस-प्लेटफ़ॉर्म समर्थन: विंडोज और मैकओएस सहित लिनक्स से परे विभिन्न ऑपरेटिंग सिस्टम के साथ विस्तारित संगतता।
  • लचीला संचार: अधिक लचीले और कुशल अंतर-प्रक्रिया संचार के लिए डीडीएस का उपयोग।

आरओएस संदेश और विषय

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

स्थापना Ultralytics YOLO आरओएस के साथ

इस गाइड का परीक्षण इस ROS वातावरण का उपयोग करके किया गया है, जो ROSbot ROS रिपॉजिटरी का एक कांटा है। इस वातावरण में शामिल हैं Ultralytics YOLO पैकेज, आसान सेटअप के लिए एक डॉकर कंटेनर, व्यापक आरओएस पैकेज, और तेजी से परीक्षण के लिए गज़ेबो दुनिया। इसे Husarion ROSbot 2 PRO के साथ काम करने के लिए डिज़ाइन किया गया है। प्रदान किए गए कोड उदाहरण किसी भी आरओएस नोएटिक/मेलोडिक वातावरण में काम करेंगे, जिसमें सिमुलेशन और वास्तविक दुनिया दोनों शामिल हैं।

हुसरियन रोसबोट 2 प्रो

निर्भरता स्थापना

आरओएस वातावरण के अलावा, आपको निम्नलिखित निर्भरताओं को स्थापित करने की आवश्यकता होगी:

  • आरओएस न्यूम्पी पैकेज: यह आरओएस छवि संदेशों और सुन्न सरणियों के बीच तेजी से रूपांतरण के लिए आवश्यक है।

    pip install ros_numpy
    
  • Ultralytics पैकेज:

    pip install ultralytics
    

प्रयोग Ultralytics आरओएस के साथ sensor_msgs/Image

वही sensor_msgs/Image संदेश प्रकार आमतौर पर छवि डेटा का प्रतिनिधित्व करने के लिए आरओएस में उपयोग किया जाता है। इसमें एन्कोडिंग, ऊंचाई, चौड़ाई और पिक्सेल डेटा के लिए फ़ील्ड शामिल हैं, जो इसे कैमरों या अन्य सेंसर द्वारा कैप्चर की गई छवियों को प्रसारित करने के लिए उपयुक्त बनाते हैं। छवि संदेशों का व्यापक रूप से रोबोट अनुप्रयोगों में दृश्य धारणा, वस्तु का पता लगाने और नेविगेशन जैसे कार्यों के लिए उपयोग किया जाता है।

ROS Gazebo में डिटेक्शन और सेगमेंटेशन

छवि चरण-दर-चरण उपयोग

निम्न कोड स्निपेट प्रदर्शित करता है कि Ultralytics YOLO आरओएस के साथ पैकेज। इस उदाहरण में, हम एक कैमरा विषय की सदस्यता लेते हैं, आने वाली छवि का उपयोग करके प्रक्रिया करते हैं YOLO, और पता लगाए गए ऑब्जेक्ट्स को पता लगाने और विभाजन के लिए नए विषयों पर प्रकाशित करें

सबसे पहले, आवश्यक पुस्तकालयों को आयात करें और दो मॉडल तत्काल करें: एक के लिए एक खंड और एक के लिए खोज. आरओएस नोड को इनिशियलाइज़ करें (नाम के साथ ultralytics) आरओएस मास्टर के साथ संचार को सक्षम करने के लिए। एक स्थिर कनेक्शन सुनिश्चित करने के लिए, हम एक संक्षिप्त विराम शामिल करते हैं, जिससे नोड को आगे बढ़ने से पहले कनेक्शन स्थापित करने के लिए पर्याप्त समय मिलता है।

import time

import rospy

from ultralytics import YOLO

detection_model = YOLO("yolov8m.pt")
segmentation_model = YOLO("yolov8m-seg.pt")
rospy.init_node("ultralytics")
time.sleep(1)

दो आरओएस विषयों को प्रारंभ करें: एक के लिए खोज और एक के लिए एक खंड. इन विषयों का उपयोग एनोटेट की गई छवियों को प्रकाशित करने के लिए किया जाएगा, जिससे उन्हें आगे की प्रक्रिया के लिए सुलभ बनाया जा सके। नोड्स के बीच संचार का उपयोग करके सुविधा प्रदान की जाती है sensor_msgs/Image संदेश।

from sensor_msgs.msg import Image

det_image_pub = rospy.Publisher("/ultralytics/detection/image", Image, queue_size=5)
seg_image_pub = rospy.Publisher("/ultralytics/segmentation/image", Image, queue_size=5)

अंत में, एक सब्सक्राइबर बनाएं जो संदेशों को सुनता है /camera/color/image_raw विषय और प्रत्येक नए संदेश के लिए कॉलबैक फ़ंक्शन को कॉल करता है। यह कॉलबैक फ़ंक्शन प्रकार के संदेश प्राप्त करता है sensor_msgs/Image, का उपयोग कर उन्हें एक numpy सरणी में परिवर्तित करता है ros_numpy, पहले तत्काल के साथ छवियों को संसाधित करता है YOLO मॉडल, छवियों को एनोटेट करता है, और फिर उन्हें संबंधित विषयों पर वापस प्रकाशित करता है: /ultralytics/detection/image पता लगाने के लिए और /ultralytics/segmentation/image विभाजन के लिए।

import ros_numpy


def callback(data):
    """Callback function to process image and publish annotated images."""
    array = ros_numpy.numpify(data)
    if det_image_pub.get_num_connections():
        det_result = detection_model(array)
        det_annotated = det_result[0].plot(show=False)
        det_image_pub.publish(ros_numpy.msgify(Image, det_annotated, encoding="rgb8"))

    if seg_image_pub.get_num_connections():
        seg_result = segmentation_model(array)
        seg_annotated = seg_result[0].plot(show=False)
        seg_image_pub.publish(ros_numpy.msgify(Image, seg_annotated, encoding="rgb8"))


rospy.Subscriber("/camera/color/image_raw", Image, callback)

while True:
    rospy.spin()
पूरा कोड
import time

import ros_numpy
import rospy
from sensor_msgs.msg import Image

from ultralytics import YOLO

detection_model = YOLO("yolov8m.pt")
segmentation_model = YOLO("yolov8m-seg.pt")
rospy.init_node("ultralytics")
time.sleep(1)

det_image_pub = rospy.Publisher("/ultralytics/detection/image", Image, queue_size=5)
seg_image_pub = rospy.Publisher("/ultralytics/segmentation/image", Image, queue_size=5)


def callback(data):
    """Callback function to process image and publish annotated images."""
    array = ros_numpy.numpify(data)
    if det_image_pub.get_num_connections():
        det_result = detection_model(array)
        det_annotated = det_result[0].plot(show=False)
        det_image_pub.publish(ros_numpy.msgify(Image, det_annotated, encoding="rgb8"))

    if seg_image_pub.get_num_connections():
        seg_result = segmentation_model(array)
        seg_annotated = seg_result[0].plot(show=False)
        seg_image_pub.publish(ros_numpy.msgify(Image, seg_annotated, encoding="rgb8"))


rospy.Subscriber("/camera/color/image_raw", Image, callback)

while True:
    rospy.spin()
डीबगिंग

सिस्टम की वितरित प्रकृति के कारण ROS (रोबोट ऑपरेटिंग सिस्टम) नोड्स को डिबग करना चुनौतीपूर्ण हो सकता है। कई उपकरण इस प्रक्रिया में सहायता कर सकते हैं:

  1. rostopic echo <TOPIC-NAME> : यह आदेश आपको किसी विशिष्ट विषय पर प्रकाशित संदेशों को देखने की अनुमति देता है, जिससे आपको डेटा प्रवाह का निरीक्षण करने में मदद मिलती है।
  2. rostopic list: आरओएस सिस्टम में सभी उपलब्ध विषयों को सूचीबद्ध करने के लिए इस कमांड का उपयोग करें, जिससे आपको सक्रिय डेटा स्ट्रीम का अवलोकन मिल सके।
  3. rqt_graph: यह विज़ुअलाइज़ेशन टूल नोड्स के बीच संचार ग्राफ़ प्रदर्शित करता है, जो इस बात की जानकारी प्रदान करता है कि नोड्स कैसे परस्पर जुड़े हुए हैं और वे कैसे इंटरैक्ट करते हैं।
  4. अधिक जटिल विज़ुअलाइज़ेशन के लिए, जैसे 3D प्रतिनिधित्व, आप उपयोग कर सकते हैं आरविज़. RViz (ROS Visualization) ROS के लिए एक शक्तिशाली 3D विज़ुअलाइज़ेशन टूल है। यह आपको वास्तविक समय में अपने रोबोट की स्थिति और उसके पर्यावरण की कल्पना करने की अनुमति देता है। RViz के साथ, आप सेंसर डेटा देख सकते हैं (उदा। sensors_msgs/Image), रोबोट मॉडल राज्यों, और विभिन्न अन्य प्रकार की जानकारी, जिससे आपके रोबोट सिस्टम के व्यवहार को डीबग करना और समझना आसान हो जाता है।

के साथ पता लगाया गया कक्षाएं प्रकाशित करें std_msgs/String

मानक आरओएस संदेशों में भी शामिल हैं std_msgs/String संदेश। कई अनुप्रयोगों में, संपूर्ण एनोटेट की गई छवि को पुनः प्रकाशित करना आवश्यक नहीं है; इसके बजाय, केवल रोबोट के दृश्य में मौजूद वर्गों की आवश्यकता होती है। निम्न उदाहरण प्रदर्शित करता है कि उपयोग कैसे करें std_msgs/String संदेश पर पता लगाए गए वर्गों को पुनः प्रकाशित करने के लिए /ultralytics/detection/classes विचार-विषय। ये संदेश अधिक हल्के होते हैं और आवश्यक जानकारी प्रदान करते हैं, जिससे वे विभिन्न अनुप्रयोगों के लिए मूल्यवान हो जाते हैं।

उदाहरण उपयोग का मामला

एक कैमरा और वस्तु से लैस एक गोदाम रोबोट पर विचार करें डिटेक्शन मॉडल. नेटवर्क पर बड़ी एनोटेट की गई छवियों को भेजने के बजाय, रोबोट पता लगाए गए वर्गों की एक सूची प्रकाशित कर सकता है std_msgs/String संदेश। उदाहरण के लिए, जब रोबोट "बॉक्स", "पैलेट" और "फोर्कलिफ्ट" जैसी वस्तुओं का पता लगाता है तो यह इन वर्गों को प्रकाशित करता है /ultralytics/detection/classes विचार-विषय। इस जानकारी का उपयोग केंद्रीय निगरानी प्रणाली द्वारा वास्तविक समय में इन्वेंट्री को ट्रैक करने, बाधाओं से बचने के लिए रोबोट की पथ योजना को अनुकूलित करने, या विशिष्ट कार्यों को ट्रिगर करने जैसे कि एक पता लगाए गए बॉक्स को चुनने के लिए किया जा सकता है। यह दृष्टिकोण संचार के लिए आवश्यक बैंडविड्थ को कम करता है और महत्वपूर्ण डेटा संचारित करने पर केंद्रित है।

स्ट्रिंग चरण-दर-चरण उपयोग

यह उदाहरण दर्शाता है कि इसका उपयोग कैसे करें Ultralytics YOLO आरओएस के साथ पैकेज। इस उदाहरण में, हम एक कैमरा विषय की सदस्यता लेते हैं, आने वाली छवि का उपयोग करके प्रक्रिया करते हैं YOLO, और नए विषय के लिए खोजे गए ऑब्जेक्ट्स प्रकाशित करें /ultralytics/detection/classes का उपयोग करके std_msgs/String संदेश। वही ros_numpy पैकेज का उपयोग आरओएस छवि संदेश को प्रसंस्करण के लिए एक सुन्न सरणी में बदलने के लिए किया जाता है YOLO.

import time

import ros_numpy
import rospy
from sensor_msgs.msg import Image
from std_msgs.msg import String

from ultralytics import YOLO

detection_model = YOLO("yolov8m.pt")
rospy.init_node("ultralytics")
time.sleep(1)
classes_pub = rospy.Publisher("/ultralytics/detection/classes", String, queue_size=5)


def callback(data):
    """Callback function to process image and publish detected classes."""
    array = ros_numpy.numpify(data)
    if classes_pub.get_num_connections():
        det_result = detection_model(array)
        classes = det_result[0].boxes.cls.cpu().numpy().astype(int)
        names = [det_result[0].names[i] for i in classes]
        classes_pub.publish(String(data=str(names)))


rospy.Subscriber("/camera/color/image_raw", Image, callback)
while True:
    rospy.spin()

प्रयोग Ultralytics आरओएस गहराई छवियों के साथ

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

एक गहराई छवि एक छवि है जहां प्रत्येक पिक्सेल कैमरे से किसी वस्तु की दूरी का प्रतिनिधित्व करता है। रंग कैप्चर करने वाली आरजीबी छवियों के विपरीत, गहराई वाली छवियां स्थानिक जानकारी को कैप्चर करती हैं, जिससे रोबोट अपने पर्यावरण की 3 डी संरचना को समझ सकते हैं।

गहराई छवियाँ प्राप्त करना

विभिन्न सेंसर का उपयोग करके गहराई की छवियां प्राप्त की जा सकती हैं:

  1. स्टीरियो कैमरा: छवि असमानता के आधार पर गहराई की गणना करने के लिए दो कैमरों का उपयोग करें।
  2. टाइम-ऑफ-फ्लाइट (टीओएफ) कैमरे: किसी वस्तु से लौटने में प्रकाश को लगने वाले समय को मापें।
  3. संरचित प्रकाश सेंसर: एक पैटर्न प्रोजेक्ट करें और सतहों पर इसके विरूपण को मापें।

का उपयोग करके YOLO गहराई छवियों के साथ

आरओएस में, गहराई छवियों को द्वारा दर्शाया जाता है sensor_msgs/Image संदेश प्रकार, जिसमें एन्कोडिंग के लिए फ़ील्ड, ऊँचाई, चौड़ाई और पिक्सेल डेटा शामिल हैं. गहराई छवियों के लिए एन्कोडिंग फ़ील्ड अक्सर "16UC1" जैसे प्रारूप का उपयोग करता है, जो प्रति पिक्सेल 16-बिट अहस्ताक्षरित पूर्णांक को दर्शाता है, जहां प्रत्येक मान ऑब्जेक्ट की दूरी का प्रतिनिधित्व करता है। पर्यावरण के बारे में अधिक व्यापक दृष्टिकोण प्रदान करने के लिए गहराई छवियों का उपयोग आमतौर पर RGB छवियों के संयोजन में किया जाता है।

का उपयोग करके YOLO, आरजीबी और गहराई छवियों दोनों से जानकारी निकालना और संयोजित करना संभव है। उदाहरणार्थ YOLO आरजीबी छवि के भीतर वस्तुओं का पता लगा सकता है, और इस पहचान का उपयोग गहराई छवि में संबंधित क्षेत्रों को इंगित करने के लिए किया जा सकता है। यह पता लगाई गई वस्तुओं के लिए सटीक गहराई की जानकारी निकालने की अनुमति देता है, जिससे रोबोट की तीन आयामों में अपने पर्यावरण को समझने की क्षमता बढ़ जाती है।

आरजीबी-डी कैमरा

गहराई वाली छवियों के साथ काम करते समय, यह सुनिश्चित करना आवश्यक है कि RGB और गहराई वाली छवियां सही ढंग से संरेखित हों। RGB-D कॅमेरे, जसे की Intel RealSense श्रृंखला, सिंक्रनाइज़ RGB और गहराई वाली छवियां प्रदान करती है, जिससे दोनों स्रोतों से जानकारी को संयोजित करना आसान हो जाता है। यदि अलग आरजीबी और गहराई कैमरों का उपयोग कर रहे हैं, तो सटीक संरेखण सुनिश्चित करने के लिए उन्हें जांचना महत्वपूर्ण है।

गहराई चरण-दर-चरण उपयोग

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

import time

import rospy
from std_msgs.msg import String

from ultralytics import YOLO

rospy.init_node("ultralytics")
time.sleep(1)

segmentation_model = YOLO("yolov8m-seg.pt")

classes_pub = rospy.Publisher("/ultralytics/detection/distance", String, queue_size=5)

अगला, एक कॉलबैक फ़ंक्शन को परिभाषित करें जो आने वाली गहराई छवि संदेश को संसाधित करता है। फ़ंक्शन गहराई छवि और RGB छवि संदेशों की प्रतीक्षा करता है, उन्हें सुन्न सरणियों में परिवर्तित करता है, और RGB छवि पर विभाजन मॉडल लागू करता है। यह तब प्रत्येक पता लगाया वस्तु के लिए विभाजन मुखौटा निकालता है और गहराई छवि का उपयोग कर कैमरे से वस्तु की औसत दूरी की गणना करता है. अधिकांश सेंसर में अधिकतम दूरी होती है, जिसे क्लिप दूरी के रूप में जाना जाता है, जिसके आगे मानों को inf (np.inf). प्रसंस्करण से पहले, इन शून्य मानों को फ़िल्टर करना और उन्हें 0. अंत में, यह पता लगाई गई वस्तुओं को उनकी औसत दूरी के साथ प्रकाशित करता है /ultralytics/detection/distance विचार-विषय।

import numpy as np
import ros_numpy
from sensor_msgs.msg import Image


def callback(data):
    """Callback function to process depth image and RGB image."""
    image = rospy.wait_for_message("/camera/color/image_raw", Image)
    image = ros_numpy.numpify(image)
    depth = ros_numpy.numpify(data)
    result = segmentation_model(image)

    for index, cls in enumerate(result[0].boxes.cls):
        class_index = int(cls.cpu().numpy())
        name = result[0].names[class_index]
        mask = result[0].masks.data.cpu().numpy()[index, :, :].astype(int)
        obj = depth[mask == 1]
        obj = obj[~np.isnan(obj)]
        avg_distance = np.mean(obj) if len(obj) else np.inf

    classes_pub.publish(String(data=str(all_objects)))


rospy.Subscriber("/camera/depth/image_raw", Image, callback)

while True:
    rospy.spin()
पूरा कोड
import time

import numpy as np
import ros_numpy
import rospy
from sensor_msgs.msg import Image
from std_msgs.msg import String

from ultralytics import YOLO

rospy.init_node("ultralytics")
time.sleep(1)

segmentation_model = YOLO("yolov8m-seg.pt")

classes_pub = rospy.Publisher("/ultralytics/detection/distance", String, queue_size=5)


def callback(data):
    """Callback function to process depth image and RGB image."""
    image = rospy.wait_for_message("/camera/color/image_raw", Image)
    image = ros_numpy.numpify(image)
    depth = ros_numpy.numpify(data)
    result = segmentation_model(image)

    for index, cls in enumerate(result[0].boxes.cls):
        class_index = int(cls.cpu().numpy())
        name = result[0].names[class_index]
        mask = result[0].masks.data.cpu().numpy()[index, :, :].astype(int)
        obj = depth[mask == 1]
        obj = obj[~np.isnan(obj)]
        avg_distance = np.mean(obj) if len(obj) else np.inf

    classes_pub.publish(String(data=str(all_objects)))


rospy.Subscriber("/camera/depth/image_raw", Image, callback)

while True:
    rospy.spin()

प्रयोग Ultralytics आरओएस के साथ sensor_msgs/PointCloud2

ROS Gazebo में डिटेक्शन और सेगमेंटेशन

वही sensor_msgs/PointCloud2 संदेश प्रकार एक डेटा संरचना है जिसका उपयोग आरओएस में 3 डी बिंदु क्लाउड डेटा का प्रतिनिधित्व करने के लिए किया जाता है। यह संदेश प्रकार रोबोटिक अनुप्रयोगों का अभिन्न अंग है, जो 3D मैपिंग, ऑब्जेक्ट पहचान और स्थानीयकरण जैसे कार्यों को सक्षम करता है।

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

संदर्भ फ्रेम

साथ काम करते समय sensor_msgs/PointCloud2, सेंसर के संदर्भ फ्रेम पर विचार करना आवश्यक है जिससे बिंदु क्लाउड डेटा प्राप्त किया गया था। बिंदु बादल शुरू में सेंसर के संदर्भ फ्रेम में कब्जा कर लिया है। आप इस संदर्भ फ्रेम को सुनकर निर्धारित कर सकते हैं /tf_static विचार-विषय। हालाँकि, आपकी विशिष्ट एप्लिकेशन आवश्यकताओं के आधार पर, आपको पॉइंट क्लाउड को किसी अन्य संदर्भ फ़्रेम में बदलने की आवश्यकता हो सकती है। इस परिवर्तन का उपयोग करके प्राप्त किया जा सकता है tf2_ros पैकेज, जो समन्वय फ़्रेम के प्रबंधन और उनके बीच डेटा को बदलने के लिए उपकरण प्रदान करता है।

बिंदु बादल प्राप्त करना

विभिन्न सेंसर का उपयोग करके प्वाइंट क्लाउड प्राप्त किए जा सकते हैं:

  1. LIDAR (लाइट डिटेक्शन एंड रेंजिंग): वस्तुओं की दूरी मापने और उच्च-सटीक 3D मानचित्र बनाने के लिए लेजर दालों का उपयोग करता है।
  2. गहराई कैमरे: प्रत्येक पिक्सेल के लिए गहराई की जानकारी कैप्चर करें, जिससे दृश्य के 3D पुनर्निर्माण की अनुमति मिलती है।
  3. स्टीरियो कैमरा: त्रिकोणीय के माध्यम से गहराई की जानकारी प्राप्त करने के लिए दो या अधिक कैमरों का उपयोग करें।
  4. संरचित प्रकाश स्कैनर: एक सतह पर एक ज्ञात पैटर्न प्रोजेक्ट करें और गहराई की गणना करने के लिए विरूपण को मापें।

का उपयोग करके YOLO बिंदु बादलों के साथ

एकीकृत करने के लिए YOLO के साथ sensor_msgs/PointCloud2 संदेश टाइप करें, हम गहराई के नक्शे के लिए उपयोग की जाने वाली विधि के समान एक विधि को नियोजित कर सकते हैं। पॉइंट क्लाउड में एम्बेडेड रंग जानकारी का लाभ उठाकर, हम एक 2D छवि निकाल सकते हैं, इस छवि का उपयोग करके विभाजन कर सकते हैं YOLO, और फिर परिणामी मुखौटा को ब्याज की 3D वस्तु को अलग करने के लिए त्रि-आयामी बिंदुओं पर लागू करें।

बिंदु बादलों को संभालने के लिए, हम Open3D (pip install open3d), एक उपयोगकर्ता के अनुकूल Python पुस्तकालय। Open3D पॉइंट क्लाउड डेटा संरचनाओं के प्रबंधन, उनकी कल्पना करने और जटिल संचालन को मूल रूप से निष्पादित करने के लिए मजबूत उपकरण प्रदान करता है। यह पुस्तकालय प्रक्रिया को काफी सरल बना सकता है और बिंदु बादलों के संयोजन में हेरफेर और विश्लेषण करने की हमारी क्षमता को बढ़ा सकता है YOLO-आधारित विभाजन।

प्वाइंट क्लाउड चरण-दर-चरण उपयोग

आवश्यक पुस्तकालयों को आयात करें और YOLO विभाजन के लिए मॉडल।

import time

import rospy

from ultralytics import YOLO

rospy.init_node("ultralytics")
time.sleep(1)
segmentation_model = YOLO("yolov8m-seg.pt")

एक फ़ंक्शन बनाएँ pointcloud2_to_array, जो एक sensor_msgs/PointCloud2 दो सुन्न सरणियों में संदेश। वही sensor_msgs/PointCloud2 संदेशों में शामिल हैं n अंक के आधार पर width और height अधिग्रहित छवि का। उदाहरण के लिए, एक 480 x 640 छवि होगी 307,200 अंक। प्रत्येक बिंदु में तीन स्थानिक निर्देशांक शामिल हैं (xyz) और इसी रंग में RGB प्रारूप। इन्हें सूचना के दो अलग-अलग चैनल माना जा सकता है।

फ़ंक्शन xyz coordinates और RGB मूल कैमरा रिज़ॉल्यूशन के प्रारूप में मान (width x height). अधिकांश सेंसर में अधिकतम दूरी होती है, जिसे क्लिप दूरी के रूप में जाना जाता है, जिसके आगे मानों को inf (np.inf). प्रसंस्करण से पहले, इन शून्य मानों को फ़िल्टर करना और उन्हें 0.

import numpy as np
import ros_numpy


def pointcloud2_to_array(pointcloud2: PointCloud2) -> tuple:
    """
    Convert a ROS PointCloud2 message to a numpy array.

    Args:
        pointcloud2 (PointCloud2): the PointCloud2 message

    Returns:
        (tuple): tuple containing (xyz, rgb)
    """
    pc_array = ros_numpy.point_cloud2.pointcloud2_to_array(pointcloud2)
    split = ros_numpy.point_cloud2.split_rgb_field(pc_array)
    rgb = np.stack([split["b"], split["g"], split["r"]], axis=2)
    xyz = ros_numpy.point_cloud2.get_xyz_points(pc_array, remove_nans=False)
    xyz = np.array(xyz).reshape((pointcloud2.height, pointcloud2.width, 3))
    nan_rows = np.isnan(xyz).all(axis=2)
    xyz[nan_rows] = [0, 0, 0]
    rgb[nan_rows] = [0, 0, 0]
    return xyz, rgb

इसके बाद, सदस्यता लें /camera/depth/points विषय बिंदु क्लाउड संदेश प्राप्त करने और sensor_msgs/PointCloud2 XYZ निर्देशांक और RGB मानों वाले numpy सरणियों में संदेश ( pointcloud2_to_array समारोह)। RGB इमेज को वापरून प्रोसेस करा YOLO खंडित वस्तुओं को निकालने के लिए मॉडल। प्रत्येक पता चला वस्तु के लिए, विभाजन मुखौटा निकालने और 3 डी अंतरिक्ष में वस्तु को अलग करने के लिए आरजीबी छवि और XYZ निर्देशांक दोनों के लिए इसे लागू होते हैं.

मुखौटा प्रसंस्करण सीधा है क्योंकि इसमें बाइनरी मान होते हैं, साथ 1 वस्तु की उपस्थिति का संकेत और 0 अनुपस्थिति का संकेत देते हुए। मास्क लगाने के लिए, बस मूल चैनलों को मास्क से गुणा करें। यह ऑपरेशन छवि के भीतर रुचि की वस्तु को प्रभावी ढंग से अलग करता है। अंत में, एक Open3D पॉइंट क्लाउड ऑब्जेक्ट बनाएं और संबंधित रंगों के साथ 3D स्पेस में खंडित ऑब्जेक्ट की कल्पना करें।

import sys

import open3d as o3d

ros_cloud = rospy.wait_for_message("/camera/depth/points", PointCloud2)
xyz, rgb = pointcloud2_to_array(ros_cloud)
result = segmentation_model(rgb)

if not len(result[0].boxes.cls):
    print("No objects detected")
    sys.exit()

classes = result[0].boxes.cls.cpu().numpy().astype(int)
for index, class_id in enumerate(classes):
    mask = result[0].masks.data.cpu().numpy()[index, :, :].astype(int)
    mask_expanded = np.stack([mask, mask, mask], axis=2)

    obj_rgb = rgb * mask_expanded
    obj_xyz = xyz * mask_expanded

    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(obj_xyz.reshape((ros_cloud.height * ros_cloud.width, 3)))
    pcd.colors = o3d.utility.Vector3dVector(obj_rgb.reshape((ros_cloud.height * ros_cloud.width, 3)) / 255)
    o3d.visualization.draw_geometries([pcd])
पूरा कोड
import sys
import time

import numpy as np
import open3d as o3d
import ros_numpy
import rospy

from ultralytics import YOLO

rospy.init_node("ultralytics")
time.sleep(1)
segmentation_model = YOLO("yolov8m-seg.pt")


def pointcloud2_to_array(pointcloud2: PointCloud2) -> tuple:
    """
    Convert a ROS PointCloud2 message to a numpy array.

    Args:
        pointcloud2 (PointCloud2): the PointCloud2 message

    Returns:
        (tuple): tuple containing (xyz, rgb)
    """
    pc_array = ros_numpy.point_cloud2.pointcloud2_to_array(pointcloud2)
    split = ros_numpy.point_cloud2.split_rgb_field(pc_array)
    rgb = np.stack([split["b"], split["g"], split["r"]], axis=2)
    xyz = ros_numpy.point_cloud2.get_xyz_points(pc_array, remove_nans=False)
    xyz = np.array(xyz).reshape((pointcloud2.height, pointcloud2.width, 3))
    nan_rows = np.isnan(xyz).all(axis=2)
    xyz[nan_rows] = [0, 0, 0]
    rgb[nan_rows] = [0, 0, 0]
    return xyz, rgb


ros_cloud = rospy.wait_for_message("/camera/depth/points", PointCloud2)
xyz, rgb = pointcloud2_to_array(ros_cloud)
result = segmentation_model(rgb)

if not len(result[0].boxes.cls):
    print("No objects detected")
    sys.exit()

classes = result[0].boxes.cls.cpu().numpy().astype(int)
for index, class_id in enumerate(classes):
    mask = result[0].masks.data.cpu().numpy()[index, :, :].astype(int)
    mask_expanded = np.stack([mask, mask, mask], axis=2)

    obj_rgb = rgb * mask_expanded
    obj_xyz = xyz * mask_expanded

    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(obj_xyz.reshape((ros_cloud.height * ros_cloud.width, 3)))
    pcd.colors = o3d.utility.Vector3dVector(obj_rgb.reshape((ros_cloud.height * ros_cloud.width, 3)) / 255)
    o3d.visualization.draw_geometries([pcd])

प्वाइंट क्लाउड सेगमेंटेशन के साथ Ultralytics

अक्सर पूछे जाने वाले प्रश्न

रोबोट ऑपरेटिंग सिस्टम (ROS) क्या है?

रोबोट ऑपरेटिंग सिस्टम (आरओएस) एक ओपन-सोर्स फ्रेमवर्क है जिसका उपयोग आमतौर पर रोबोटिक्स में किया जाता है ताकि डेवलपर्स को मजबूत रोबोट एप्लिकेशन बनाने में मदद मिल सके। यह रोबोट सिस्टम के निर्माण और इंटरफेसिंग के लिए पुस्तकालयों और उपकरणों का एक संग्रह प्रदान करता है, जिससे जटिल अनुप्रयोगों का आसान विकास होता है। आरओएस विषयों या सेवाओं पर संदेशों का उपयोग करके नोड्स के बीच संचार का समर्थन करता है

मैं कैसे एकीकृत करूं Ultralytics YOLO वास्तविक समय वस्तु का पता लगाने के लिए आरओएस के साथ?

एकीकरण Ultralytics YOLO आरओएस के साथ एक आरओएस वातावरण स्थापित करना और उपयोग करना शामिल है YOLO सेंसर डेटा को संसाधित करने के लिए। आवश्यक निर्भरताओं को स्थापित करके शुरू करें जैसे ros_numpy और Ultralytics YOLO:

pip install ros_numpy ultralytics

इसके बाद, एक आरओएस नोड बनाएं और आने वाले डेटा को संसाधित करने के लिए एक छवि विषय की सदस्यता लें। यहाँ एक न्यूनतम उदाहरण है:

import ros_numpy
import rospy
from sensor_msgs.msg import Image

from ultralytics import YOLO

detection_model = YOLO("yolov8m.pt")
rospy.init_node("ultralytics")
det_image_pub = rospy.Publisher("/ultralytics/detection/image", Image, queue_size=5)


def callback(data):
    array = ros_numpy.numpify(data)
    det_result = detection_model(array)
    det_annotated = det_result[0].plot(show=False)
    det_image_pub.publish(ros_numpy.msgify(Image, det_annotated, encoding="rgb8"))


rospy.Subscriber("/camera/color/image_raw", Image, callback)
rospy.spin()

आरओएस विषय क्या हैं और उनका उपयोग कैसे किया जाता है Ultralytics YOLO?

ROS विषय प्रकाशित-सदस्यता मॉडल का उपयोग करके ROS नेटवर्क में नोड्स के बीच संचार की सुविधा प्रदान करते हैं। एक विषय एक नामित चैनल है जो नोड्स अतुल्यकालिक रूप से संदेश भेजने और प्राप्त करने के लिए उपयोग करते हैं। के संदर्भ में Ultralytics YOLO, आप एक नोड को एक छवि विषय की सदस्यता ले सकते हैं, छवियों का उपयोग करके संसाधित कर सकते हैं YOLO पता लगाने या विभाजन जैसे कार्यों के लिए, और नए विषयों के लिए परिणाम प्रकाशित करें।

उदाहरण के लिए, कैमरा विषय की सदस्यता लें और पता लगाने के लिए आने वाली छवि को संसाधित करें:

rospy.Subscriber("/camera/color/image_raw", Image, callback)

के साथ गहराई छवियों का उपयोग क्यों करें Ultralytics YOLO आरओएस में?

आरओएस में गहराई छवियां, द्वारा प्रतिनिधित्व किया गया sensor_msgs/Image, कैमरे से वस्तुओं की दूरी प्रदान करें, बाधा से बचाव, 3D मानचित्रण और स्थानीयकरण जैसे कार्यों के लिए महत्वपूर्ण है। द्वारा गहराई से जानकारी का उपयोग करना आरजीबी छवियों के साथ, रोबोट अपने 3 डी वातावरण को बेहतर ढंग से समझ सकते हैं।

के साथ YOLO, आप आरजीबी छवियों से विभाजन मास्क निकाल सकते हैं और सटीक 3 डी ऑब्जेक्ट जानकारी प्राप्त करने के लिए इन मास्क को गहराई से छवियों पर लागू कर सकते हैं, रोबोट की नेविगेट करने और अपने परिवेश के साथ बातचीत करने की क्षमता में सुधार कर सकते हैं।

मैं 3D बिंदु बादलों की कल्पना कैसे कर सकता हूं YOLO आरओएस में?

आरओएस में 3 डी बिंदु बादलों की कल्पना करने के लिए YOLO:

  1. बदलना sensor_msgs/PointCloud2 सुन्न सरणियों के लिए संदेश।
  2. प्रयोग YOLO RGB इमेज को सेगमेंट करने के लिए।
  3. बिंदु बादल विभाजन मुखौटा लागू करें.

विज़ुअलाइज़ेशन के लिए Open3D का उपयोग करके यहां एक उदाहरण दिया गया है:

import sys

import open3d as o3d
import ros_numpy
import rospy
from sensor_msgs.msg import PointCloud2

from ultralytics import YOLO

rospy.init_node("ultralytics")
segmentation_model = YOLO("yolov8m-seg.pt")


def pointcloud2_to_array(pointcloud2):
    pc_array = ros_numpy.point_cloud2.pointcloud2_to_array(pointcloud2)
    split = ros_numpy.point_cloud2.split_rgb_field(pc_array)
    rgb = np.stack([split["b"], split["g"], split["r"]], axis=2)
    xyz = ros_numpy.point_cloud2.get_xyz_points(pc_array, remove_nans=False)
    xyz = np.array(xyz).reshape((pointcloud2.height, pointcloud2.width, 3))
    return xyz, rgb


ros_cloud = rospy.wait_for_message("/camera/depth/points", PointCloud2)
xyz, rgb = pointcloud2_to_array(ros_cloud)
result = segmentation_model(rgb)

if not len(result[0].boxes.cls):
    print("No objects detected")
    sys.exit()

classes = result[0].boxes.cls.cpu().numpy().astype(int)
for index, class_id in enumerate(classes):
    mask = result[0].masks.data.cpu().numpy()[index, :, :].astype(int)
    mask_expanded = np.stack([mask, mask, mask], axis=2)

    obj_rgb = rgb * mask_expanded
    obj_xyz = xyz * mask_expanded

    pcd = o3d.geometry.PointCloud()
    pcd.points = o3d.utility.Vector3dVector(obj_xyz.reshape((-1, 3)))
    pcd.colors = o3d.utility.Vector3dVector(obj_rgb.reshape((-1, 3)) / 255)
    o3d.visualization.draw_geometries([pcd])

यह दृष्टिकोण खंडित वस्तुओं का एक 3 डी विज़ुअलाइज़ेशन प्रदान करता है, जो नेविगेशन और हेरफेर जैसे कार्यों के लिए उपयोगी है।



बनाया गया 2024-06-19, अपडेट किया गया 2024-07-05
लेखक: ग्लेन-जोचर (2), रिजवान मुनव्वर (1), महत्वाकांक्षी-ऑक्टोपस (3)

टिप्पणियाँ