### Install Ansible and Run Docker Setup Playbook

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/installation/autoware/docker-installation.md

Install Ansible, its collection requirements, and then run the Docker setup playbook to prepare the development environment.

```bash
bash ansible/scripts/install-ansible.sh
ansible-galaxy collection install -f -r ansible-galaxy-requirements.yaml
ansible-playbook autoware.dev_env.install_docker
```

--------------------------------

### Install CloudCompare using Snap

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/pointcloud-map-pre-processing/index.md

Use this command to install CloudCompare on your system via snap. Ensure snap is installed and configured.

```bash
sudo snap install cloudcompare
```

--------------------------------

### Run Docker Setup Playbook Without NVIDIA Support

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/installation/autoware/docker-installation.md

Execute the Docker setup playbook, skipping NVIDIA-specific configurations for installations without GPU support.

```bash
ansible-playbook autoware.dev_env.install_docker --skip-tags nvidia
```

--------------------------------

### Example Launch Command for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/creating-vector-map/speed-bump/index.md

An example of the launch command for the planning simulator using the tutorial vehicle configuration.

```bash
ros2 launch autoware_launch planning_simulator.launch.xml map_path:=$HOME/autoware-data/maps/tutorial_map/ vehicle_model:=tutorial_vehicle sensor_model:=tutorial_vehicle_sensor_kit vehicle_id:=tutorial_vehicle
```

--------------------------------

### Example Planning Simulator Launch

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/creating-vector-map/traffic-light/index.md

An example command for launching the planning simulator with specific parameters for the tutorial vehicle.

```bash
ros2 launch autoware_launch planning_simulator.launch.xml map_path:$HOME/autoware_data/maps/tutorial_map/ vehicle_model:=tutorial_vehicle sensor_model:=tutorial_vehicle_sensor_kit vehicle_id:=tutorial_vehicle
```

--------------------------------

### Install and Serve Autoware Documentation Locally

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/README.md

Clone the repository, set up a virtual environment, install dependencies, and serve the documentation locally using MkDocs.

```bash
git clone https://github.com/autowarefoundation/autoware-documentation.git
cd autoware-documentation

python3 -m venv .venv
source .venv/bin/activate

pip install -r mkdocs-requirements.txt

mkdocs serve
```

--------------------------------

### Navigate to Autoware Directory and Source Setup

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/intrinsic-camera-calibration/index.md

Before launching the intrinsic calibrator, navigate to your Autoware installation directory and source the setup script. This ensures that all necessary ROS 2 environment variables are set.

```bash
cd <YOUR-OWN-AUTOWARE-DIRECTORY>
source install/setup.bash
```

--------------------------------

### Start CARLA Server (Headless/GPU)

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/demos/digital-twin-demos/carla-tutorial.md

Starts the CARLA simulator in a headless mode optimized for GPU usage. This is a common setup for running simulations without a graphical display.

```bash
./CarlaUE4.sh -prefernvidia -quality-level=Low -RenderOffScreen
```

--------------------------------

### Install hector-trajectory-server

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/optimized-sc-f-loam/index.md

Install the hector-trajectory-server package for visualization purposes.

```bash
sudo apt-get install ros-noetic-hector-trajectory-server
```

--------------------------------

### Example: Launch Planning Simulator with Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/creating-vehicle-model/index.md

An example of launching the planning simulator with the tutorial vehicle configuration. This demonstrates the expected parameters for vehicle_model, sensor_model, and vehicle_id.

```bash
ros2 launch autoware_launch planning_simulator.launch.xml map_path:=$HOME/autoware_data/maps/sample-map-planning/ vehicle_model:=tutorial_vehicle sensor_model:=tutorial_vehicle_sensor_kit vehicle_id:=tutorial_vehicle
```

--------------------------------

### Verify Docker Installation

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/lidar-imu-calibration/index.md

Runs the 'hello-world' Docker image to confirm that Docker is installed and functioning correctly.

```bash
sudo docker run hello-world
```

--------------------------------

### Install Ccache

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/others/advanced-usage-of-colcon.md

Install the Ccache compiler cache utility. This is the first step to speeding up recompilation times.

```bash
sudo apt update && sudo apt install ccache
```

--------------------------------

### Example: Launch Planning Simulator for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/creating-vector-map/detection-area/index.md

An example command to launch the planning simulator specifically for the tutorial vehicle, including map path, vehicle model, sensor kit, and vehicle ID.

```bash
ros2 launch autoware_launch planning_simulator.launch.xml map_path:=$HOME/autoware_data/maps/tutorial_map/ vehicle_model:=tutorial_vehicle sensor_model:=tutorial_vehicle_sensor_kit vehicle_id:=tutorial_vehicle
```

--------------------------------

### Install TIER IV Calibration Tools

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/installation/related-tools/index.md

Follow these steps to install the calibration tools. Ensure Autoware is already installed. Refer to the README.md for more details.

```bash
cd autoware
wget https://raw.githubusercontent.com/tier4/CalibrationTools/refs/heads/tier4/universe/calibration_tools_autoware.repos
vcs import src < calibration_tools.repos
rosdep install -y --from-paths src --ignore-src --rosdistro $ROS_DISTRO
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release
```

--------------------------------

### Install libomp-dev

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/others/applying-clang-tidy-to-ros-packages.md

Install `libomp-dev` if you encounter `clang-diagnostic-error` issues, as it provides OpenMP support.

```bash
sudo apt-get install libomp-dev
```

--------------------------------

### Setup Autoware Interface Workspace

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/tools/autoware-interfaces/README.md

Clone and build the autoware_adapi_msgs package to set up the necessary environment for document generation. Ensure you source the setup script before proceeding.

```bash
mkdir -p workspace/src
cd workspace/src
git clone https://github.com/autowarefoundation/autoware_adapi_msgs.git
cd ..
colcon build
source install/setup.bash
```

--------------------------------

### Install Git using apt-get

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/installation/autoware/source-installation.md

Installs Git, a version control system, using the apt-get package manager. This is a prerequisite for cloning the Autoware repository.

```bash
sudo apt-get -y update
sudo apt-get -y install git
```

--------------------------------

### Install Ansible Collection and Run Demo Artifacts Playbook

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/demos/planning-sim/index.md

Installs the necessary Ansible collection and then runs the demo_artifacts tag of the install_dev_env playbook to download sample maps.

```bash
ansible-galaxy collection install -f -r "ansible-galaxy-requirements.yaml"
ansible-playbook autoware.dev_env.install_dev_env --tags demo_artifacts --ask-become-pass
```

--------------------------------

### ROS Message README Reference Example

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/contributing/coding-guidelines/ros-nodes/message-guidelines.md

Example of how to reference a README file for illustrative descriptions of message fields.

```text
# please refer to https://github.com/autowarefoundation/autoware_msgs/blob/main/README.md#format for the illustrative description of this field

```

--------------------------------

### Install AWS CLI

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/datasets/index.md

Steps to install the AWS Command Line Interface (AWS CLI) on your machine, necessary for downloading datasets from S3 buckets.

```bash
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

```

--------------------------------

### Example Child Frames for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/ground-lidar-calibration/index.md

This example shows the specific child_frames configuration for the tutorial vehicle, which includes two lidar sensors: rs_helios_top and rs_bpearl_front.

```xml
+   <!-- extrinsic_calibration_manager -->
+   <node pkg="extrinsic_calibration_manager" exec="extrinsic_calibration_manager" name="extrinsic_calibration_manager" output="screen">
+     <param name="parent_frame" value="$(var parent_frame)"/>
+     <!-- add your sensor frames here -->
+     <param name="child_frames" value="
+     [rs_helios_top_base_link,
+     rs_bpearl_front_base_link]"/>
+   </node>
```

--------------------------------

### Sample manual.launch.xml for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/extrinsic-manual-calibration/index.md

This is a complete sample of the manual.launch.xml file for the tutorial_vehicle, including sensor kit and sensor configurations.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<launch>
    <arg name="vehicle_id" default="tutorial_vehicle"/>

    <let name="sensor_model" value="tutorial_vehicle_sensor_kit"/>

    <group>
        <push-ros-namespace namespace="sensor_kit"/>
        <include file="$(find-pkg-share extrinsic_calibration_manager)/launch/$(var sensor_model)/manual_sensor_kit.launch.xml">
            <arg name="vehicle_id" value="$(var vehicle_id)"/>
        </include>
    </group>

    <group>
        <push-ros-namespace namespace="sensors"/>
        <include file="$(find-pkg-share extrinsic_calibration_manager)/launch/$(var sensor_model)/manual_sensors.launch.xml">
          <arg name="vehicle_id" value="$(var vehicle_id)"/>
        </include>
    </group>

</launch>
```

--------------------------------

### Get Motion State

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/design/autoware-architecture-v1/interfaces/ad-api/features/motion.md

Retrieves the current motion state of the vehicle. This can be used to monitor if the vehicle is stopped, starting, or moving.

```APIDOC
## GET /api/motion/state

### Description
Retrieves the current motion state of the vehicle.

### Method
GET

### Endpoint
/api/motion/state

### Response
#### Success Response (200)
- **state** (string) - The current motion state of the vehicle (e.g., STOPPED, STARTING, MOVING).

#### Response Example
{
  "state": "STOPPED"
}
```

--------------------------------

### Unhold CUDA Libraries and Reinstall

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/community/support/troubleshooting/index.md

Use this command to unhold all CUDA-related libraries before rerunning the installation playbook. This can resolve version conflict issues during CUDA setup.

```bash
sudo apt-mark unhold \
  "cuda*" \
  "libcudnn*" \
  "libnvinfer*" \
  "libnvonnxparsers*" \
  "libnvparsers*" \
  "tensorrt*" \
  "nvidia*"

ansible-playbook autoware.dev_env.install_dev_env
```

--------------------------------

### Sample interactive.launch.xml for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/lidar-camera-calibration/index.md

This is a complete example of an `interactive.launch.xml` file configured for a tutorial vehicle. It includes arguments for vehicle ID, sensor model, camera name, RViz integration, and concatenated pointcloud usage.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<launch>
  <arg name="vehicle_id" default="tutorial_vehicle"/>
  <let name="sensor_model" value="tutorial_vehicle_sensor_kit"/>
  <arg name="camera_name"/>
  <arg name="rviz" default="false"/>
  <arg name="use_concatenated_pointcloud" default="true"/>

  <group>
    <push-ros-namespace namespace="sensor_kit"/>
    <include file="$(find-pkg-share extrinsic_calibration_manager)/launch/$(var sensor_model)/interactive_sensor_kit.launch.xml" if="$(var rviz)">
      <arg name="vehicle_id" value="$(var vehicle_id)"/>
      <arg name="camera_name" value="$(var camera_name)"/>
    </include>
  </group>

<!-- You can change the config file path -->
<node pkg="rviz2" exec="rviz2" name="rviz2" output="screen" args="
-d $(find-pkg-share extrinsic_calibration_manager)/config/x2/extrinsic_interactive_calibrator.rviz" if="$(var rviz)"/>
</launch>
```

--------------------------------

### Branch Name Example

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/contributing/pull-request-guidelines/commit-guidelines.md

Branch names should start with the corresponding issue number and use dash-case for separators. This helps in quickly finding related issues and maintains consistency.

```text
123-add-feature
```

```text
123-fix-memory-leak-of-trajectory-follower
```

--------------------------------

### Configure Calibration Parameters

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/lidar-imu-calibration/index.md

Example configuration for the Lidar-IMU calibration tool. Adjust 'topic_lidar', 'topic_imu', 'LidarModel', 'start_time', 'end_time', and 'path_bag' according to your setup and rosbag file.

```yaml
topic_lidar: /sensing/lidar/top/pointcloud_raw
topic_imu: /sensing/gnss/sbg/ros/imu/data

LidarModel: VLP_16_SIMU

selected_segment:
  - {
      start_time: 0,
      end_time: 40,
      path_bag: /root/calib_ws/src/OA-LICalib/data/rosbag2_2023_08_18-14_42_12_0.bag,
    }
```

--------------------------------

### Sample mapping_based.launch.xml for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/lidar-lidar-calibration/index.md

This is a complete example of the `mapping_based.launch.xml` file configured for a tutorial vehicle, setting default values for vehicle ID and sensor model.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<launch>
  <arg name="vehicle_id" default="tutorial_vehicle"/>
  <let name="sensor_model" value="tutorial_vehicle_sensor_kit"/>
  <arg name="rviz" default="true"/>

  <group>
    <push-ros-namespace namespace="sensor_kit"/>
    <include file="$(find-pkg-share extrinsic_calibration_manager)/launch/$(var sensor_model)/mapping_based_sensor_kit.launch.xml">
      <arg name="vehicle_id" value="$(var vehicle_id)"/>
      <arg name="rviz" value="$(var rviz)"/>
    </include>
  </group>
</launch>
```

--------------------------------

### Use rclcpp/logging.hpp for Core Libraries

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/contributing/coding-guidelines/ros-nodes/console-logging.md

For core library classes intended for potential non-ROS use, depend on `rclcpp/logging.hpp` instead of `rclcpp/node.hpp`. This reduces dependencies and aids portability. The compliant examples show how to pass a logger or get a logger by name.

```cpp
// Compliant
#include <rclcpp/logging.hpp>

class FooCore {
public:
  explicit FooCore(const rclcpp::Logger & logger) : logger_(logger) {}

  void process() {
    RCLCPP_INFO(logger_, "message");
  }

private:
  rclcpp::Logger logger_;
};

// Compliant
// Note that logs aren't published to `/rosout` if the logger name is different from the node name.
#include <rclcpp/logging.hpp>

class FooCore {
  void process() {
    RCLCPP_INFO(rclcpp::get_logger("foo_core_logger"), "message");
  }
};


// Non-compliant
#include <rclcpp/node.hpp>

class FooCore {
public:
  explicit FooCore(const rclcpp::NodeOptions & node_options) : node_("foo_core_node", node_options) {}

  void process() {
    RCLCPP_INFO(node_.get_logger(), "message");
  }

private:
  rclcpp::Node node_;
};
```

--------------------------------

### Sample ground_plane.launch.xml for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/ground-lidar-calibration/index.md

This is a complete example of the ground_plane.launch.xml file for the tutorial vehicle, demonstrating the correct configuration of vehicle and sensor model arguments.

```xml
<launch>
  <arg name="vehicle_id" default="tutorial_vehicle"/>
  <let name="sensor_model" value="tutorial_vehicle_sensor_kit"/>

  <group>
    <push-ros-namespace namespace="sensor_kit"/>
    <include file="$(find-pkg-share extrinsic_calibration_manager)/launch/$(var sensor_model)/ground_plane_sensor_kit.launch.xml">
      <arg name="vehicle_id" value="$(var vehicle_id)"/>
    </include>
  </group>
</launch>
```

--------------------------------

### Accept Start API

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/design/autoware-architecture-v1/interfaces/ad-api/list/api/motion/accept_start.md

Accept the vehicle to start. This API can be used when the motion state is STARTING.

```APIDOC
## accept_start

### Description
Accept the vehicle to start. This API can be used when the motion state is STARTING.

### Method
function call

### Type
autoware_adapi_v1_msgs/srv/AcceptStart

### Response
#### Success Response
- **status** (string) - response status
```

--------------------------------

### Camera Launch XML for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/creating-sensor-model/index.md

Example camera.launch.xml configuration for the tutorial vehicle, specifying common parameters like image topic names.

```xml
<launch>
  <arg name="launch_driver" default="true"/>
  <!--    common parameters -->
  <arg name="image_0" default="camera_0" description="image raw topic name"/>

  <!--    tensorrt params -->

```

--------------------------------

### Install GTSAM Library

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/fast-lio-lc/index.md

Installs the GTSAM library, a dependency for FAST-LIO-LC. Ensure you have wget and unzip installed.

```bash
wget -O ~/Downloads/gtsam.zip https://github.com/borglab/gtsam/archive/4.0.0-alpha2.zip
cd ~/Downloads/ && unzip gtsam.zip -d ~/Downloads/
cd ~/Downloads/gtsam-4.0.0-alpha2/
mkdir build && cd build
cmake ..
sudo make install
```

--------------------------------

### Tutorial Vehicle Sensor Kit Launch File

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/ground-lidar-calibration/index.md

This is a sample `ground_plane_sensor_kit.launch.xml` for the tutorial vehicle. It sets up parameters for the extrinsic calibration client and manager, and includes configurations for multiple lidar sensors.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<launch>
<arg name="vehicle_id" default="tutorial_vehicle"/>
<let name="sensor_model" value="tutorial_vehicle_sensor_kit"/>
<let name="base_frame" value="base_link"/>
<let name="parent_frame" value="sensor_kit_base_link"/>
<let name="rviz_profile" value="$(find-pkg-share extrinsic_ground_plane_calibrator)/rviz/velodyne_top.rviz"/>
<arg name="calibration_rviz" default="true"/>

  <!-- extrinsic_calibration_client -->
  <arg name="src_yaml" default="$(find-pkg-share individual_params)/config/$(var vehicle_id)/$(var sensor_model)/sensor_kit_calibration.yaml"/>
  <arg name="dst_yaml" default="$(env HOME)/sensor_kit_calibration.yaml"/>

  <node pkg="extrinsic_calibration_client" exec="extrinsic_calibration_client" name="extrinsic_calibration_client" output="screen">
    <param name="src_path" value="$(var src_yaml)"/>
    <param name="dst_path" value="$(var dst_yaml)"/>
  </node>

  <!-- extrinsic_calibration_manager -->
  <node pkg="extrinsic_calibration_manager" exec="extrinsic_calibration_manager" name="extrinsic_calibration_manager" output="screen">
    <param name="parent_frame" value="$(var parent_frame)"/>
    <param name="child_frames" value="
    [rs_helios_top_base_link,
    rs_bpearl_front_base_link]"/>
  </node>

  <!-- rs_helios_top_base_link: extrinsic_ground_plane_calibrator -->
  <group>
    <include file="$(find-pkg-share extrinsic_ground_plane_calibrator)/launch/calibrator.launch.xml">
      <arg name="ns" value="$(var parent_frame)/rs_helios_top_base_link"/>
      <arg name="base_frame" value="$(var base_frame)"/>
      <arg name="parent_frame" value="$(var parent_frame)"/>
      <arg name="child_frame" value="rs_helios_top_base_link"/>
      <arg name="pointcloud_topic" value="/sensing/lidar/top/pointcloud_raw"/>
    </include>
  </group>

  <!-- rs_bpearl_front_base_link: extrinsic_ground_plane_calibrator -->
  <group>
    <include file="$(find-pkg-share extrinsic_ground_plane_calibrator)/launch/calibrator.launch.xml">
      <arg name="ns" value="$(var parent_frame)/rs_bpearl_front_base_link"/>
      <arg name="base_frame" value="$(var base_frame)"/>
      <arg name="parent_frame" value="$(var parent_frame)"/>
      <arg name="child_frame" value="rs_bpearl_front_base_link"/>
      <arg name="pointcloud_topic" value="/sensing/lidar/front/pointcloud_raw"/>
    </include>
  </group>

  <node pkg="rviz2" exec="rviz2" name="rviz2" output="screen" args="-d $(var rviz_profile)" if="$(var calibration_rviz)"/>
</launch>
```

--------------------------------

### Install rmw_zenoh-cpp

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/installation/additional-settings-for-developers/network-configuration/zenoh-settings.md

Installs the Zenoh RMW implementation for ROS 2 Jazzy. Ensure your system is updated before installation.

```bash
sudo apt update && sudo apt install ros-jazzy-rmw-zenoh-cpp
```

--------------------------------

### Install Docker on Ubuntu

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/lidar-imu-calibration/index.md

Set up Docker's official GPG key and Apt repository on Ubuntu. This is the first step to using the Docker image provided for Lidar-Imu calibration.

```sh
# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
```

--------------------------------

### Install GTSAM 4.x

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/sc-a-loam/index.md

Install GTSAM version 4.x if it is not already present. This involves downloading the source, building it with CMake, and installing it.

```bash
wget -O ~/Downloads/gtsam.zip https://github.com/borglab/gtsam/archive/4.0.2.zip
cd ~/Downloads/ && unzip gtsam.zip -d ~/Downloads/
cd ~/Downloads/gtsam-4.0.2/
mkdir build && cd build
cmake -DGTSAM_BUILD_WITH_MARCH_NATIVE=OFF ..
sudo make install -j8
```

--------------------------------

### Build SC-A-LOAM Workspace

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/sc-a-loam/index.md

Set up the Catkin workspace, clone the SC-A-LOAM repository, build the package, and source the setup file.

```bash
mkdir -p ~/catkin_scaloam_ws/src
cd ~/catkin_scaloam_ws/src
git clone https://github.com/gisbi-kim/SC-A-LOAM.git
cd ../
catkin_make
source ~/catkin_scaloam_ws/devel/setup.bash
```

--------------------------------

### Install ROS Dependencies (Kinetic)

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/ia-lio-slam/index.md

Installs necessary ROS packages for IA-LIO-SAM on Ubuntu with ROS Kinetic. Ensure ROS is installed and sourced before running.

```bash
sudo apt-get install -y ros-kinetic-navigation
sudo apt-get install -y ros-kinetic-robot-localization
sudo apt-get install -y ros-kinetic-robot-state-publisher
```

--------------------------------

### Install ROS Dependencies (Melodic)

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/ia-lio-slam/index.md

Installs necessary ROS packages for IA-LIO-SAM on Ubuntu with ROS Melodic. Ensure ROS is installed and sourced before running.

```bash
sudo apt-get install -y ros-melodic-navigation
sudo apt-get install -y ros-melodic-robot-localization
sudo apt-get install -y ros-melodic-robot-state-publisher
```

--------------------------------

### Serve MkDocs Documentation Locally

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/contributing/documentation-guidelines/index.md

Builds and serves the Autoware documentation website on your local machine using MkDocs. Navigate to your documentation directory before running this command.

```bash
cd /PATH/TO/YOUR-autoware-documentation
mkdocs serve
```

--------------------------------

### Create and Navigate to Launch Files Directory

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/lidar-lidar-calibration/index.md

Navigate to the sensor calibration tools directory and create new launch files for your vehicle's sensor kit.

```bash
cd <YOUR-OWN-AUTOWARE-DIRECTORY>/src/autoware/calibration_tools/sensor
cd extrinsic_calibration_manager/launch
cd <YOUR-OWN-SENSOR-KIT-NAME> # i.e. for our guide, it will ve cd tutorial_vehicle_sensor_kit which is created in manual calibration
touch mapping_based.launch.xml mapping_based_sensor_kit.launch.xml
```

--------------------------------

### Install CalibrationTools Repository

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/calibration-tools/index.md

Clone the CalibrationTools repository into your Autoware workspace and install its dependencies. This involves downloading the repository definition and running `vcs import` and `rosdep install`.

```bash
cd <YOUR-OWN-AUTOWARE-DIRECTORY> # for example: cd autoware.tutorial_vehicle
wget https://raw.githubusercontent.com/tier4/CalibrationTools/tier4/universe/calibration_tools_autoware.repos
vcs import src < calibration_tools_autoware.repos
rosdep install -y --from-paths src --ignore-src --rosdistro $ROS_DISTRO
```

--------------------------------

### Launch Autoware with Custom Perception Arguments

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/launch-autoware/perception/index.md

Example of launching Autoware with specific perception arguments set via the command line.

```bash
ros2 launch autoware_launch autoware.launch.xml ... detected_objects_filter_method:=lanelet_filter occupancy_grid_map_method:=laserscan_based_occupancy_grid_map ...

```

--------------------------------

### Entire ROS Package Structure Example

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/contributing/coding-guidelines/ros-nodes/directory-structure.md

This is a reference for how an entire ROS package might be structured. A package may not include all the directories shown here.

```txt
autoware_gnss_poser
├─ package.xml
├─ CMakeLists.txt
├─ README.md
│
├─ config
│   ├─ gnss_poser.param.yaml
│   └─ another_non_ros_config.yaml
│
├─ schema
│   └─ gnss_poser.schema.json
│
├─ doc
│   ├─ foo_document.md
│   └─ foo_diagram.svg
│
├─ include  # for exporting headers
│   └─ autoware
│       └─ gnss_poser
│           └─ exported_header.hpp
│
├─ src
│   ├─ include
│   │   ├─ gnss_poser_node.hpp
│   │   └─ foo.hpp
│   ├─ gnss_poser_node.cpp
│   └─ bar.cpp
│
├─ launch
│   ├─ gnss_poser.launch.xml
│   └─ gnss_poser.launch.py
│
└─ test
    ├─ test_foo.hpp  # or place under an `include` folder here
    └─ test_foo.cpp
```

--------------------------------

### Install Dependencies

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/converting-utm-to-mgrs-map/index.md

Installs necessary ROS 2 and GeographicLib tools for the converter package.

```bash
sudo apt install ros-humble-pcl-conversions \
       geographiclib-tools
```

--------------------------------

### Launch Autoware with Logging Simulator

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/demos/rosbag-replay-simulation.md

Source the Autoware setup and launch the logging simulator with specified map, vehicle, and sensor configurations. Ensure you use the full path for HOME, as `~` is not supported.

```sh
source ~/autoware/install/setup.bash
ros2 launch autoware_launch logging_simulator.launch.xml map_path:=$HOME/autoware_data/maps/sample-map-rosbag vehicle_model:=sample_vehicle sensor_model:=sample_sensor_kit
```

--------------------------------

### Install GTSAM Library

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/lio-sam/index.md

Installs the GTSAM (Georgia Tech Smoothing and Mapping) library, a key dependency for LIO-SAM's factor graph optimization. This command adds the GTSAM PPA and installs the development packages.

```bash
sudo add-apt-repository ppa:borglab/gtsam-release-4.1
sudo apt install libgtsam-dev libgtsam-unstable-dev
```

--------------------------------

### Install fd-find

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/others/applying-clang-tidy-to-ros-packages.md

Install fd-find utility, which helps in efficiently finding files for use with `run-clang-tidy`.

```bash
sudo apt-get install fd-find
```

--------------------------------

### Install Development Environment with Ansible

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/installation/autoware/source-installation.md

Sets up the Autoware development environment using Ansible playbooks. This includes installing all necessary dependencies. The `--skip-tags nvidia` option can be used to install without NVIDIA GPU support.

```bash
bash ansible/scripts/install-ansible.sh
ansible-galaxy collection install -f -r ansible-galaxy-requirements.yaml
ansible-playbook autoware.dev_env.install_dev_env
```

```bash
ansible-playbook autoware.dev_env.install_dev_env --skip-tags nvidia
```

--------------------------------

### Tutorial Vehicle Sensor Kit Launch File

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/extrinsic-manual-calibration/index.md

This launch file configures the extrinsic calibration client and manager for a tutorial vehicle. It specifies source and destination YAML files for calibration parameters and lists the child frames to be calibrated.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<launch>
    <arg name="vehicle_id" default="tutorial_vehicle"/> <!-- You can update with your own vehicle_id -->

    <let name="sensor_model" value="tutorial_vehicle_sensor_kit"/> <!-- You can update with your own sensor model -->
    <let name="parent_frame" value="sensor_kit_base_link"/>

    <!-- extrinsic_calibration_client -->
    <arg name="src_yaml" default="$(find-pkg-share individual_params)/config/$(var vehicle_id)/$(var sensor_model)/sensor_kit_calibration.yaml"/>
    <arg name="dst_yaml" default="$(env HOME)/sensor_kit_calibration.yaml"/>

    <node pkg="extrinsic_calibration_client" exec="extrinsic_calibration_client" name="extrinsic_calibration_client" output="screen">
        <param name="src_path" value="$(var src_yaml)"/>
        <param name="dst_path" value="$(var dst_yaml)"/>
    </node>

    <!-- extrinsic_calibration_manager -->
    <node pkg="extrinsic_calibration_manager" exec="extrinsic_calibration_manager" name="extrinsic_calibration_manager" output="screen">
        <param name="parent_frame" value="$(var parent_frame)"/>
        <!-- Please Update with your own sensor frames -->
        <param name="child_frames" value="
    [rs_helios_top_base_link,
    rs_bpearl_front_base_link,
    camera0/camera_link,
    gnss_link]"/>
    </node>

    <!-- extrinsic_manual_calibrator -->
    <!-- Please create a launch for all sensors that you used. -->
    <include file="$(find-pkg-share extrinsic_manual_calibrator)/launch/calibrator.launch.xml">
        <arg name="ns" value="$(var parent_frame)/rs_helios_top_base_link"/>
        <arg name="parent_frame" value="$(var parent_frame)"/>
        <arg name="child_frame" value="rs_helios_top_base_link"/>
    </include>

    <include file="$(find-pkg-share extrinsic_manual_calibrator)/launch/calibrator.launch.xml">
        <arg name="ns" value="$(var parent_frame)/rs_bpearl_front_base_link"/>
        <arg name="parent_frame" value="$(var parent_frame)"/>
        <arg name="child_frame" value="rs_bpearl_front_base_link"/>
    </include>

    <include file="$(find-pkg-share extrinsic_manual_calibrator)/launch/calibrator.launch.xml">
        <arg name="ns" value="$(var parent_frame)/camera0/camera_link"/>
        <arg name="parent_frame" value="$(var parent_frame)"/>
        <arg name="child_frame" value="camera0/camera_link"/>
    </include>

    <include file="$(find-pkg-share extrinsic_manual_calibrator)/launch/calibrator.launch.xml">
        <arg name="ns" value="$(var parent_frame)/gnss_link"/>
        <arg name="parent_frame" value="$(var parent_frame)"/>
        <arg name="child_frame" value="gnss_link"/>
    </include>
</launch>
```

--------------------------------

### Launch Manual Calibration for Tutorial Vehicle

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-vehicle-and-sensor-model/calibrating-sensors/extrinsic-manual-calibration/index.md

Launch the manual calibration tool specifically for the tutorial vehicle. This command uses predefined models and IDs for the tutorial setup.

```bash
ros2 launch extrinsic_calibration_manager calibration.launch.xml mode:=manual sensor_model:=tutorial_vehicle_sensor_kit vehicle_model:=tutorial_vehicle vehicle_id:=tutorial_vehicle
```

--------------------------------

### Install Clang-Tidy and Clang-Apply-Replacements

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/others/applying-clang-tidy-to-ros-packages.md

Install the core Clang-Tidy linter and the `clang-apply-replacements` tool for managing code fixes.

```bash
sudo apt-get install clang-tidy clang-tools
```

--------------------------------

### Launch Autoware with Basic Arguments

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/launch-autoware/index.md

Launch Autoware using the `autoware_launch.launch.xml` file, specifying essential parameters like map path, vehicle model, sensor model, and vehicle ID.

```bash
ros2 launch autoware_launch autoware_launch.launch.xml map_path:=<YOUR-MAP-PATH> vehicle_model:=<YOUR-VEHICLE-MODEL> sensor_model:=<YOUR-SENSOR-MODEL> vehicle_id:=<YOUR-VEHICLE-ID>
```

--------------------------------

### Install Autoware Core Package

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/installation/autoware/core-debian-installation.md

Installs the Autoware Core package and its ROS 2 Humble dependencies.

```bash
sudo apt install ros-humble-autoware-core
```

--------------------------------

### Download and Unzip Sample Map

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/others/using-divided-map.md

Use gdown to download the sample map and unzip it to the specified directory. Ensure the directory structure is created first.

```bash
mkdir -p ~/autoware_data/maps
gdown -O ~/autoware_data/maps/sample-rosbag_split.zip 'https://docs.google.com/uc?export=download&id=11tLC9T4MS8fnZ9Wo0D8-Ext7hEDl2YJ4'
unzip -d ~/autoware_data/maps/ ~/autoware_data/maps/sample-rosbag_split.zip
```

--------------------------------

### Install Hector Trajectory Server

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/tutorials/integrating-autoware/creating-maps/open-source-slam/iscloam/index.md

Install the hector-trajectory-server package, which is used for trajectory visualization purposes within ISCLOAM.

```bash
sudo apt-get install ros-melodic-hector-trajectory-server
```

--------------------------------

### Update pip and install autoware_rosbag2_anonymizer

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/datasets/data-anonymization/index.md

Update your pip package manager and then install the autoware_rosbag2_anonymizer tool using pip.

```bash
python3 -m pip install pip -U

python3 -m pip install .
```

--------------------------------

### Launch Autoware from Debian Package Installation

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/demos/digital-twin-demos/autoware-core-awsim/index.md

Source the ROS Humble environment and launch Autoware Core, configuring it for simulation with the Shinjuku map and specific vehicle/sensor models.

```bash
source /opt/ros/humble/setup.bash
ros2 launch autoware_core autoware_core.launch.xml use_sim_time:=true map_path:=$HOME/Downloads/Shinjuku-Map/map vehicle_model:=autoware_sample_vehicle sensor_model:=autoware_awsim_sensor_kit
```

--------------------------------

### Verify Docker Installation

Source: https://github.com/autowarefoundation/autoware-documentation/blob/main/docs/community/support/troubleshooting/index.md

Run these commands to ensure your Docker installation is functioning correctly and can pull and run images.

```bash
docker run --rm -it hello-world
```

```bash
docker run --rm -it ubuntu:latest
```