Replication Package

[Link]

1. Install the necessary environment required by EPNET.

• Clone the PointRCNN repository.

git clone https://github.com/happinesslz/EPNet.git

• Install the dependent python libraries like easydict,tqdm, tensorboardX etc.

• Build and install the pointnet2_lib, iou3d, roipool3d libraries by executing the following command:

sh build_and_install.sh

2. Use synthetic corruption datasets to construct datasets in the EPNet required format.

EPNet

├── data

│   ├── KITTI

│   │   ├── ImageSets

│   │   ├── object

│   │   │   ├──training

│   │   │      ├──calib & velodyne & label_2 & image_2 & (optional: planes)

│   │   │   ├──testing

│   │   │      ├──calib & velodyne & image_2

├── lib

├── pointnet2_lib

├── tools

3. Run EPNet and evaluate the performance.

[Link] 

1. Install the necessary environment required by FConv.

• Clone the repository and install dependencies

git clone https://github.com/zhixinwang/frustum-convnet.git

• You may need to install extra packages, like pybind11, opencv, yaml, tensorflow(optional).

• If you want to use tensorboard to visualize the training status, you should install tensorflow (CPU version is enough). Otherwise, you should set the config 'USE_TFBOARD: False' in cfgs/*.yaml.

• Compile extension

cd ops bash 

clean.sh 

bash make.sh

2. Train the 2D detector in the KITTI dataset, and then infer the detection results in the synthetic image, and move them to the directory FConv/kitti/rgb_detections.

3. Use synthetic corruption datasets to construct datasets in the FConv required format.

data/kitti

├── testing

│   ├── calib

│   ├── image_2

│   └── velodyne

└── training

    ├── calib

    ├── image_2

    ├── label_2

    └── velodyne

4. Run FConv and evaluate the performance.

[Link] 

1. Install the necessary environment required by CLOCs. Note that we should be careful to install the correct version of spconv.

pip install shapely fire pybind11 tensorboardX protobuf scikit-image numba pillow

export PYTHONPATH=$PYTHONPATH:'/dir/to/your/CLOCs/'

2. Train the 2D detector in the KITTI dataset, and then infer the detection results in the synthetic image.

3. Use synthetic corruption datasets to construct datasets in the CLOCs required format. Then modify the CLOCs config file carefully. 

└── KITTI_DATASET_ROOT

       ├── training    <-- 7481 train data

       |   ├── image_2 <-- for visualization

       |   ├── calib

       |   ├── label_2

       |   ├── velodyne

       |   └── velodyne_reduced <-- empty directory

       └── testing     <-- 7518 test data

       |   ├── image_2 <-- for visualization

       |   ├── calib

       |   ├── velodyne

       |   └── velodyne_reduced <-- empty directory

       └── kitti_dbinfos_train.pkl

       ├── kitti_infos_train.pkl

       ├── kitti_infos_test.pkl

       ├── kitti_infos_val.pkl

       └── kitti_infos_trainval.pkl 

4. As CLOCs mentioned, you could follow the SECOND-1.5 instructions to create kitti infos, reduced point cloud and groundtruth-database infos. Note that you need to perform this step every time you construct corruption datasets.

5. Run CLOCs and evaluate the performance.

[Link] 

1. Install the necessary environment required by JMODT.

• Install PyTorch and CUDA.

• Install other required Python packages

pip install -r requirements.txt

python setup.py develop

• Build and install the required CUDA modules via PyTorch and the CUDA toolkit:

python setup.py develop

2. Use synthetic corruption datasets to construct datasets in the JMODT required format.

JMODT

├── data

    ├── KITTI

        ├── tracking

        │   ├──training

        │   │  ├──calib & velodyne & label_02 & image_02

        │   ├──testing

        │      ├──calib & velodyne & image_02

        ├── tracking_object

            ├──ImageSets

            │  ├──small_val.txt & test.txt & train.txt & val.txt

            ├──training

            │  ├──calib & velodyne & label_2 & image_2 & sample2frame.txt & seq2sample.txt

            ├──testing

            ├──calib & velodyne & image_2 & sample2frame.txt & seq2sample.txt           

3. use the following command to reformat the ground truth to KITTI's object detection format. 

python tools/kitti_converter.py --data_root ${DATA_ROOT}

4. Run JMODT and evaluate the performance.

[Link]

1. Install the necessary environment required by DFMOT.

• git clone https://github.com/wangxiyang2022/DeepFusionMOT

• cd your_path/DeepFusionMOT

pip install -r requirements.txt

2. Train a 2D detector and a 3D detector in the KITTI dataset, and then infer the detection results in the synthetic image and point cloud. Then  move them to the directory DeepFusionMOT/datasets/kitti/2D_rrc_Car_train and  DeepFusionMOT/datasets/kitti/3D_pointrcnn_train respectively.

3. Use synthetic corruption datasets to construct datasets in the DFMOT required format.

DeepFusionMOT

├── datasets

    ├── kitti

        ├── train

│   ├──calib_train

│   ├──image_02_train

        ├── test

    ├──calib_test

                    ├──image_02_test

4. Run DFMOT and evaluate the performance.

[Link] 

1. Install the necessary environment required by TWISE.

2. Use synthetic corruption datasets to construct datasets in the TWISE required format.

Data

  |__depth_selection

3. Run TWISE and evaluate the performance.

[Link] 

1. Install the necessary environment required by MDANet.

• install mmcv 1.0.5 (You can install mmcv from this repo)

• clone this repository 

git clone https://github.com/USTC-Keyanjie/MDANet_ICRA2021.git && cd MDANet_ICRA2021

2. Use synthetic corruption datasets to construct datasets in the MDANet required format.

/path/to/KITTI/Depth/dataset

├── data_depth_annotated

│   ├── train

│   └── val

├── data_depth_velodyne

│   ├── train

│   └── val

└── depth_selection

    ├── test_depth_completion_anonymous

    ├── test_depth_prediction_anonymous

    └── val_selection_cropped

3. Run MDANet and evaluate the performance.