ROS (Robot Operating System) 퀵스타트 가이드

ROS 소개 (캡션) - Open Robotics (Vimeo).

ROS란 무엇입니까?

ROS(Robot Operating System)는 로봇 공학 연구 및 산업에서 널리 사용되는 오픈 소스 프레임워크입니다. ROS는 개발자가 로봇 애플리케이션을 만들 수 있도록 라이브러리 및 도구 모음을 제공합니다. ROS는 다양한 로봇 플랫폼과 함께 작동하도록 설계되어 로봇 전문가를 위한 유연하고 강력한 도구입니다.

ROS의 주요 기능

1. 모듈식 아키텍처: ROS는 모듈식 아키텍처를 가지고 있어 개발자는 노드라는 더 작고 재사용 가능한 구성 요소를 결합하여 복잡한 시스템을 구축할 수 있습니다. 각 노드는 일반적으로 특정 기능을 수행하며 노드는 토픽 또는 서비스를 통해 메시지를 사용하여 서로 통신합니다.

2. 통신 미들웨어: ROS는 프로세스 간 통신 및 분산 컴퓨팅을 지원하는 강력한 통신 인프라를 제공합니다. 이는 데이터 스트림 (토픽)에 대한 게시-구독 모델과 서비스 호출에 대한 요청-응답 모델을 통해 달성됩니다.

3. 하드웨어 추상화: ROS는 하드웨어에 대한 추상화 계층을 제공하여 개발자가 장치에 구애받지 않는 코드를 작성할 수 있도록 합니다. 이를 통해 동일한 코드를 다른 하드웨어 설정과 함께 사용할 수 있어 통합 및 실험이 용이해집니다.

4. 도구 및 유틸리티: ROS는 시각화, 디버깅 및 시뮬레이션을 위한 다양한 도구 및 유틸리티를 제공합니다. 예를 들어 RViz는 센서 데이터 및 로봇 상태 정보를 시각화하는 데 사용되는 반면, Gazebo는 알고리즘 및 로봇 설계를 테스트하기 위한 강력한 시뮬레이션 환경을 제공합니다.

5. 광범위한 생태계: ROS 생태계는 광대하며 지속적으로 성장하고 있으며, 탐색, 조작, 인식 등을 포함한 다양한 로봇 애플리케이션에 사용할 수 있는 수많은 패키지가 있습니다. 커뮤니티는 이러한 패키지의 개발 및 유지 관리에 적극적으로 기여합니다.

ROS 메시지 및 토픽

ROS에서 노드 간의 통신은 메시지와 토픽을 통해 이루어집니다. 메시지는 노드 간에 교환되는 정보를 정의하는 데이터 구조이며, 토픽은 메시지가 송수신되는 명명된 채널입니다. 노드는 토픽에 메시지를 게시하거나 토픽에서 메시지를 구독하여 서로 통신할 수 있습니다. 이 게시-구독 모델은 비동기 통신과 노드 간의 분리를 가능하게 합니다. 로봇 시스템의 각 센서 또는 액추에이터는 일반적으로 데이터를 토픽에 게시하며, 다른 노드에서 이를 소비하여 처리하거나 제어할 수 있습니다. 이 가이드에서는 이미지, 깊이 및 포인트 클라우드 메시지와 카메라 토픽에 중점을 둘 것입니다.

ROS를 사용하여 Ultralytics YOLO 설정

이 가이드는 이 ROS 환경을 사용하여 테스트되었으며, 이는 ROSbot ROS 저장소의 포크입니다. 이 환경에는 Ultralytics YOLO 패키지, 쉬운 설정을 위한 Docker 컨테이너, 포괄적인 ROS 패키지 및 빠른 테스트를 위한 Gazebo 월드가 포함되어 있습니다. Husarion ROSbot 2 PRO와 함께 작동하도록 설계되었습니다. 제공된 코드 예제는 시뮬레이션과 실제를 포함하여 모든 ROS Noetic/Melodic 환경에서 작동합니다.

종속성 설치

ROS 환경 외에도 다음과 같은 종속성을 설치해야 합니다.

• ROS Numpy 패키지: 이는 ROS 이미지 메시지와 numpy 배열 간의 빠른 변환에 필요합니다.

  pip install ros_numpy
  

• Ultralytics 패키지:

  pip install ultralytics
  

ROS와 함께 Ultralytics 사용 sensor_msgs/Image

에 지정되어 있습니다. sensor_msgs/Image 메시지 유형 이미지 데이터를 나타내기 위해 ROS에서 일반적으로 사용됩니다. 인코딩, 높이, 너비 및 픽셀 데이터 필드를 포함하고 있어 카메라 또는 기타 센서에서 캡처한 이미지를 전송하는 데 적합합니다. 이미지 메시지는 시각적 인식과 같은 작업에 대한 로봇 애플리케이션에서 널리 사용됩니다. 객체 감지, 탐색 기능 등이 있습니다.

이미지 단계별 사용법

다음 코드 스니펫은 ROS와 함께 Ultralytics YOLO 패키지를 사용하는 방법을 보여줍니다. 이 예에서는 카메라 토픽을 구독하고 YOLO를 사용하여 들어오는 이미지를 처리한 다음 감지된 객체를 감지 및 분할을 위한 새 토픽에 게시합니다.

먼저 필요한 라이브러리를 가져오고 두 개의 모델(하나는 분할 그리고 하나는 감지. ROS 노드를 초기화합니다(이름은 ultralytics)을 사용하여 ROS 마스터와 통신할 수 있습니다. 안정적인 연결을 위해 짧은 일시 중지를 포함하여 노드가 연결을 설정할 충분한 시간을 확보합니다.

import time

import rospy

from ultralytics import YOLO

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

두 개의 ROS 토픽 초기화: 하나는 다음을 위한 것입니다. 감지 그리고 하나는 분할. 이러한 토픽은 어노테이션이 추가된 이미지를 게시하는 데 사용되어 추가 처리를 위해 액세스할 수 있게 합니다. 노드 간의 통신은 다음을 사용하여 용이하게 이루어집니다. 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("yolo11m.pt")
segmentation_model = YOLO("yolo11m-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()

감지된 클래스 게시 std_msgs/String

표준 ROS 메시지에도 다음이 포함됩니다. std_msgs/String 메시지로 게시합니다. 많은 애플리케이션에서 전체 주석이 달린 이미지를 다시 게시할 필요는 없으며, 대신 로봇의 뷰에 있는 클래스만 필요합니다. 다음 예제에서는 std_msgs/String 메시지 감지된 클래스를 다시 게시하려면 /ultralytics/detection/classes 토픽입니다. 이러한 메시지는 더 가볍고 필수 정보를 제공하므로 다양한 애플리케이션에 유용합니다.

사용 사례 예시

카메라와 객체가 장착된 창고 로봇을 고려하십시오. 감지 모델. 로봇은 네트워크를 통해 큰 어노테이션 이미지를 보내는 대신 감지된 클래스 목록을 다음과 같이 게시할 수 있습니다. std_msgs/String 메시지. 예를 들어 로봇이 "상자", "팔레트" 및 "지게차"와 같은 객체를 감지하면 이러한 클래스를 /ultralytics/detection/classes 토픽입니다. 이 정보는 중앙 모니터링 시스템에서 실시간으로 재고를 추적하거나, 로봇의 경로 계획을 최적화하여 장애물을 피하거나, 감지된 상자를 집어 올리는 등의 특정 작업을 트리거하는 데 사용될 수 있습니다. 이 접근 방식은 통신에 필요한 대역폭을 줄이고 중요한 데이터 전송에 집중합니다.

단계별 문자열 사용법

이 예제에서는 ROS와 함께 Ultralytics YOLO 패키지를 사용하는 방법을 보여줍니다. 이 예제에서는 카메라 토픽을 구독하고 YOLO를 사용하여 들어오는 이미지를 처리하고 탐지된 객체를 새 토픽에 게시합니다. /ultralytics/detection/classes 사용 std_msgs/String 메시지를 사용하는 방법을 보여줍니다. ros_numpy 패키지는 ROS 이미지 메시지를 YOLO로 처리하기 위해 numpy 배열로 변환하는 데 사용됩니다.

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("yolo11m.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()

ROS Depth 이미지와 함께 Ultralytics 사용

RGB 이미지 외에도 ROS는 카메라에서 물체까지의 거리에 대한 정보를 제공하는 깊이 이미지를 지원합니다. 깊이 이미지는 장애물 회피, 3D 매핑 및 현지화와 같은 로봇 애플리케이션에 매우 중요합니다.

깊이 이미지는 각 픽셀이 카메라에서 객체까지의 거리를 나타내는 이미지입니다. 색상을 캡처하는 RGB 이미지와 달리 깊이 이미지는 공간 정보를 캡처하여 로봇이 환경의 3D 구조를 인식할 수 있도록 합니다.

Depth 이미지를 이용한 YOLO 활용

ROS에서 깊이 이미지는 다음으로 표현됩니다. sensor_msgs/Image 메시지 유형에는 인코딩, 높이, 너비 및 픽셀 데이터 필드가 포함됩니다. 깊이 이미지의 인코딩 필드는 종종 픽셀당 16비트 부호 없는 정수를 나타내는 "16UC1"과 같은 형식을 사용하며, 각 값은 객체까지의 거리를 나타냅니다. 깊이 이미지는 일반적으로 RGB 이미지와 함께 사용하여 환경에 대한 보다 포괄적인 뷰를 제공합니다.

YOLO를 사용하면 RGB 이미지와 depth 이미지 모두에서 정보를 추출하고 결합할 수 있습니다. 예를 들어, YOLO는 RGB 이미지 내에서 객체를 감지할 수 있으며, 이 감지 결과를 사용하여 depth 이미지에서 해당 영역을 정확히 찾아낼 수 있습니다. 이를 통해 감지된 객체에 대한 정확한 depth 정보를 추출하여 로봇이 3차원으로 환경을 이해하는 능력을 향상시킬 수 있습니다.

깊이 단계별 사용법

이 예제에서는 YOLO를 사용하여 이미지를 분할하고 추출된 마스크를 적용하여 깊이 이미지에서 객체를 분할합니다. 이를 통해 카메라 초점 중심에서 관심 객체의 각 픽셀 거리를 확인할 수 있습니다. 이 거리 정보를 얻으면 카메라와 장면의 특정 객체 사이의 거리를 계산할 수 있습니다. 필요한 라이브러리를 가져오고, ROS 노드를 생성하고, 분할 모델과 ROS 토픽을 인스턴스화하여 시작합니다.

import time

import rospy
from std_msgs.msg import String

from ultralytics import YOLO

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

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

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

다음으로, 들어오는 깊이 이미지 메시지를 처리하는 콜백 함수를 정의합니다. 이 함수는 깊이 이미지와 RGB 이미지 메시지를 기다리고, 이를 numpy 배열로 변환한 다음, RGB 이미지에 분할 모델을 적용합니다. 그런 다음 감지된 각 객체에 대한 분할 마스크를 추출하고 깊이 이미지를 사용하여 카메라에서 객체까지의 평균 거리를 계산합니다. 대부분의 센서에는 클립 거리라고 하는 최대 거리가 있으며, 이 거리를 초과하는 값은 inf(np.inf). 처리하기 전에 이러한 null 값을 필터링하고 값을 할당하는 것이 중요합니다. 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)

    all_objects = []
    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
        all_objects.append(f"{name}: {avg_distance:.2f}m")

    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("yolo11m-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)

    all_objects = []
    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
        all_objects.append(f"{name}: {avg_distance:.2f}m")

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


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

while True:
    rospy.spin()

ROS와 함께 Ultralytics 사용 sensor_msgs/PointCloud2

에 지정되어 있습니다. sensor_msgs/PointCloud2 메시지 유형 ROS에서 3D 포인트 클라우드 데이터를 나타내는 데 사용되는 데이터 구조입니다. 이 메시지 유형은 3D 매핑, 객체 인식 및 위치 추정과 같은 작업을 가능하게 하여 로봇 애플리케이션에 필수적입니다.

점군(Point cloud)은 3차원 좌표계 내에 정의된 데이터 점의 모음입니다. 이러한 데이터 점은 3D 스캔 기술을 통해 캡처된 객체 또는 장면의 외부 표면을 나타냅니다. 클라우드의 각 점은 다음을 가집니다. X, Y및 Z 좌표는 공간에서의 위치에 해당하며 색상 및 강도와 같은 추가 정보도 포함할 수 있습니다.

Point Cloud를 이용한 YOLO 활용

YOLO를 다음과 통합하려면 sensor_msgs/PointCloud2 type 메시지의 경우, 깊이 맵에 사용된 방법과 유사한 방법을 사용할 수 있습니다. 포인트 클라우드에 내장된 색상 정보를 활용하여 2D 이미지를 추출하고, YOLO를 사용하여 이 이미지에 대한 분할을 수행한 다음, 결과 마스크를 3차원 포인트에 적용하여 관심 있는 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("yolo11m-seg.pt")

함수 생성 pointcloud2_to_array, 다음으로 변환하는 sensor_msgs/PointCloud2 메시지를 두 개의 numpy 배열로 변환합니다. sensor_msgs/PointCloud2 메시지에는 다음이 포함됩니다. n 기반 포인트 width 및 height 획득한 이미지의 예시입니다. 480 x 640 이미지는 다음을 갖습니다. 307,200 포인트. 각 포인트는 세 개의 공간 좌표 (xyz) 및 해당 색상은 RGB format입니다. 이는 두 개의 개별 정보 채널로 간주될 수 있습니다.

이 함수는 다음을 반환합니다. xyz 좌표 및 RGB 원래 카메라 해상도 형식의 값(width x height). 대부분의 센서는 최대 거리가 있으며, 이 거리를 클립 거리라고 합니다. 이 거리를 초과하는 값은 inf(np.inf). 처리하기 전에 이러한 null 값을 필터링하고 값을 할당하는 것이 중요합니다. 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 함수). YOLO 모델을 사용하여 RGB 이미지를 처리하여 분할된 객체를 추출합니다. 감지된 각 객체에 대해 분할 마스크를 추출하고 RGB 이미지와 XYZ 좌표 모두에 적용하여 3D 공간에서 객체를 분리합니다.

마스크는 이진 값으로 구성되어 있으므로 마스크 처리는 간단하며, 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 sensor_msgs.msg import PointCloud2

from ultralytics import YOLO

rospy.init_node("ultralytics")
time.sleep(1)
segmentation_model = YOLO("yolo11m-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])

FAQ

ROS(Robot Operating System)란 무엇입니까?

ROS(Robot Operating System)는 개발자가 강력한 로봇 애플리케이션을 만들 수 있도록 로봇 공학에서 일반적으로 사용되는 오픈 소스 프레임워크입니다. 로봇 시스템을 구축하고 인터페이스하기 위한 라이브러리 및 도구 모음을 제공하여 복잡한 애플리케이션을 보다 쉽게 개발할 수 있습니다. ROS는 토픽 또는 서비스를 통해 메시지를 사용하여 노드 간의 통신을 지원합니다.

실시간 객체 감지를 위해 Ultralytics YOLO를 ROS와 어떻게 통합합니까?

Ultralytics YOLO를 ROS와 통합하려면 ROS 환경을 설정하고 YOLO를 사용하여 센서 데이터를 처리해야 합니다. 먼저 다음과 같은 필요한 종속성을 설치합니다. ros_numpy 그리고 Ultralytics YOLO:

pip install ros_numpy ultralytics

다음으로, ROS 노드를 생성하고 들어오는 데이터를 처리하기 위해 이미지 토픽을 구독합니다. 다음은 최소한의 예입니다.

import ros_numpy
import rospy
from sensor_msgs.msg import Image

from ultralytics import YOLO

detection_model = YOLO("yolo11m.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()

ROS 토픽이란 무엇이며 Ultralytics YOLO에서 어떻게 사용됩니까?

ROS 토픽은 publish-subscribe 모델을 사용하여 ROS 네트워크의 노드 간 통신을 용이하게 합니다. 토픽은 노드가 메시지를 비동기적으로 보내고 받는 데 사용하는 명명된 채널입니다. Ultralytics YOLO의 컨텍스트에서 노드가 이미지 토픽을 구독하고, detection 또는 segmentation과 같은 작업을 위해 YOLO를 사용하여 이미지를 처리하고, 결과를 새 토픽에 게시할 수 있습니다.

예를 들어, 카메라 토픽을 구독하고 들어오는 이미지를 처리하여 객체를 탐지합니다.

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

ROS에서 Ultralytics YOLO와 함께 깊이 이미지를 사용하는 이유는 무엇입니까?

ROS에서 깊이 이미지는 다음과 같이 표현됩니다. sensor_msgs/Image, 카메라로부터 객체까지의 거리를 제공하여 장애물 회피, 3D 매핑 및 위치 파악과 같은 작업에 매우 중요합니다. 다음을 통해 깊이 정보 사용 RGB 이미지와 함께 로봇은 3D 환경을 더 잘 이해할 수 있습니다.

YOLO를 사용하면 RGB 이미지에서 분할 마스크를 추출하고 이러한 마스크를 깊이 이미지에 적용하여 정확한 3D 객체 정보를 얻을 수 있으므로 로봇이 주변 환경을 탐색하고 상호 작용하는 능력이 향상됩니다.

ROS에서 YOLO를 사용하여 3D 포인트 클라우드를 어떻게 시각화합니까?

YOLO를 사용하여 ROS에서 3D 포인트 클라우드를 시각화하려면:

1. 변환 sensor_msgs/PointCloud2 메시지를 numpy 배열로 변환합니다.
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("yolo11m-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])

이 방법은 로봇 애플리케이션에서 탐색 및 조작과 같은 작업에 유용한 분할된 객체의 3D 시각화를 제공합니다.

📅 1년 전에 생성됨 ✏️ 26일 전에 업데이트됨

댓글