Create and use Docker images for ZED and ROS

In this section, we guide you to create a docker image that can run ROS and ZED SDK.

Dockerfile Overview

Specify the parent image

In this section, we first specify the parent Docker image to pull a ZED SDK Docker image. The Ubuntu release year, SDK and CUDA versions are passed as arguments

1 # Build Arguments
2 ARG UBUNTU_RELEASE_YEAR
3 ARG ZED_SDK_MAJOR
4 ARG ZED_SDK_MINOR
5 ARG CUDA_MAJOR
6 ARG CUDA_MINOR
7 
8 # Specify the parent image from which we build
9 FROM stereolabs/zed:${ZED_SDK_MAJOR}.${ZED_SDK_MINOR}-gl-devel-cuda${CUDA_MAJOR}.${CUDA_MINOR}-ubuntu${UBUNTU_RELEASE_YEAR}.04
10 
11 ARG ROS_DISTRO_ARG
12 ENV LOGNAME root
13 ENV ROS_DISTRO ${ROS_DISTRO_ARG}
14 ENV LANG C.UTF-8
15 ENV LC_ALL C.UTF-8

The above section remains the same for both ROS and ROS 2 Dockerfiles.

Install ROS

Once you have specified the source image, you can go ahead and decide on the ROS distribution to be installed.

This Dockerfile.ros installs dependencies based on the versions mentioned, be careful to check the version availability and compatibility.

1 # Setup ROS
2 RUN apt-get update -y || true && \
3     DEBIAN_FRONTEND=noninteractive apt-get install -y tzdata curl && \
4     sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list' && \
5     curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | sudo apt-key add - && \
6     apt-get update || true &&\
7     DEBIAN_FRONTEND=noninteractive apt-get install -y ros-$ROS_DISTRO-desktop-full build-essential cmake usbutils libusb-1.0-0-dev git -y --allow-unauthenticated
8 
9 # Install Packages depending on ROS distro
10 RUN if [ "$ROS_DISTRO_ARG" = "noetic" ] ; then \
11   apt-get install -y python3-rosdep python3-rosinstall  python3-rosinstall-generator python3-wstool ;\
12     else \
13        apt-get install -y python-rosdep  python-rosinstall python-rosinstall-generator python-wstool ; \
14     fi 
15 
16 RUN rm -rf /var/lib/apt/lists/*

Setup the ROS workspace

This final section lets you set up the ROS workspace and get ready to install ROS packages.

1 RUN mkdir -p /opt/ros_ws/src
2 WORKDIR /opt/ros_ws
3 RUN  . /opt/ros/noetic/setup.sh && \
4      catkin_make 
5 
6 # setup entrypoint
7 COPY ./ros_entrypoint.sh /
8 ENTRYPOINT ["/ros_entrypoint.sh"]
9 
10 CMD ["bash"]

Entrypoint

As you can see Dockerfile.ros contain the command ENTRYPOINT ["/ros_entrypoint.sh"]. The ENTRYPOINT specified is the default executable of the image which runs the script ros_entrypoint.sh every time the image is run. You can find this file along with the Dockerfiles here.

$ #!/bin/bash
$ set -e
$ 
$ # setup ros environment
$ source "/opt/ros/$ROS_DISTRO/setup.bash" 
$ source "$ROS_WS/devel/setup.bash"
$ exec "$@"

ros_entrypoint.sh makes sure that the setup.bash file is sourced every time when the image is run. Make sure that this file is present along with your Dockerfile when you build and run the image.

Build Script Overview

Just like the build script for OpenCV dockerfiles, the build-ros-desktop-image.sh file lets you configure the versions which are passed during the build. The script is detailed below.

Configure the arguments

The build arguments remain the same as that of the OpenCV Dockerfile build arguments, except here instead of having the OPENCV_VERSION we have an argument ROS_2_FLAG.

The ROS distro is selected based on the UBUNTU_RELEASE_YEAR , when the release year is 20 ROS_2_FLAG lets you choose between ROS or ROS 2, when the flag is set to 0 ROS distro noetic is installed and when set to 1 ROS 2 Foxy Fitzroy is installed.

These values are default and can be changed to the versions that you intend to build.

$ UBUNTU_RELEASE_YEAR=20  # Specify the Ubuntu release year
$ ZED_SDK_MAJOR=3         # ZED SDK major version 
$ ZED_SDK_MINOR=7         # ZED SDK minor version
$ CUDA_MAJOR=11           # CUDA major version
$ CUDA_MINOR=4            # CUDA minor version 
$ ROS_2_FLAG=0            # Change it to 1 to setup ROS 2

Check for version compatibility

In addition to checking for the versions compatibility it also assigns corresponding $ROS_DISTRO based on the UBUNTU_RELEASE_YEAR.

$ #Check for the version compatibilities
$ 
$ if [ ${UBUNTU_RELEASE_YEAR} == "18" ] ; then
$   echo "Ubuntu 18.04"
$   ROS_DISTRO_ARG="melodic"
$   # Not compatible with CUDA <= 9
$   if [ ${CUDA_MAJOR} -le "9" ] ; then
$     echo "Ubuntu 18.04 Not compatible with CUDA <= 9"
$     exit
$   fi
$ elif [ ${UBUNTU_RELEASE_YEAR} == "20" ] ; then
$   if [ ${ROS_2_FLAG} == 1 ] ; then 
$     ROS_DISTRO_ARG="foxy"
$   else 
$     ROS_DISTRO_ARG="noetic"
$   fi
$   # Not compatible with CUDA <= 10
$   if [ ${CUDA_MAJOR} -le "10" ] ; then
$        echo "Ubuntu 20.04 is not compatible with CUDA <= 10 "
$        exit
$   fi
$ else
$   echo "UBUNTU_RELEASE_YEAR! Allowed values are 18 or 20 "
$   exit
$ fi 
$ 
$ if [ ${CUDA_MAJOR} -ge "11" ] ; then
$   if [ ${ZED_SDK_MINOR} -lt "2" ] ; then # CUDA 11.0 was introduced with 3.2
$     echo "CUDA 11.0 was introduced with 3.2"
$     exit
$   fi
$   if [ ${CUDA_MINOR} -ge "1" ] ; then
$     if [ ${ZED_SDK_MINOR} -lt "3" ] ; then # CUDA 11.1 was introduced with 3.3
$       echo "CUDA 11.1 was introduced with 3.3"
$     exit
$     fi
$   fi
$   if [ ${CUDA_MINOR} == "2" ] || [ ${CUDA_MINOR} == "3" ]  || [ ${CUDA_MINOR} -ge "6" ] ; then 
$     #invalid CUDA versions
$        echo "Invalid CUDA_MINOR! Allowed values : 0,1,4,5"
$        exit
$   fi
$ elif [ ${CUDA_MAJOR} == "10" ] ; then
$   if [ ${CUDA_MINOR} != "0" ] || [ ${CUDA_MINOR} != "2" ] ; then 
$      echo "Invalid CUDA_MINOR! Allowed values are 0 or 2"
$      exit
$   fi
$ else
$   echo "Invalid CUDA_MAJOR! Allowed values are 10 or 11" 
$ fi

Docker build

This section of the script executes docker build for creating the Docker image, since a single script is used to build both ROS and ROS 2 Docker images, the default tag is assigned based on the ROS_2_FLAG. Accordingly, different Dockerfiles are chosen for the build.

$ # Default Tag based on the selected versions
$ if [ ${ROS_2_FLAG} == 1 ] ; then
$   echo "ROS_2 flag == 1 " 
$   TAG="${ZED_SDK_MAJOR}.${ZED_SDK_MINOR}-ros2-gl-devel-cuda${CUDA_MAJOR}.${CUDA_MINOR}-ubuntu${UBUNTU_RELEASE_YEAR}.04"
$   DOCKERFILE="Dockerfile.ros2"
$ else
$   TAG="${ZED_SDK_MAJOR}.${ZED_SDK_MINOR}-ros-gl-devel-cuda${CUDA_MAJOR}.${CUDA_MINOR}-ubuntu${UBUNTU_RELEASE_YEAR}.04"
$   DOCKERFILE="Dockerfile.ros"
$ fi
$            
$ 
$ echo "Building '${TAG}'" 
$ 
$ docker build --build-arg UBUNTU_RELEASE_YEAR=${UBUNTU_RELEASE_YEAR} \
> --build-arg ZED_SDK_MAJOR=${ZED_SDK_MAJOR} \
> --build-arg ZED_SDK_MINOR=${ZED_SDK_MINOR} \
> --build-arg ROS_DISTRO_ARG=${ROS_DISTRO_ARG} \
> --build-arg CUDA_MAJOR=${CUDA_MAJOR} \
> --build-arg CUDA_MINOR=${CUDA_MINOR} \
> -t "${TAG}" -f "${DOCKERFILE}" .