Isaac ROS image_pipeline package for hardware-accelerated image processing in ROS2.

Last update: Dec 15, 2022

Overview

`isaac_ros_image_pipeline`

Overview

This metapackage offers similar functionality as the standard, CPU-based image_pipeline metapackage, but does so by leveraging the Jetson platform's specialized computer vision hardware. Considerable effort has been made to ensure that replacing image_pipeline with isaac_ros_image_pipeline on a Jetson device is as painless a transition as possible.

System Requirements

This Isaac ROS package is designed and tested to be compatible with ROS2 Foxy on Jetson hardware.

Jetson

AGX Xavier or Xavier NX
JetPack 4.6

x86_64

CUDA 10.2/11.2 supported discrete GPU
VPI 1.1.11
Ubuntu 18.04+

Docker

Precompiled ROS2 Foxy packages are not available for JetPack 4.6 (based on Ubuntu 18.04 Bionic). You can either manually compile ROS2 Foxy and required dependent packages from source or use the Isaac ROS development Docker image from Isaac ROS Common based on images from jetson-containers. The Docker images support both Jetson and x86_64 platfroms. The x86_64 docker image includes VPI Debian packages for CUDA 11.2.

Run the following script in isaac_ros_common to build the image and launch the container:

$ scripts/run_dev.sh <optional_path>

You can either provide an optional path to mirror in your host ROS workspace with Isaac ROS packages, which will be made available in the container as /workspaces/isaac_ros-dev, or you can setup a new workspace in the container.

Package Dependencies

Note: `isaac_ros_common' is used for running tests and/or creating a development container. It also contains VPI Debian packages that can be installed natively on a development machine without a container.

Quickstart

Create a ROS2 workspace if one is not already prepared:
mkdir -p your_ws/src
Note: The workspace can have any name; the quickstart assumes you name it your_ws.
Clone this metapackage repository to your_ws/src/isaac_ros_image_pipeline. Check that you have Git LFS installed before cloning to pull down all large files.
cd your_ws/src && git clone https://github.com/NVIDIA-AI-IOT/isaac_ros_image_pipeline
Build and source the workspace:
cd your_ws && colcon build --symlink-install && source install/setup.bash
(Optional) Run tests to verify complete and correct installation:
colcon test
Start isaac_ros_image_proc using the prebuilt executable:
ros2 run isaac_ros_image_proc isaac_ros_image_proc
In a separate terminal, spin up a calibrated camera publisher to /image_raw and /camera_info using any package(for example, v4l2_camera):
ros2 run v4l2_camera v4l2_camera_node
Observe the rectified image output in grayscale and color on /image_rect and /image_rect_color, respectively:
ros2 run image_view image_view --ros-args -r image:=image_rect
ros2 run image_view image_view --ros-args -r image:=image_rect_color

Replacing `image_pipeline` with `isaac_ros_image_pipeline`

Add a dependency on isaac_ros_image_pipeline to your_package/package.xml and your_package/CMakeLists.txt. If all desired packages under an existing image_pipeline dependency have Isaac ROS alternatives (see Supported Packages), then the original image_pipeline dependency may be removed entirely.
Change the package and plugin names in any *.launch.py launch files to use [package name] and isaac_ros::image_proc::[component_name] respectively. For a list of all packages, see Supported Packages. For a list of all ROS2 Components made available, see the per-package detailed documentation below.

Supported Packages

At this time, the packages under the standard image_pipeline have the following support:

Existing Package	Isaac ROS Alternative
`image_pipeline`	See `isaac_ros_image_pipeline`
`image_proc`	See `isaac_ros_image_proc`
`stereo_image_proc`	See `isaac_ros_stereo_image_proc`
`depth_image_proc`	On roadmap
`camera_calibration`	Continue using existing package
`image_publisher`	Continue using existing package
`image_view`	Continue using existing package
`image_rotate`	Continue using existing package

Tutorial - Stereo Image Pipeline

Connect a compatible Realsense camera (D435, D455) to your host machine.
Build and source the workspace:
cd your_ws && colcon build --symlink-install && source install/setup.bash
Spin up the stereo image pipeline and Realsense camera node with the launchfile:
ros2 launch isaac_ros_stereo_image_proc isaac_ros_stereo_image_pipeline_launch.py

Note For best performance on Jetson, ensure that power settings are configured appropriately (Power Management for Jetson).

ROS2 Package API

`isaac_ros_image_proc`

Overview

The isaac_ros_image_proc package offers functionality for rectifying/undistorting images from a monocular camera setup, resizing the image, and changing the image format. It largely replaces the image_proc package, though the image format conversion facility also functions as a way to replace the CPU-based image format conversion in cv_bridge.

Available Components

Component	Topics Subscribed	Topics Published	Parameters
`ImageFormatConverterNode`	`image_raw`, `camera_info`: The input camera stream	`image`: The converted image	`backends`: The VPI backend to use, which is CUDA by default (options: "CPU", "CUDA", "VIC") `encoding_desired`: Target encoding to convert to. Note: VIC does not support RGB8 and BGR8 for either input or output encoding.
`RectifyNode`	`image`, `camera_info`: The input camera stream	`image_rect`: The rectified image	`interpolation`: The VPI interpolation scheme to use during undistortion, which is Catmull-Rom Spline by default `backends`: The VPI backend to use, which is CUDA by default (options: "CUDA", "VIC")
`ResizeNode`	`image`, `camera_info`: The input camera stream	`resized/image`, `resized/camera_info`: The resized camera stream	`use_relative_scale`: Whether to scale in a relative fashion, which is true by default `scale_height`: The fraction to relatively scale height by `scale_width`: The fraction to relatively scale width by `height`: The absolute height to resize to `width`: The absolute width to resize to `backends`: The VPI backend to use, which is CUDA by default(options: "CPU", "CUDA", "VIC")

`isaac_ros_stereo_image_proc`

Overview

The isaac_ros_stereo_image_proc package offers functionality for handling image pairs from a binocular/stereo camera setup, calculating the disparity between the two images, and producing a point cloud with depth information. It largely replaces the stereo_image_proc package.

Available Components

Component	Topics Subscribed	Topics Published	Parameters
`DisparityNode`	`left/image_rect`, `left/camera_info`: The left camera stream `right/image_rect`, `right/camera_info`: The right camera stream	`disparity`: The disparity between the two cameras	`max_disparity`: The maximum value for disparity per pixel, which is 64 by default. With TEGRA backend, this value must be 256. `window_size`: The window size for SGM, which is 5 by default `backends`: The VPI backend to use, which is CUDA by default (options: "CUDA", "TEGRA")
`PointCloudNode`	`left/image_rect_color`: The coloring for the point cloud `left/camera_info`: The left camera info `right/camera_info`: The right camera info `disparity` The disparity between the two cameras	`points2`: The output point cloud	`queue_size`: The length of the subscription queues, which is `rmw_qos_profile_default.depth` by default `use_color`: Whether or not the output point cloud should have color. The default value is true. `unit_scaling`: The amount to scale the xyz points by

References

[1] D. Scharstein, H. Hirschmüller, Y. Kitajima, G. Krathwohl, N. Nesic, X. Wang, and P. Westling. High-resolution stereo datasets with subpixel-accurate ground truth. In German Conference on Pattern Recognition (GCPR 2014), Münster, Germany, September 2014.

TelloTalent Robomaster TT hardware package for programming the esp32 included with it

TelloTalent esp32 for arduino IDE TelloTalent Robomaster TT hardware package for programming the esp32 included with it Notes All this files are extra

3 Jun 30, 2022

Second life for famous JPEGView - fast and tiny viewer/editor for JPEG, BMP, PNG, WEBP, TGA, GIF and TIFF images with a minimalist GUI and base image processing.

JPEGView-Image-Viewer-and-Editor Updated Dec 07 2021. Version 1.1.1.0 has been released. Download link1, link2 added. Second life for famous JPEGView

40 Dec 27, 2022

An image processing application & library built in C++20 and the Qt Framework.

Comments

Build fails on Jetson AGX with Jetpack 5.0

Error description :

Hello, I've created a new workspace containing only the isaac_ros_common and isaac_ros_image_pipeline packages but the build fails on the isaac_ros_image_proc node.

System setup :

ROS Distro - Foxy Hardware - Nvidia Jetson AGX Ubuntu - 20.04 Jetpack version - 5.0.0

Error message :

/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp: In function ‘cv::Mat {anonymous}::GetConvertedMat(VPIImageImpl*&, VPIImageImpl*&, VPIStreamImpl*&, const cv::Mat&, uint32_t, std::__cxx11::string, std::__cxx11::string)’:
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:68:5: error: ‘vpiImageCreateOpenCVMatWrapper’ was not declared in this scope
     vpiImageCreateOpenCVMatWrapper(
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/xavier/test/install/isaac_ros_common/include/isaac_ros_common/vpi_utilities.hpp:20:25: note: in definition of macro ‘CHECK_STATUS’
     VPIStatus status = (STMT); \
                         ^~~~
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:68:5: note: suggested alternative: ‘vpiImageCreateWrapper’
     vpiImageCreateOpenCVMatWrapper(
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/xavier/test/install/isaac_ros_common/include/isaac_ros_common/vpi_utilities.hpp:20:25: note: in definition of macro ‘CHECK_STATUS’
     VPIStatus status = (STMT); \
                         ^~~~
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:81:61: error: too many arguments to function ‘VPIStatus vpiImageLock(VPIImage, VPILockMode)’
   CHECK_STATUS(vpiImageLock(output, VPI_LOCK_READ, &out_data));
                                                             ^
/home/xavier/test/install/isaac_ros_common/include/isaac_ros_common/vpi_utilities.hpp:20:25: note: in definition of macro ‘CHECK_STATUS’
     VPIStatus status = (STMT); \
                         ^~~~
In file included from /home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:28:
/opt/nvidia/vpi2/include/vpi/Image.h:556:22: note: declared here
 VPI_PUBLIC VPIStatus vpiImageLock(VPIImage img, VPILockMode mode);
                      ^~~~~~~~~~~~
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:82:31: error: ‘VPIImageData’ {aka ‘struct VPIImageDataRec’} has no member named ‘planes’
   cv::Mat output_mat{out_data.planes[0].height, out_data.planes[0].width,
                               ^~~~~~
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:82:58: error: ‘VPIImageData’ {aka ‘struct VPIImageDataRec’} has no member named ‘planes’
   cv::Mat output_mat{out_data.planes[0].height, out_data.planes[0].width,
                                                          ^~~~~~
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:83:54: error: ‘VPIImageData’ {aka ‘struct VPIImageDataRec’} has no member named ‘planes’
     g_str_to_channels.at(encoding_desired), out_data.planes[0].data,
                                                      ^~~~~~
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:84:34: error: ‘VPIImageData’ {aka ‘struct VPIImageDataRec’} has no member named ‘planes’
     static_cast<size_t>(out_data.planes[0].pitchBytes)};
                                  ^~~~~~
/home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:84:55: error: no matching function for call to ‘cv::Mat::Mat(<brace-enclosed initializer list>)’
     static_cast<size_t>(out_data.planes[0].pitchBytes)};
                                                       ^
In file included from /usr/include/opencv4/opencv2/core.hpp:58,
                 from /usr/include/opencv4/opencv2/core/core.hpp:48,
                 from /opt/ros/foxy/include/cv_bridge/cv_bridge.h:43,
                 from /home/xavier/test/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/image_format_converter_node.cpp:20:
/usr/include/opencv4/opencv2/core/mat.hpp:2091:5: note: candidate: ‘cv::Mat::Mat(cv::Mat&&)’
     Mat(Mat&& m);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:2091:5: note:   candidate expects 1 argument, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:1051:14: note: candidate: ‘cv::Mat::Mat(const cv::cuda::GpuMat&)’
     explicit Mat(const cuda::GpuMat& m);
              ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1051:14: note:   candidate expects 1 argument, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:1048:37: note: candidate: ‘template<class _Tp> cv::Mat::Mat(const cv::MatCommaInitializer_<_Tp>&)’
     template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
                                     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1048:37: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1044:37: note: candidate: ‘template<class _Tp> cv::Mat::Mat(const cv::Point3_<_Tp>&, bool)’
     template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
                                     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1044:37: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1040:37: note: candidate: ‘template<class _Tp> cv::Mat::Mat(const cv::Point_<_Tp>&, bool)’
     template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
                                     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1040:37: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1036:51: note: candidate: ‘template<class _Tp, int m, int n> cv::Mat::Mat(const cv::Matx<_Tp, m, n>&, bool)’
     template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
                                                   ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1036:51: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1032:44: note: candidate: ‘template<class _Tp, int n> cv::Mat::Mat(const cv::Vec<_Tp, m>&, bool)’
     template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
                                            ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1032:44: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1028:49: note: candidate: ‘template<class _Tp, long unsigned int _Nm> cv::Mat::Mat(const std::array<_Tp, _Nm>&, bool)’
     template<typename _Tp, size_t _Nm> explicit Mat(const std::array<_Tp, _Nm>& arr, bool copyData=false);
                                                 ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1028:49: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1024:37: note: candidate: ‘template<class _Tp> cv::Mat::Mat(std::initializer_list<int>, std::initializer_list<_Tp>)’
     template<typename _Tp> explicit Mat(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> list);
                                     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1024:37: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1020:14: note: candidate: ‘template<class _Tp, class> cv::Mat::Mat(std::initializer_list<_Tp>)’
     explicit Mat(const std::initializer_list<_Tp> list);
              ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1020:14: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:1015:37: note: candidate: ‘template<class _Tp> cv::Mat::Mat(const std::vector<BufferT>&, bool)’
     template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
                                     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:1015:37: note:   template argument deduction/substitution failed:
/usr/include/opencv4/opencv2/core/mat.hpp:997:5: note: candidate: ‘cv::Mat::Mat(const cv::Mat&, const std::vector<cv::Range>&)’
     Mat(const Mat& m, const std::vector<Range>& ranges);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:997:5: note:   candidate expects 2 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:987:5: note: candidate: ‘cv::Mat::Mat(const cv::Mat&, const cv::Range*)’
     Mat(const Mat& m, const Range* ranges);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:987:5: note:   candidate expects 2 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:977:5: note: candidate: ‘cv::Mat::Mat(const cv::Mat&, const Rect&)’
     Mat(const Mat& m, const Rect& roi);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:977:5: note:   candidate expects 2 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:967:5: note: candidate: ‘cv::Mat::Mat(const cv::Mat&, const cv::Range&, const cv::Range&)’
     Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:967:5: note:   candidate expects 3 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:955:5: note: candidate: ‘cv::Mat::Mat(const std::vector<int>&, int, void*, const size_t*)’
     Mat(const std::vector<int>& sizes, int type, void* data, const size_t* steps=0);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:955:5: note:   candidate expects 4 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:941:5: note: candidate: ‘cv::Mat::Mat(int, const int*, int, void*, const size_t*)’
     Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:941:5: note:   conversion of argument 1 would be ill-formed:
/usr/include/opencv4/opencv2/core/mat.hpp:926:5: note: candidate: ‘cv::Mat::Mat(cv::Size, int, void*, size_t)’
     Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:926:5: note:   candidate expects 4 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:910:5: note: candidate: ‘cv::Mat::Mat(int, int, int, void*, size_t)’
     Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:910:5: note:   conversion of argument 1 would be ill-formed:
/usr/include/opencv4/opencv2/core/mat.hpp:894:5: note: candidate: ‘cv::Mat::Mat(const cv::Mat&)’
     Mat(const Mat& m);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:894:5: note:   candidate expects 1 argument, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:884:5: note: candidate: ‘cv::Mat::Mat(const std::vector<int>&, int, const Scalar&)’
     Mat(const std::vector<int>& sizes, int type, const Scalar& s);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:884:5: note:   candidate expects 3 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:874:5: note: candidate: ‘cv::Mat::Mat(int, const int*, int, const Scalar&)’
     Mat(int ndims, const int* sizes, int type, const Scalar& s);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:874:5: note:   candidate expects 4 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:863:5: note: candidate: ‘cv::Mat::Mat(const std::vector<int>&, int)’
     Mat(const std::vector<int>& sizes, int type);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:863:5: note:   candidate expects 2 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:856:5: note: candidate: ‘cv::Mat::Mat(int, const int*, int)’
     Mat(int ndims, const int* sizes, int type);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:856:5: note:   candidate expects 3 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:848:5: note: candidate: ‘cv::Mat::Mat(cv::Size, int, const Scalar&)’
     Mat(Size size, int type, const Scalar& s);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:848:5: note:   candidate expects 3 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:837:5: note: candidate: ‘cv::Mat::Mat(int, int, int, const Scalar&)’
     Mat(int rows, int cols, int type, const Scalar& s);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:837:5: note:   candidate expects 4 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:826:5: note: candidate: ‘cv::Mat::Mat(cv::Size, int)’
     Mat(Size size, int type);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:826:5: note:   candidate expects 2 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:818:5: note: candidate: ‘cv::Mat::Mat(int, int, int)’
     Mat(int rows, int cols, int type);
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:818:5: note:   candidate expects 3 arguments, 5 provided
/usr/include/opencv4/opencv2/core/mat.hpp:810:5: note: candidate: ‘cv::Mat::Mat()’
     Mat() CV_NOEXCEPT;
     ^~~
/usr/include/opencv4/opencv2/core/mat.hpp:810:5: note:   candidate expects 0 arguments, 5 provided
make[2]: *** [CMakeFiles/image_format_converter_node.dir/build.make:63: CMakeFiles/image_format_converter_node.dir/src/image_format_converter_node.cpp.o] Error 1
make[1]: *** [CMakeFiles/Makefile2:168: CMakeFiles/image_format_converter_node.dir/all] Error 2
make: *** [Makefile:141: all] Error 2
---
Failed   <<< isaac_ros_image_proc [15.8s, exited with code 2]
Aborted  <<< isaac_ros_stereo_image_proc [1min 4s]

Am i missing any dependency ? Thank you in advance !

opened by cordu69 1

VPI_ERROR_OUT_OF_MEMORY: Not enough space for resource allocation

Hello,

after running isaac_ros_image_proc or isaac_ros::image_proc::RectifyNode for a few minutes, it seems to overflow the GPU Memory. In this case, the following error message is shown:

[component_container-2] [ERROR] [1645635774.159060082] [rectify_node]: Error while rectifying image: /workspaces/isaac_ros-dev/src/isaac_ros_image_pipeline/isaac_ros_image_proc/src/rectify_node.cpp:305: VPI_ERROR_OUT_OF_MEMORY: Not enough space for resource allocation

It is running inside a container created by the latest isaac_ros_common and runs on amd64 with a Titan RTX, Driver Version: 470.103.01 and CUDA Version: 11.4 on host OS: Ubuntu 20.04 LTS with Docker 20.10.10. I could also provide some logs, but i don't know which additional information would be helpful.

Kind regards, Patrick

opened by poett1 4