# Install from source

## Install dependencies

The following script will install depthai-core and update usb rules and install depthai devices

```bash
sudo wget -qO- https://raw.githubusercontent.com/luxonis/depthai-ros/main/install_dependencies.sh | sudo bash
```

if you don't have opencv installed then try sudo apt install libopencv-dev

if you don't have rosdep installed and not initialized please execute the following steps:

```bash
sudo apt install python3-rosdep
sudo rosdep init
rosdep update
```

## Setting up procedure

The following setup procedure assumes you have cmake version >= 3.10.2 and OpenCV version >= 4.0.0. We selected dai_ws as the name
for a new folder, as it will be our depthai ros workspace.

 1. mkdir -p dai_ws/src
 2. cd dai_ws/src
 3. git clone --branch <ros-distro> https://github.com/luxonis/depthai-ros.git
 4. cd ..
 5. rosdep install --from-paths src --ignore-src -r -y
 6. source /opt/ros/<ros-distro>/setup.bash
 7. catkin_make_isolated (For ROS1) MAKEFLAGS="-j1 -l1" colcon build (for ROS2)
 8. source devel/setup.bash (For ROS1) & source install/setup.bash (for ROS2)

Note If you are using a lower end PC or RPi, standard building may take a lot of RAM and clog your PC. To avoid that, you can use
build.sh command from your workspace (it just wraps colcon commands): ./src/depthai-ros/build.sh

# Docker

You can additionally build and run docker images on your local machine. To do that, add USB rules as in above step.

### Running prebuilt images

Each tagged version has its own prebuilt docker image. To download and run it:

```bash
xhost +local:docker
```

to enable GUI tools such as rviz or rqt.

Then

```bash
docker run -it -v /dev/:/dev/  --privileged -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix luxonis/depthai-ros:noetic-latest [CMD]
```

Where [CMD] is what's going to be executed when container is initially run and could be for example:

 * bash (it will allow you to browse files and make modifications to the code and rebuild it)
 * zsh (other shell that is installed that has some advantages over bash)
 * roslaunch depthai_ros_driver camera.launch (this is just an example, any launch file will work here) A side note here, launch
   files in depthai_ros_driver have some default parameters set by .yaml files inside the driver. You can either edit them inside
   the container itself, or you can make a .yaml file on your host (let's say /home/YOUR_USERNAME_HERE/params/example_config.yaml)
   and pass it as an argument to the executable, as follows:

```bash
docker run -it -v /dev/:/dev/ -v /home/YOUR_USERNAME_HERE/params:/params --network host --privileged -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix luxonis/depthai-ros:noetic-latest roslaunch depthai_ros_driver camera.launch params_file:=/params/example_config.yaml
```

Note, to make images more compact only some external dependencies are installed, for example if you want to try out RTABMap
example in docker, you have to:

 * Install it by running the container in bash/zsh mode
 * Modify the Dockerfile so that it's installed during building - you'll have to rebuild the container after that.
 * Run base camera node in our container and RTABMap separately on host/ in a separate container (see the launch file on what
   parameters/topic names need to be changed when running separately).

## Building

Clone the repository and inside it run (it matters on which branch you are on):

```bash
docker build --build-arg USE_RVIZ=1 -t depthai-ros .
```

If you find out that you run out of RAM during building, you can also set BUILD_SEQUENTIAL=1 to build packages one at a time, it
should take longer, but use less RAM.

RUN_RVIZ arg means rviz will be installed inside docker. If you want to run it you need to also execute following command (you'll
have to do it again after restarting your PC):

```bash
xhost +local:docker
```

Then you can run your image in following way:

```bash
docker run -it -v /dev/:/dev/ --privileged -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix depthai-ros
```

will run an interactive docker session. You can also try:

```bash
docker run -it -v /dev/:/dev/ --privileged -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix depthai-ros roslaunch depthai_examples stereo_inertial_node.launch.py
```

to run a launch file of your choice.

NOTE ROS2 Humble docker image uses Cyclone as RMW implementation.

### Running docker image on ROS1

```bash
docker run -it -v /dev/:/dev/ --privileged -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix depthai-ros roslaunch depthai_examples stereo_inertial_node.launch
```

Will only start stereo_inertial_node launch file (you can try different commands).

### Running docker image on ROS2

```bash
docker run -it -v /dev/:/dev/ --privileged -e DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix depthai-ros ros2 launch depthai_examples stereo_inertial_node.launch.py
```