diff --git a/README.md b/README.md
index 9853b1c..66516c3 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,11 @@
 This repo aims to provide flexible and reproducible visual 3D detection on KITTI dataset. We expect scripts starting from the current directory, and treat ./visualDet3D as a package that we could modify and test directly instead of a library. Several useful scripts are provided in the main directory for easy usage.
 
 We believe that visual tasks are interconnected, so we make this library extensible to more experiments. 
-The package uses registry to register datasets, models, processing functions and more allowing easy inserting of new tasks/models while not interfere with the existing ones.
+The package uses registry to register datasets, models, processing functions and more, allowing easy inserting of new tasks/models while not interfere with the existing ones.
 
 ## Related Paper:
 
-This repo contains the official implementation of 2021 *RAL* paper [**Ground-aware Monocular 3D Object Detection for Autonomous Driving**](https://ieeexplore.ieee.org/document/9327478). [Arxiv Page](https://arxiv.org/abs/2102.00690). Pretrained model can be found at release pages.
+This repo contains the official implementation of 2021 *RAL* \& *ICRA* paper [**Ground-aware Monocular 3D Object Detection for Autonomous Driving**](https://ieeexplore.ieee.org/document/9327478). [Arxiv Page](https://arxiv.org/abs/2102.00690). Pretrained model can be found at [release pages](https://github.com/Owen-Liuyuxuan/visualDet3D/releases/tag/1.0).
 ```
 @ARTICLE{9327478,
   author={Y. {Liu} and Y. {Yuan} and M. {Liu}},
@@ -16,6 +16,20 @@ This repo contains the official implementation of 2021 *RAL* paper [**Ground-awa
   year={2021},
   doi={10.1109/LRA.2021.3052442}}
 ```
+
+Also the official implementation of 2021 *ICRA* paper [**YOLOStereo3D: A Step Back to 2D for Efficient Stereo 3D Detection**](https://arxiv.org/abs/2103.09422). Pretrained model can be found at [release pages](https://github.com/Owen-Liuyuxuan/visualDet3D/releases/tag/1.1).
+```
+@inproceedings{liu2021yolostereo3d,
+  title={YOLOStereo3D: A Step Back to 2D for Efficient Stereo 3D Detection},
+  author={Yuxuan Liu and Lujia Wang and Ming, Liu},
+  booktitle={2021 International Conference on Robotics and Automation (ICRA)},
+  year={2021},
+  organization={IEEE}
+}
+```
+
+We further incorperate an *Unofficial* re-implementation of **Monocular 3D Detection with Geometric Constraints Embedding and Semi-supervised Training** (KM3D) as a reference on how to integrate with other frameworks. (Notice that the codes are from the [originally official repo](https://github.com/Banconxuan/RTM3D), and we **DO NOT** guarantee a complete re-implementation).
+
 ## Key Features
 
 - **SOTA Performance** State of the art result on visual 3D detection.
@@ -26,7 +40,7 @@ This repo contains the official implementation of 2021 *RAL* paper [**Ground-awa
 - **Global Path-based IMDB** Do not need data placed inside the folder, convienient for managing data and code separately.
 
 
-We provide start-up solutions for [Mono3D](docs/mono3d.md), [Depth Predictions](docs/monoDepth.md) and more (until further publication).
+We provide start-up solutions for [Mono3D](docs/mono3d.md), [Stereo3D](docs/stereo3d.md), [Depth Predictions](docs/monoDepth.md) and more (until further publication).
 
 Reference: this repo borrows codes and ideas from [retinanet](https://github.com/yhenon/pytorch-retinanet),
 [mmdetection](https://github.com/open-mmlab/mmdetection),
@@ -44,13 +58,13 @@ pip3 install -r requirement.txt
 or manually check dependencies.
 
 ```bash
-# build ops (deform convs), We will not install operations into the system environment
+# build ops (deform convs and iou3d), We will not install operations into the system environment
 ./make.sh
 ```
 
 ## Start Training
 
-Please check the corresponding task: [Mono3D](docs/mono3d.md), [Depth Predictions](docs/monoDepth.md). More demo will be available through contributions and further paper submission.
+Please check the corresponding task: [Mono3D](docs/mono3d.md), [Stereo3D](docs/stereo3d.md) [Depth Predictions](docs/monoDepth.md). More demo will be available through contributions and further paper submission.
 
 ### Config and Path setup. 
 
@@ -78,7 +92,9 @@ Please check the template's comments and other comments in codes to fully exploi
 ## Other Resources
 
 - [RAM-LAB](https://www.ram-lab.com)
-- [Collections of Papers and Readings](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/); [Collection for Mono3D](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/3dDetection/RecentCollectionForMono3D/); [Ground-Aware 3D](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/3dDetection/GroundAwareConvultion/)
+- [Collections of Papers and Readings](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/);
+-  [Collection for Mono3D](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/3dDetection/RecentCollectionForMono3D/); [Ground-Aware 3D](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/3dDetection/GroundAwareConvultion/)
+- [Collection for Stereo3D](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/3dDetection/RecentCollectionForStereo3D/); [YOLOStereo3D](https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/3dDetection/YOLOStereo3D/)
 
 ## Related Codes
 
@@ -86,4 +102,5 @@ Please check the template's comments and other comments in codes to fully exploi
 - [M3D-RPN](https://github.com/garrickbrazil/M3D-RPN)
 - [Retinanet](https://github.com/yhenon/pytorch-retinanet)
 - [DORN](https://github.com/dontLoveBugs/SupervisedDepthPrediction)
-- [det3](https://github.com/pyun-ram/FL3D)
\ No newline at end of file
+- [det3](https://github.com/pyun-ram/FL3D)
+- [RTM3D](https://github.com/Banconxuan/RTM3D)
\ No newline at end of file
diff --git a/config/KM3D_example b/config/KM3D_example
new file mode 100644
index 0000000..a96f476
--- /dev/null
+++ b/config/KM3D_example
@@ -0,0 +1,165 @@
+from easydict import EasyDict as edict
+import os 
+import numpy as np
+
+cfg = edict()
+cfg.obj_types = ['Car', 'Pedestrian', 'Cyclist']
+cfg.anchor_prior = False
+## trainer
+trainer = edict(
+    gpu = 0,
+    max_epochs = 200,
+    disp_iter = 50,
+    save_iter = 20,
+    test_iter = 20,
+    cudnn = True,
+    training_func = "train_rtm3d",
+    test_func = "test_mono_detection",
+    evaluate_func = "evaluate_kitti_obj",
+)
+
+cfg.trainer = trainer
+
+## path
+path = edict()
+path.data_path = "/home/kitti_obj/training"
+path.test_path = "/home/kitti_obj/testing"
+path.visualDet3D_path = "/home/stereo_kitti/visualDet3D"
+path.project_path = "/home/stereo_kitti/workdirs"
+
+if not os.path.isdir(path.project_path):
+    os.mkdir(path.project_path)
+path.project_path = os.path.join(path.project_path, 'RTM3D')
+if not os.path.isdir(path.project_path):
+    os.mkdir(path.project_path)
+
+path.log_path = os.path.join(path.project_path, "log")
+if not os.path.isdir(path.log_path):
+    os.mkdir(path.log_path)
+
+path.checkpoint_path = os.path.join(path.project_path, "checkpoint")
+if not os.path.isdir(path.checkpoint_path):
+    os.mkdir(path.checkpoint_path)
+
+path.preprocessed_path = os.path.join(path.project_path, "output")
+if not os.path.isdir(path.preprocessed_path):
+    os.mkdir(path.preprocessed_path)
+
+path.train_imdb_path = os.path.join(path.preprocessed_path, "training")
+if not os.path.isdir(path.train_imdb_path):
+    os.mkdir(path.train_imdb_path)
+
+path.val_imdb_path = os.path.join(path.preprocessed_path, "validation")
+if not os.path.isdir(path.val_imdb_path):
+    os.mkdir(path.val_imdb_path)
+
+cfg.path = path
+
+## optimizer
+optimizer = edict(
+    type_name = 'adam',
+    keywords = edict(
+        lr        = 1.25e-4,
+        weight_decay = 0,
+    ),
+    clipped_gradient_norm = 35.0
+)
+cfg.optimizer = optimizer
+## scheduler
+scheduler = edict(
+    type_name = 'MultiStepLR',
+    keywords = edict(
+        milestones = [90, 120]
+    )
+)
+cfg.scheduler = scheduler
+
+## data
+data = edict(
+    batch_size = 32,
+    num_workers = 4,
+    rgb_shape = (384, 1280, 3),
+    train_dataset = "KittiRTM3DDataset",
+    val_dataset   = "KittiMonoDataset",
+    test_dataset  = "KittiMonoTestDataset",
+    train_split_file = os.path.join(cfg.path.visualDet3D_path, 'data', 'kitti', 'chen_split', 'train.txt'),
+    val_split_file   = os.path.join(cfg.path.visualDet3D_path, 'data', 'kitti', 'chen_split', 'val.txt'),
+    max_occlusion = 4,
+    min_z = 3,
+)
+
+data.augmentation = edict(
+    rgb_mean = np.array([0.485, 0.456, 0.406]),
+    rgb_std  = np.array([0.229, 0.224, 0.225]),
+    cropSize = (data.rgb_shape[0], data.rgb_shape[1]),
+)
+data.train_augmentation = [
+    edict(type_name='ConvertToFloat'),
+    edict(type_name='RandomWarpAffine', keywords=edict(output_w=data.augmentation.cropSize[1], output_h=data.augmentation.cropSize[0])),
+    #edict(type_name='Resize', keywords=edict(size=data.augmentation.cropSize)),
+    edict(type_name="Shuffle", keywords=edict(
+            aug_list=[
+                edict(type_name="RandomBrightness", keywords=edict(distort_prob=1.0)),
+                edict(type_name="RandomContrast", keywords=edict(distort_prob=1.0, lower=0.6, upper=1.4)),
+                edict(type_name="Compose", keywords=edict(
+                   aug_list=[
+                       edict(type_name="ConvertColor", keywords=edict(transform='HSV')),
+                       edict(type_name="RandomSaturation", keywords=edict(distort_prob=1.0, lower=0.6, upper=1.4)),
+                       edict(type_name="ConvertColor", keywords=edict(current='HSV', transform='RGB')),
+                   ] 
+                ))
+            ]
+        )
+    ),
+    edict(type_name='RandomEigenvalueNoise', keywords=edict(alphastd=0.1)),
+    edict(type_name='RandomMirror', keywords=edict(mirror_prob=0.5)),
+    edict(type_name="FilterObject"),
+    edict(type_name='Normalize', keywords=edict(mean=data.augmentation.rgb_mean, stds=data.augmentation.rgb_std))
+]
+data.test_augmentation = [
+    edict(type_name='ConvertToFloat'),
+    #edict(type_name='CropTop', keywords=edict(crop_top_index=data.augmentation.crop_top)),
+    edict(type_name='Resize', keywords=edict(size=data.augmentation.cropSize)),
+    edict(type_name='Normalize', keywords=edict(mean=data.augmentation.rgb_mean, stds=data.augmentation.rgb_std))
+]
+cfg.data = data
+
+## networks
+detector = edict()
+detector.obj_types = cfg.obj_types
+detector.name = 'KM3D'
+detector.backbone = edict(
+    depth=18,
+    pretrained=True,
+    frozen_stages=-1,
+    num_stages=4,
+    out_indices=(3, ),
+    norm_eval=False,
+    dilations=(1, 1, 1, 1),
+)
+head_loss = edict(
+    gamma=2.0,
+    rampup_length = 100,
+    output_w = data.rgb_shape[1] // 4
+)
+head_test = edict(
+    score_thr=0.3,
+)
+
+head_layer = edict(
+    input_features=256,
+    head_features=64,
+    head_dict={'hm': len(cfg.obj_types), 'wh': 2, 'hps': 18,
+               'rot': 8, 'dim': 3, 'prob': 1,
+               'reg': 2, 'hm_hp': 9, 'hp_offset': 2}
+)
+detector.head = edict(
+    num_classes     = len(cfg.obj_types),
+    num_joints      = 9,
+    max_objects     = 32,
+    layer_cfg       = head_layer,
+    loss_cfg        = head_loss,
+    test_cfg        = head_test
+)
+detector.loss = head_loss
+cfg.detector = detector
diff --git a/config/Stereo3D_example b/config/Stereo3D_example
new file mode 100644
index 0000000..99021cc
--- /dev/null
+++ b/config/Stereo3D_example
@@ -0,0 +1,167 @@
+from easydict import EasyDict as edict
+import os 
+import numpy as np
+
+cfg = edict()
+cfg.obj_types = ['Car', 'Pedestrian']
+
+## trainer
+trainer = edict(
+    gpu = 0,
+    max_epochs = 80, # for validation epoch 50 is enough
+    disp_iter = 100,
+    save_iter = 5,
+    test_iter = 10,
+    training_func = "train_stereo_detection",
+    test_func = "test_stereo_detection",
+    evaluate_func = "evaluate_kitti_obj",
+)
+
+cfg.trainer = trainer
+
+## path
+path = edict()
+path.data_path = "/data/kitti_obj/training" # used in visualDet3D/data/.../dataset
+path.test_path = "/data/kitti_obj/testing" # used in visualDet3D/data/.../dataset
+path.visualDet3D_path = "/path/to/visualDet3D/visualDet3D" # The path should point to the inner subfolder
+path.project_path = "/path/to/visualDet3D/workdirs" # or other path for pickle files, checkpoints, tensorboard logging and output files.
+if not os.path.isdir(path.project_path):
+    os.mkdir(path.project_path)
+path.project_path = os.path.join(path.project_path, 'Stereo3D')
+if not os.path.isdir(path.project_path):
+    os.mkdir(path.project_path)
+
+path.log_path = os.path.join(path.project_path, "log")
+if not os.path.isdir(path.log_path):
+    os.mkdir(path.log_path)
+
+path.checkpoint_path = os.path.join(path.project_path, "checkpoint")
+if not os.path.isdir(path.checkpoint_path):
+    os.mkdir(path.checkpoint_path)
+
+path.preprocessed_path = os.path.join(path.project_path, "output")
+if not os.path.isdir(path.preprocessed_path):
+    os.mkdir(path.preprocessed_path)
+
+path.train_imdb_path = os.path.join(path.preprocessed_path, "training")
+if not os.path.isdir(path.train_imdb_path):
+    os.mkdir(path.train_imdb_path)
+
+path.val_imdb_path = os.path.join(path.preprocessed_path, "validation")
+if not os.path.isdir(path.val_imdb_path):
+    os.mkdir(path.val_imdb_path)
+
+cfg.path = path
+
+## optimizer
+optimizer = edict(
+    type_name = 'adam',
+    keywords = edict(
+        lr        = 1e-4,
+        weight_decay = 0,
+    ),
+    clipped_gradient_norm = 0.1
+)
+cfg.optimizer = optimizer
+## scheduler
+scheduler = edict(
+    type_name = 'CosineAnnealingLR',
+    keywords = edict(
+        T_max     = cfg.trainer.max_epochs,
+        eta_min   = 5e-6,
+    )
+)
+cfg.scheduler = scheduler
+
+## data
+data = edict(
+    batch_size = 4,
+    num_workers = 4,
+    rgb_shape = (288, 1280, 3),
+    train_dataset = "KittiStereoDataset",
+    val_dataset   = "KittiStereoDataset",
+    test_dataset  = "KittiStereoTestDataset",
+    train_split_file = os.path.join(cfg.path.visualDet3D_path, 'data', 'kitti', 'test_split', 'train.txt'),
+    val_split_file   = os.path.join(cfg.path.visualDet3D_path, 'data', 'kitti', 'test_split', 'val.txt'),
+)
+
+data.augmentation = edict(
+    rgb_mean = np.array([0.485, 0.456, 0.406]),
+    rgb_std  = np.array([0.229, 0.224, 0.225]),
+    cropSize = (data.rgb_shape[0], data.rgb_shape[1]),
+    crop_top = 100,
+)
+data.train_augmentation = [
+    edict(type_name='ConvertToFloat'),
+    edict(type_name='PhotometricDistort', keywords=edict(distort_prob=1.0, contrast_lower=0.5, contrast_upper=1.5, saturation_lower=0.5, saturation_upper=1.5, hue_delta=18.0, brightness_delta=32)),
+    edict(type_name='CropTop', keywords=edict(crop_top_index=data.augmentation.crop_top)),
+    edict(type_name='Resize', keywords=edict(size=data.augmentation.cropSize)),
+    edict(type_name='RandomMirror', keywords=edict(mirror_prob=0.5)),
+    edict(type_name='Normalize', keywords=edict(mean=data.augmentation.rgb_mean, stds=data.augmentation.rgb_std))
+]
+data.test_augmentation = [
+    edict(type_name='ConvertToFloat'),
+    edict(type_name='CropTop', keywords=edict(crop_top_index=data.augmentation.crop_top)),
+    edict(type_name='Resize', keywords=edict(size=data.augmentation.cropSize)),
+    edict(type_name='Normalize', keywords=edict(mean=data.augmentation.rgb_mean, stds=data.augmentation.rgb_std))
+]
+cfg.data = data
+
+## networks
+detector = edict()
+detector.obj_types = cfg.obj_types
+detector.name = 'Stereo3D'
+detector.backbone = edict(
+    depth=34,
+    pretrained=True,
+    frozen_stages=-1,
+    num_stages=3,
+    out_indices=(0, 1, 2),
+    norm_eval=True,
+    dilations=(1, 1, 1),
+)
+head_loss = edict(
+    fg_iou_threshold = 0.5,
+    bg_iou_threshold = 0.4,
+    L1_regression_alpha = 5 ** 2,
+    focal_loss_gamma = 2.0,
+    balance_weight   = [20.0, 40],
+    regression_weight = [1, 1, 1, 1, 1, 1, 12, 1, 1, 0.5, 0.5, 0.5, 1], #[x, y, w, h, cx, cy, z, sin2a, cos2a, w, h, l]
+)
+head_test = edict(
+    score_thr=0.75,
+    cls_agnostic = False,
+    nms_iou_thr=0.4,
+    post_optimization=True
+)
+
+anchors = edict(
+        {
+            'obj_types': cfg.obj_types,
+            'pyramid_levels':[4],
+            'strides': [2 ** 4],
+            'sizes' : [24],
+            'ratios': np.array([0.5, 1, 2.0]),
+            'scales': np.array([2 ** (i / 4.0) for i in range(16)]),
+        }
+    )
+
+head_layer = edict(
+    num_features_in=1408,
+    num_cls_output=len(cfg.obj_types)+1,
+    num_reg_output=12,
+    cls_feature_size=256,
+    reg_feature_size=1408,
+)
+detector.head = edict(
+    num_regression_loss_terms=13,
+    preprocessed_path=path.preprocessed_path,
+    num_classes     = len(cfg.obj_types),
+    anchors_cfg     = anchors,
+    layer_cfg       = head_layer,
+    loss_cfg        = head_loss,
+    test_cfg        = head_test
+)
+detector.anchors = anchors
+detector.loss = head_loss
+cfg.detector = detector
diff --git a/demos/visualize_test_3d_stereo.ipynb b/demos/visualize_test_3d_stereo.ipynb
new file mode 100644
index 0000000..e2cb141
--- /dev/null
+++ b/demos/visualize_test_3d_stereo.ipynb
@@ -0,0 +1,342 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2021-03-17 16:26:11 224002facb3e numba.cuda.cudadrv.driver[8550] INFO init\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CUDA available: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "sys.path.append(\"../\")\n",
+    "import importlib\n",
+    "import os\n",
+    "import copy\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import cv2\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from torch.utils.tensorboard import SummaryWriter\n",
+    "from torchvision import datasets, models, transforms\n",
+    "import torchvision\n",
+    "from visualDet3D.data.kitti.utils import write_result_to_file\n",
+    "from visualDet3D.utils.utils import LossLogger, cfg_from_file\n",
+    "from visualDet3D.networks.utils.registry import DETECTOR_DICT, DATASET_DICT, PIPELINE_DICT\n",
+    "from visualDet3D.networks.heads.anchors import Anchors\n",
+    "from visualDet3D.networks.lib.fast_utils.hill_climbing import post_opt\n",
+    "from visualDet3D.networks.utils import BBox3dProjector, BackProjection\n",
+    "from visualDet3D.utils.utils import convertAlpha2Rot, convertRot2Alpha, draw_3D_box, compound_annotation\n",
+    "import visualDet3D.data.kitti.dataset\n",
+    "from visualDet3D.utils.timer import Timer\n",
+    "from numba import jit\n",
+    "from tqdm import tqdm\n",
+    "print('CUDA available: {}'.format(torch.cuda.is_available()))\n",
+    "\n",
+    "cfg = cfg_from_file(\"../config/kitti_stereo.py\")\n",
+    "is_test_train = True\n",
+    "\n",
+    "checkpoint_name = \"open_Stereo3D_latest.pth\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def draw_bbox2d_to_image(image, bboxes2d, color=(255, 0, 255)):\n",
+    "    drawed_image = image.copy()\n",
+    "    for box2d in bboxes2d:\n",
+    "        cv2.rectangle(drawed_image, (int(box2d[0]), int(box2d[1])), (int(box2d[2]), int(box2d[3])), color, 3)\n",
+    "    return drawed_image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cfg.batch_size=1\n",
+    "split_to_test='validation'\n",
+    "\n",
+    "is_test_train = split_to_test == 'training'\n",
+    "if split_to_test == 'training':\n",
+    "    dataset_name = cfg.data.train_dataset\n",
+    "elif split_to_test == 'test':\n",
+    "    dataset_name = cfg.data.test_dataset\n",
+    "else:\n",
+    "    dataset_name = cfg.data.val_dataset\n",
+    "\n",
+    "dataset = DATASET_DICT[dataset_name](\n",
+    "        cfg, split_to_test\n",
+    "        )\n",
+    "\n",
+    "if split_to_test=='training':\n",
+    "    dataset_val = DATASET_DICT[cfg.data.val_dataset](\n",
+    "            cfg, 'validation'\n",
+    "            )\n",
+    "    dataset.transform = dataset_val.transform\n",
+    "    dataset.collate_fn = dataset_val.collate_fn\n",
+    "\n",
+    "\n",
+    "\n",
+    "detector = DETECTOR_DICT[cfg.detector.name](cfg.detector)\n",
+    "detector = detector.cuda()\n",
+    "\n",
+    "weight_path = os.path.join(cfg.path.checkpoint_path, checkpoint_name)\n",
+    "state_dict = torch.load(weight_path, map_location='cuda:{}'.format(cfg.trainer.gpu))\n",
+    "new_dict = state_dict.copy()\n",
+    "for key in state_dict:\n",
+    "    if 'focalLoss' in key:\n",
+    "        new_dict.pop(key)\n",
+    "detector.load_state_dict(new_dict, strict=False)\n",
+    "detector.eval().cuda()\n",
+    "\n",
+    "# testing pipeline\n",
+    "test_func = PIPELINE_DICT[cfg.trainer.test_func]\n",
+    "\n",
+    "projector = BBox3dProjector().cuda()\n",
+    "backprojector = BackProjection().cuda()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "index = 0\n",
+    "def corner_homo2bbox(corner_homo):\n",
+    "    \"\"\"\n",
+    "        corner_homo: [N, 8, 3]\n",
+    "    \"\"\"\n",
+    "    min_xy  = torch.min(corner_homo[:, :, 0:2], dim=1)[0]\n",
+    "    max_xy  = torch.max(corner_homo[:, :, 0:2], dim=1)[0]\n",
+    "    min_xy[:, 0]  = torch.clamp(min_xy[:, 0], 0, cfg.rgb_shape[1])\n",
+    "    min_xy[:, 1]  = torch.clamp(min_xy[:, 1], 0, cfg.rgb_shape[0])\n",
+    "    max_xy[:, 0]  = torch.clamp(max_xy[:, 0], 0, cfg.rgb_shape[1])\n",
+    "    max_xy[:, 1]  = torch.clamp(max_xy[:, 1], 0, cfg.rgb_shape[0])\n",
+    "    return torch.cat([min_xy, max_xy], dim=1)\n",
+    "\n",
+    "def denorm(image):\n",
+    "    new_image = np.array((image * cfg.data.augmentation.rgb_std +  cfg.data.augmentation.rgb_mean) * 255, dtype=np.uint8)\n",
+    "    return new_image\n",
+    "\n",
+    "@jit(cache=True, nopython=True)\n",
+    "def ToColorDepth(depth_image:np.ndarray)->np.ndarray: #[H, W] -> [H, W, 3] # Used to draw depth predictions\n",
+    "    H, W = depth_image.shape\n",
+    "    max_depth = float(np.max(depth_image))\n",
+    "    cmap = np.array([\n",
+    "        [0,0,0,114],[0,0,1,185],[1,0,0,114],[1,0,1,174], \n",
+    "        [0,1,0,114],[0,1,1,185],[1,1,0,114],[1,1,1,0]\n",
+    "    ])\n",
+    "    _sum  = 0\n",
+    "    for i in range(8):\n",
+    "        _sum += cmap[i, 3]\n",
+    "    \n",
+    "    weights = np.zeros(8)\n",
+    "    cumsum = np.zeros(8)\n",
+    "    for i in range(7):\n",
+    "        weights[i] = _sum / cmap[i, 3]\n",
+    "        cumsum[i+1] = cumsum[i] + cmap[i, 3] / _sum\n",
+    "    \n",
+    "    image = np.zeros((H, W, 3), dtype=np.uint8)\n",
+    "    for i in range(H):\n",
+    "        for j in range(W):\n",
+    "            val = depth_image[i, j] / max_depth\n",
+    "            for k in range(7):\n",
+    "                if val <= cumsum[k + 1]:\n",
+    "                    break\n",
+    "            w = 1.0- (val - cumsum[k]) * weights[k]\n",
+    "            r = int( (w * cmap[k, 0] + (1 - w) * cmap[k+1, 0]) * 255 )\n",
+    "            g = int( (w * cmap[k, 1] + (1 - w) * cmap[k+1, 1]) * 255 )\n",
+    "            b = int( (w * cmap[k, 2] + (1 - w) * cmap[k+1, 2]) * 255 )\n",
+    "            image[i, j] = np.array([r,g,b])\n",
+    "    return image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_once(index, is_draw=True, is_test_train=True):\n",
+    "    name = \"%06d\" % index\n",
+    "    data = dataset[index]\n",
+    "    if isinstance(data['calib'], list):\n",
+    "        P2 = data['calib'][0]\n",
+    "    else:\n",
+    "        P2 = data['calib']\n",
+    "    original_height = data['original_shape'][0]\n",
+    "    collated_data = dataset.collate_fn([data])\n",
+    "    height = collated_data[0].shape[2]\n",
+    "    scale_2d = (original_height - cfg.data.augmentation.crop_top) / height\n",
+    "    \n",
+    "    if len(collated_data) > 6:\n",
+    "        left_images, right_images, _, _, labels, bbox_3d, _ = collated_data\n",
+    "    else:\n",
+    "        left_images, right_images, _, _, labels, bbox_3d = collated_data\n",
+    "    image = left_images\n",
+    "\n",
+    "    with torch.no_grad():\n",
+    "        \n",
+    "        left_images, right_images, P2, P3 = collated_data[0], collated_data[1], collated_data[2], collated_data[3]\n",
+    "        scores, bbox, obj_names = detector([left_images.cuda().float().contiguous(),\n",
+    "                                          right_images.cuda().float().contiguous(),\n",
+    "                                          P2.cuda().float(),\n",
+    "                                          P3.cuda().float()])\n",
+    "        \n",
+    "        P2 = P2[0]\n",
+    "        bbox_2d = bbox[:, 0:4]\n",
+    "        bbox_3d_state = bbox[:, 4:] #[cx,cy,z,w,h,l,alpha]\n",
+    "        bbox_3d_state_3d = backprojector(bbox_3d_state, P2.cuda()) #[x, y, z, w,h ,l, alpha]\n",
+    "        abs_bbox, bbox_3d_corner_homo, thetas = projector(bbox_3d_state_3d, P2.cuda())\n",
+    "\n",
+    "            \n",
+    "    \n",
+    "    rgb_image = denorm(image[0].cpu().numpy().transpose([1, 2, 0]))\n",
+    "    if len(scores) > 0:\n",
+    "        rgb_image = draw_bbox2d_to_image(rgb_image, bbox_2d.cpu().numpy())\n",
+    "        for box in bbox_3d_corner_homo:\n",
+    "            box = box.cpu().numpy().T\n",
+    "            rgb_image = draw_3D_box(rgb_image, box)\n",
+    "    if is_draw:\n",
+    "        plt.imshow(np.clip(rgb_image, 0, 255))\n",
+    "\n",
+    "    return np.clip(rgb_image, 0, 255)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```python\n",
+    "centers = np.array([[1.50, 1.57, 1.625, 1.67, 1.72],\n",
+    "                    [1.42, 1.46,  1.50, 1.58, 1.66],\n",
+    "                    [3.43, 3.63,  3.89, 4.17, 4.47]]) #[3, 5]\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PSM Cos Volume takes 0.0013043880462646484 seconds at call time 1\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "../visualDet3D/networks/lib/PSM_cost_volume.py:82: UserWarning: volatile was removed and now has no effect. Use `with torch.no_grad():` instead.\n",
+      "  cost = Variable(\n",
+      "../visualDet3D/networks/lib/PSM_cost_volume.py:49: UserWarning: volatile was removed and now has no effect. Use `with torch.no_grad():` instead.\n",
+      "  cost = Variable(\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "index = 0\n",
+    "a = compute_once(index)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PSM Cos Volume takes 0.002501249313354492 seconds at call time 2\n",
+      "PSM Cos Volume takes 0.0020182132720947266 seconds at call time 3\n",
+      "Cost Volume takes 0.001317739486694336 seconds at call time 1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x648 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#%matplotlib inline\n",
+    "fig = plt.figure(figsize=(16,9))\n",
+    "index += 1\n",
+    "a = compute_once(index, is_test_train=False, is_draw=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/stereo3d.md b/docs/stereo3d.md
new file mode 100644
index 0000000..6cf5a69
--- /dev/null
+++ b/docs/stereo3d.md
@@ -0,0 +1,34 @@
+# Stereo3D
+
+## Training Schedule
+
+```bash
+# copy Stereo 3D example config
+cd config
+cp Stereo3D_example $CONFIG_FILE.py
+
+## Modify config path
+nano $CONFIG_FILE.py
+cd ..
+
+## Compute image database and anchors mean/std
+# You can run ./launcher/det_precompute.sh without arguments to see helper documents
+./launcher/det_precompute.sh config/$CONFIG_FILE.py train
+./launcher/det_precompute.sh config/$CONFIG_FILE.py test
+
+## run this if disparity map is needed, can be computed with point cloud or openCV BlockMatching
+# You can run ./launcher/disparity_precompute.sh without arguments to see helper documents
+./disparity_precompute.sh config/$CONFIG_FILE.py $IsUsingPointCloud
+
+## train the model with one GPU
+# You can run ./launcher/train.sh without arguments to see helper documents
+./launcher/train.sh  --config/$CONFIG_FILE.py 0 $experiment_name # validation goes along
+
+## produce validation/test result # we only support single GPU testing
+# You can run ./launcher/eval.sh without arguments to see helper documents
+./launcher/eval.sh --config/$CONFIG_FILE.py 0 $CHECKPOINT_PATH validation/test
+```
+
+
+## Testing on KITTI
+![stere3d_gif](stereo_3d.gif)
\ No newline at end of file
diff --git a/docs/stereo_3d.gif b/docs/stereo_3d.gif
new file mode 100644
index 0000000..f4fbbb6
Binary files /dev/null and b/docs/stereo_3d.gif differ
diff --git a/launchers/disparity_precompute.sh b/launchers/disparity_precompute.sh
new file mode 100755
index 0000000..237d3cb
--- /dev/null
+++ b/launchers/disparity_precompute.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+set -e
+if [[ "$2" == "" ]];then
+    echo -e "--------------------Disparity Ground Truth Precompute script------------------"
+    echo -e "Two arguments are needed. Usage: \n"
+    echo -e "   ./disparity_precompute.sh <ConfigPath> <IsUsingPointCloud>\n"
+    echo -e "exiting"
+    echo -e "------------------------------------------------------------------"
+    exit 1
+fi
+CONFIG_PATH=$1
+IS_PC=$2
+
+
+python3 scripts/disparity_compute.py --config=$CONFIG_PATH --use_point_cloud=$IS_PC
diff --git a/make.sh b/make.sh
index 7101061..8fd381d 100755
--- a/make.sh
+++ b/make.sh
@@ -8,8 +8,13 @@ CUDA_VER=$(python3 -c "import torch;print(torch.version.cuda)")
 if [[ $CUDA_VER < "10.0" || $TORCH_VER < '1.3' ]] ; then 
     echo "The current version of pytorch/cuda is $TORCH_VER/$CUDA_VER which could be not compatible with deformable convolution, we will not compile DCN for now. As long as you do not init DCN instance in code, the code will run fine."
 else
-    cd visualDet3D/networks/lib/ops/dcn
+    pushd visualDet3D/networks/lib/ops/dcn
     sh make.sh
     rm -r build
-    cd ../../../../..
+    popd
+
+    pushd visualDet3D/networks/lib/ops/iou3d
+    sh make.sh
+    rm -r build
+    popd
 fi
diff --git a/scripts/disparity_compute.py b/scripts/disparity_compute.py
new file mode 100644
index 0000000..1abf683
--- /dev/null
+++ b/scripts/disparity_compute.py
@@ -0,0 +1,149 @@
+from tqdm import tqdm
+import numpy as np
+import os
+import pickle
+import time
+import cv2
+from fire import Fire
+from typing import List, Dict, Tuple
+from copy import deepcopy
+import skimage.measure
+import torch
+
+from _path_init import *
+from visualDet3D.networks.heads.anchors import Anchors
+from visualDet3D.networks.utils.utils import calc_iou, BBox3dProjector
+from visualDet3D.data.pipeline import build_augmentator
+from visualDet3D.data.kitti.kittidata import KittiData
+from visualDet3D.data.kitti.utils import generate_dispariy_from_velo
+from visualDet3D.utils.timer import Timer
+from visualDet3D.utils.utils import cfg_from_file
+def denorm(image:np.ndarray, rgb_mean:np.ndarray, rgb_std:np.ndarray)->np.ndarray:
+    """
+        Denormalize a image.
+        Args:
+            image: np.ndarray normalized [H, W, 3]
+            rgb_mean: np.ndarray [3] among [0, 1] image
+            rgb_std : np.ndarray [3] among [0, 1] image
+        Returns:
+            unnormalized image: np.ndarray (H, W, 3) [0-255] dtype=np.uint8
+    """
+    image = image * rgb_std + rgb_mean #
+    image[image > 1] = 1
+    image[image < 0] = 0
+    image *= 255
+    return np.array(image, dtype=np.uint8)
+
+def process_train_val_file(cfg)-> Tuple[List[str], List[str]]:
+    train_file = cfg.data.train_split_file
+    val_file   = cfg.data.val_split_file
+
+    with open(train_file) as f:
+        train_lines = f.readlines()
+        for i  in range(len(train_lines)):
+            train_lines[i] = train_lines[i].strip()
+
+    with open(val_file) as f:
+        val_lines = f.readlines()
+        for i  in range(len(val_lines)):
+            val_lines[i] = val_lines[i].strip()
+
+    return train_lines, val_lines
+
+def compute_dispairity_for_split(cfg,
+                                 index_names:List[str], 
+                                 data_root_dir:str, 
+                                 output_dict:Dict, 
+                                 data_split:str='training', 
+                                 time_display_inter:int=100, 
+                                 use_point_cloud:bool=True):
+    save_dir = os.path.join(cfg.path.preprocessed_path, data_split)
+    if not os.path.isdir(save_dir):
+        os.makedirs(save_dir)
+
+    disp_dir = os.path.join(save_dir, 'disp')
+    if not os.path.isdir(disp_dir):
+        os.mkdir(disp_dir)
+
+    if not use_point_cloud:
+        stereo_matcher = cv2.StereoBM_create(192, 25)
+
+    N = len(index_names)
+    frames = [None] * N
+    print("start reading {} data".format(data_split))
+    timer = Timer()
+    preprocess = build_augmentator(cfg.data.test_augmentation)
+
+    for i, index_name in tqdm(enumerate(index_names)):
+
+        # read data with dataloader api
+        data_frame = KittiData(data_root_dir, index_name, output_dict)
+        calib, image, right_image, label, velo = data_frame.read_data()
+
+        original_image = image.copy()
+        baseline = (calib.P2[0, 3] - calib.P3[0, 3]) / calib.P2[0, 0]
+        image, image_3, P2, P3 = preprocess(original_image, right_image.copy(), p2=deepcopy(calib.P2), p3=deepcopy(calib.P3))
+        if use_point_cloud:
+            ## gathering disparity with point cloud back projection
+            disparity_left = generate_dispariy_from_velo(velo[:, 0:3], image.shape[0], image.shape[1], calib.Tr_velo_to_cam, calib.R0_rect, P2, baseline=baseline)
+            disparity_right = generate_dispariy_from_velo(velo[:, 0:3], image.shape[0], image.shape[1], calib.Tr_velo_to_cam, calib.R0_rect, P3, baseline=baseline)
+
+        else:
+            ## gathering disparity with stereoBM from opencv
+            left_image  = denorm(image, cfg.data.augmentation.rgb_mean, cfg.data.augmentation.rgb_std)
+            right_image = denorm(image_3, cfg.data.augmentation.rgb_mean, cfg.data.augmentation.rgb_std)
+            gray_image1 = cv2.cvtColor(left_image, cv2.COLOR_BGR2GRAY)
+            gray_image2 = cv2.cvtColor(right_image, cv2.COLOR_BGR2GRAY)
+
+            disparity_left = stereo_matcher.compute(gray_image1, gray_image2)
+            disparity_left[disparity_left < 0] = 0
+            disparity_left = disparity_left.astype(np.uint16)
+
+            disparity_right = stereo_matcher.compute(gray_image2[:, ::-1], gray_image1[:, ::-1])
+            disparity_right[disparity_right < 0] = 0
+            disparity_right= disparity_right.astype(np.uint16)
+
+        
+        disparity_left = skimage.measure.block_reduce(disparity_left, (4,4), np.max)
+        file_name = os.path.join(disp_dir, "P2%06d.png" % i)
+        cv2.imwrite(file_name, disparity_left)
+
+        disparity_right = skimage.measure.block_reduce(disparity_right, (4,4), np.max)
+        file_name = os.path.join(disp_dir, "P3%06d.png" % i)
+        cv2.imwrite(file_name, disparity_left)
+
+
+
+    print("{} split finished precomputing disparity".format(data_split))
+
+
+
+
+def main(config:str="config/config.py",use_point_cloud:bool=False):
+    """Main entry point for disparity precompute
+    config_file(str): path to the config file.
+    use_point_cloud(bool):  whether use OpenCV or point cloud to construct disparity ground truth.
+    """
+    cfg = cfg_from_file(config)
+    torch.cuda.set_device(cfg.trainer.gpu)
+    time_display_inter = 100 # define the inverval displaying time consumed in loop
+    data_root_dir = cfg.path.data_path # the base directory of training dataset
+    calib_path = os.path.join(data_root_dir, 'calib') 
+    list_calib = os.listdir(calib_path)
+    N = len(list_calib)
+    # no need for image, could be modified for extended use
+    output_dict = {
+                "calib": True,
+                "image": True,
+                "image_3" : True,
+                "label": False,
+                "velodyne": use_point_cloud,
+            }
+
+    train_names, val_names = process_train_val_file(cfg)
+    compute_dispairity_for_split(cfg, train_names, data_root_dir, output_dict, 'training', time_display_inter, use_point_cloud)
+
+    print("Preprocessing finished")
+
+if __name__ == '__main__':
+    Fire(main)
diff --git a/scripts/train.py b/scripts/train.py
index 50e70c0..abcd5d7 100644
--- a/scripts/train.py
+++ b/scripts/train.py
@@ -15,7 +15,7 @@
 
 from _path_init import *
 from visualDet3D.networks.utils.registry import DETECTOR_DICT, DATASET_DICT, PIPELINE_DICT
-from visualDet3D.networks.utils.utils import get_num_parameters
+from visualDet3D.networks.utils.utils import BackProjection, BBox3dProjector, get_num_parameters
 from visualDet3D.evaluator.kitti.evaluate import evaluate
 import visualDet3D.data.kitti.dataset
 from visualDet3D.utils.timer import Timer
@@ -61,7 +61,9 @@ def main(config="config/config.py", experiment_name="default", world_size=1, loc
         writer = None
 
     ## Set up GPU and distribution process
-    gpu = min(local_rank if is_distributed else cfg.trainer.gpu, torch.cuda.device_count() - 1)
+    if is_distributed:
+        cfg.trainer.gpu = local_rank # local_rank will overwrite the GPU in configure file
+    gpu = min(cfg.trainer.gpu, torch.cuda.device_count() - 1)
     torch.backends.cudnn.benchmark = getattr(cfg.trainer, 'cudnn', False)
     torch.cuda.set_device(gpu)
     if is_distributed:
@@ -142,7 +144,7 @@ def main(config="config/config.py", experiment_name="default", world_size=1, loc
         if training_loss_logger:
             training_loss_logger.reset()
         for iter_num, data in enumerate(dataloader_train):
-            training_dection(data, detector, optimizer, writer, training_loss_logger, global_step, cfg)
+            training_dection(data, detector, optimizer, writer, training_loss_logger, global_step, epoch_num, cfg)
 
             global_step += 1
 
@@ -151,12 +153,15 @@ def main(config="config/config.py", experiment_name="default", world_size=1, loc
 
             if is_logging and global_step % cfg.trainer.disp_iter == 0:
                 ## Log loss, print out and write to tensorboard in main process
-                log_str = 'Epoch: {} | Iteration: {}  | Running loss: {:1.5f} | eta:{}'.format(
+                if 'total_loss' not in training_loss_logger.loss_stats:
+                    print(f"\nIn epoch {epoch_num}, iteration:{iter_num}, global_step:{global_step}, total_loss not found in logger.")
+                else:
+                    log_str = 'Epoch: {} | Iteration: {}  | Running loss: {:1.5f} | eta:{}'.format(
                         epoch_num, iter_num, training_loss_logger.loss_stats['total_loss'].avg,
                         timer.compute_eta(global_step, len(dataloader_train) * cfg.trainer.max_epochs))
-                print(log_str, end='\r')
-                writer.add_text("training_log/train", log_str, global_step)
-                training_loss_logger.log(global_step)
+                    print(log_str, end='\r')
+                    writer.add_text("training_log/train", log_str, global_step)
+                    training_loss_logger.log(global_step)
 
         if not is_iter_based:
             scheduler.step()
diff --git a/visualDet3D/data/kitti/dataset/KM3D_dataset.py b/visualDet3D/data/kitti/dataset/KM3D_dataset.py
new file mode 100644
index 0000000..0f8d6d2
--- /dev/null
+++ b/visualDet3D/data/kitti/dataset/KM3D_dataset.py
@@ -0,0 +1,278 @@
+from __future__ import print_function, division
+import sys
+import os
+import torch
+import numpy as np
+import random
+import csv
+from typing import List, Tuple
+from torch.utils.data import Dataset, DataLoader
+
+import torch
+import torch.nn as nn
+import torch.utils.data
+from visualDet3D.utils.utils import alpha2theta_3d, theta2alpha_3d
+from visualDet3D.data.kitti.kittidata import KittiData, KittiObj, KittiCalib
+from visualDet3D.data.kitti.dataset import KittiMonoDataset
+from visualDet3D.data.pipeline import build_augmentator
+from visualDet3D.utils.timer import profile
+from visualDet3D.networks.utils.rtm3d_utils import gen_hm_radius, project_to_image, gaussian_radius
+import os
+import pickle
+import numpy as np
+from copy import deepcopy
+from visualDet3D.networks.utils import BBox3dProjector
+from visualDet3D.networks.utils.registry import DATASET_DICT
+import sys
+from matplotlib import pyplot as plt
+ros_py_path = '/opt/ros/kinetic/lib/python2.7/dist-packages'
+if sys.version_info > (3, 0) and ros_py_path in sys.path:
+    #Python 3, compatible with a naive ros environment
+    sys.path.remove(ros_py_path)
+    import cv2
+    sys.path.append(ros_py_path)
+else:
+    #Python 2
+    import cv2
+
+@DATASET_DICT.register_module
+class KittiRTM3DDataset(KittiMonoDataset):
+    def __init__(self, cfg, split='training'):
+        super(KittiRTM3DDataset, self).__init__(cfg, split)
+        self.num_classes = len(self.obj_types)
+        self.num_vertexes = 9
+        self.max_objects = 32
+        self.projector.register_buffer('corner_matrix', torch.tensor(
+            [[-1, -1, -1],
+            [ 1, -1, -1],
+            [ 1,  1, -1],
+            [ 1,  1,  1],
+            [ 1, -1,  1],
+            [-1, -1,  1],
+            [-1,  1,  1],
+            [-1,  1, -1],
+            [ 0,  0,  0]]
+        ).float()  )# 9, 3
+
+    def _build_target(self, image:np.ndarray, P2:np.ndarray, transformed_label:List[KittiObj], scale=4)-> dict:
+        """Encode Targets for RTM3D
+
+        Args:
+            image (np.ndarray): augmented image [H, W, 3]
+            P2 (np.ndarray): Calibration matrix [3, 4]
+            transformed_label (List[KittiObj]): A list of kitti objects.
+            scale (int, optional): Downsampling scale. Defaults to 4.
+
+        Returns:
+            dict: label dicts
+        """        
+        num_objects = len(transformed_label)
+        hm_h, hm_w = image.shape[0] // scale, image.shape[1] // scale
+
+        # setup empty targets
+        hm_main_center = np.zeros((self.num_classes, hm_h, hm_w), dtype=np.float32)
+        hm_ver = np.zeros((self.num_vertexes, hm_h, hm_w), dtype=np.float32)
+
+        cen_offset = np.zeros((self.max_objects, 2), dtype=np.float32)
+        indices_center = np.zeros((self.max_objects), dtype=np.int64)
+        obj_mask = np.zeros((self.max_objects), dtype=np.uint8)
+        location = np.zeros((self.max_objects, 3), dtype=np.float32)
+        orientation = np.zeros((self.max_objects, 1), dtype=np.float32)
+        rotbin = np.zeros((self.max_objects, 2), dtype=np.int64)
+        rotres = np.zeros((self.max_objects, 2), dtype=np.float32)
+        ver_coor = np.zeros((self.max_objects, self.num_vertexes * 2), dtype=np.float32)
+        ver_coor_mask = np.zeros((self.max_objects, self.num_vertexes * 2), dtype=np.uint8)
+        ver_offset = np.zeros((self.max_objects * self.num_vertexes, 2), dtype=np.float32)
+        ver_offset_mask = np.zeros((self.max_objects * self.num_vertexes), dtype=np.uint8)
+        indices_vertexes = np.zeros((self.max_objects * self.num_vertexes), dtype=np.int64)
+
+        dimension = np.zeros((self.max_objects, 3), dtype=np.float32)
+
+        rots = np.zeros((self.max_objects, 2), dtype=np.float32) #[sin, cos]
+
+        depth = np.zeros((self.max_objects, 1), dtype=np.float32)
+        whs = np.zeros((self.max_objects, 2), dtype=np.float32)
+
+        # compute vertexes
+        bbox3d_state = np.zeros([len(transformed_label), 7]) #[camera_x, camera_y, z, w, h, l, alpha]
+        for obj in transformed_label:
+            obj.alpha = theta2alpha_3d(obj.ry, obj.x, obj.z, P2)
+        bbox3d_origin = torch.tensor([[obj.x, obj.y - 0.5 * obj.h, obj.z, obj.w, obj.h, obj.l, obj.alpha] for obj in transformed_label], dtype=torch.float32).reshape(-1, 7)
+        abs_corner, homo_corner, theta = self.projector.forward(bbox3d_origin, torch.tensor(P2, dtype=torch.float32))
+
+        # # For debuging and visualization, testing the correctness of bbox3d->bbox2d
+        # a = plt.figure(figsize=(16,9))
+        # plt.subplot(3, 1, 1)
+        # image2 = np.array(np.clip(image * np.array([0.229, 0.224, 0.225]) + np.array([0.485, 0.456, 0.406]), 0, 1) * 255, dtype=np.uint8)
+        # max_xy, _= homo_corner[:, :, 0:2].max(dim = 1)  # [N,2]
+        # min_xy, _= homo_corner[:, :, 0:2].min(dim = 1)  # [N,2]
+
+        # result = torch.cat([min_xy, max_xy], dim=-1) #[:, 4]
+
+        # bbox2d = result.cpu().numpy()
+        # for i in range(len(transformed_label)):
+        #     image2 = cv2.rectangle(image2, tuple(bbox2d[i, 0:2].astype(int)), tuple(bbox2d[i, 2:4].astype(int)), (0, 255, 0) , 3)
+        #     draw_3D_box(image2, homo_corner[i].cpu().numpy().T)
+        # plt.imshow(image2)
+        # plt.show()
+
+
+        for k in range(num_objects):
+            obj = transformed_label[k]
+            cls_id = self.obj_types.index(obj.type)
+            bbox = np.array([obj.bbox_l, obj.bbox_t, obj.bbox_r, obj.bbox_b])
+            orientation[k] = obj.ry
+            dim  = np.array([obj.w, obj.h, obj.l])
+            ry   = obj.ry
+            alpha= obj.alpha
+
+            if np.sin(alpha) < 0.5: #alpha < np.pi / 6. or alpha > 5 * np.pi / 6.:
+                rotbin[k, 0] = 1
+                rotres[k, 0] = alpha - (-0.5 * np.pi)
+            if np.sin(alpha) > -0.5: # alpha > -np.pi / 6. or alpha < -5 * np.pi / 6.:
+                rotbin[k, 1] = 1
+                rotres[k, 1] = alpha - (0.5 * np.pi)
+
+            bbox = bbox / scale  # on the heatmap
+            bbox[[0, 2]] = np.clip(bbox[[0, 2]], 0, image.shape[1] // scale)
+            bbox[[1, 3]] = np.clip(bbox[[1, 3]], 0, image.shape[0] // scale)
+            bbox_h, bbox_w = bbox[3] - bbox[1], bbox[2] - bbox[0]
+            if bbox_h > 0 and bbox_w > 0:
+                sigma = 1.  # Just dummy
+                radius = 1  # Just dummy
+
+                location[k] = bbox3d_origin[k, 0:3].float().cpu().numpy()
+
+                radius = gaussian_radius((np.ceil(bbox_h), np.ceil(bbox_w)))
+                radius = max(0, int(radius))
+                # Generate heatmaps for 8 vertexes
+                vertexes_2d = homo_corner[k, :, 0:2].numpy()
+
+                vertexes_2d = vertexes_2d / scale  # on the heatmap
+
+                center = np.array([(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2], dtype=np.float32)
+                center_int = center.astype(np.int32)
+                
+                if not (0 <= center_int[0] < hm_w and 0 <= center_int[1] < hm_h):
+                    continue
+
+                # Generate heatmaps for main center
+                gen_hm_radius(hm_main_center[cls_id], center, radius)
+                # Index of the center
+                indices_center[k] = center_int[1] * hm_w + center_int[0]
+
+                for ver_idx, ver in enumerate(vertexes_2d):
+                    ver_int = ver.astype(np.int32)
+                    
+                    # targets for vertexes coordinates
+                    ver_coor[k, ver_idx * 2: (ver_idx + 1) * 2] = ver - center_int  # Don't take the absolute values
+                    ver_coor_mask[k, ver_idx * 2: (ver_idx + 1) * 2] = 1
+                    
+                    if (0 <= ver_int[0] < hm_w) and (0 <= ver_int[1] < hm_h):
+                        gen_hm_radius(hm_ver[ver_idx], ver_int, radius)
+                        
+                        # targets for vertexes offset
+                        ver_offset[k * self.num_vertexes + ver_idx] = ver - ver_int
+                        ver_offset_mask[k * self.num_vertexes + ver_idx] = 1
+                        # Indices of vertexes
+                        indices_vertexes[k * self.num_vertexes + ver_idx] = ver_int[1] * hm_w + ver_int[0]
+
+                # targets for center offset
+                cen_offset[k] = center - center_int
+
+                # targets for dimension
+                dimension[k] = dim
+
+                # targets for orientation
+                rots[k, 0] = np.sin(alpha)
+                rots[k, 1] = np.cos(alpha)
+
+                # targets for depth
+                depth[k] = obj.z
+
+                # targets for 2d bbox
+                whs[k, 0] = bbox_w
+                whs[k, 1] = bbox_h
+
+                # Generate masks
+                obj_mask[k] = 1
+        # Follow official names
+        targets = {
+            'hm': hm_main_center,
+            'hm_hp': hm_ver,
+            'hps': ver_coor,
+            'reg': cen_offset,
+            'hp_offset': ver_offset,
+            'dim': dimension, #whl
+            'rots': rots, # sin cos alpha
+            'rotbin': rotbin,
+            'rotres': rotres,
+            'dep': depth,
+            'ind': indices_center,
+            'hp_ind': indices_vertexes,
+            'reg_mask': obj_mask,
+            'hps_mask': ver_coor_mask,
+            'hp_mask': ver_offset_mask,
+            'wh': whs,
+            'location': location,
+            'ori': orientation
+        }
+
+        return targets
+
+    def __getitem__(self, index):
+        kitti_data = self.imdb[index % len(self.imdb)]
+        # The calib and label has been preloaded to minimize the time in each indexing
+        if index >= len(self.imdb):
+            kitti_data.output_dict = {
+                "calib": True,
+                "image": False,
+                "image_3":True,
+                "label": False,
+                "velodyne": False
+            }
+            calib, _, image, _, _ = kitti_data.read_data()
+            calib.P2 = calib.P3 # a workaround to use P3 for right camera images. 3D bboxes are the same(cx, cy, z, w, h, l, alpha)
+        else:
+            kitti_data.output_dict = self.output_dict
+            _, image, _, _ = kitti_data.read_data()
+            calib = kitti_data.calib
+        calib.image_shape = image.shape
+        label = kitti_data.label # label: list of kittiObj
+        label = []
+        for obj in kitti_data.label:
+            if obj.type in self.obj_types:
+                label.append(obj)
+        transformed_image, transformed_P2, transformed_label = self.transform(image, p2=deepcopy(calib.P2), labels=deepcopy(label))
+        targets = self._build_target(transformed_image, transformed_P2, transformed_label)
+        
+        output_dict = {'calib': transformed_P2,
+                       'image': transformed_image,
+                       'label': targets, 
+                       'original_shape':image.shape,
+                       'original_P':calib.P2.copy()}
+        
+        return output_dict
+        
+    
+    def __len__(self):
+        return len(self.imdb)
+
+    @staticmethod
+    def collate_fn(batch):
+        rgb_images = np.array([item["image"] for item in batch])#[batch, H, W, 3]
+        rgb_images = rgb_images.transpose([0, 3, 1, 2])
+
+        calib = [item["calib"] for item in batch]
+
+        # gather labels
+        label = {}
+        for key in batch[0]['label']:
+            label[key] = torch.from_numpy(
+                np.stack(
+                    [
+                        item['label'][key] for item in batch
+                    ], axis=0
+                )
+            )
+        return torch.from_numpy(rgb_images).float(), torch.tensor(calib).float(), label
diff --git a/visualDet3D/data/kitti/dataset/__init__.py b/visualDet3D/data/kitti/dataset/__init__.py
index 866fe31..d41106f 100644
--- a/visualDet3D/data/kitti/dataset/__init__.py
+++ b/visualDet3D/data/kitti/dataset/__init__.py
@@ -1,2 +1,4 @@
 from .mono_dataset import KittiMonoDataset, KittiMonoTestDataset
-from .depth_mono_dataset import KittiDepthMonoDataset, KittiDepthMonoValTestDataset
\ No newline at end of file
+from .depth_mono_dataset import KittiDepthMonoDataset, KittiDepthMonoValTestDataset
+from .stereo_dataset import KittiStereoDataset, KittiStereoTestDataset
+from .KM3D_dataset import KittiRTM3DDataset
\ No newline at end of file
diff --git a/visualDet3D/data/kitti/dataset/mono_dataset.py b/visualDet3D/data/kitti/dataset/mono_dataset.py
index 9920173..a3338f1 100644
--- a/visualDet3D/data/kitti/dataset/mono_dataset.py
+++ b/visualDet3D/data/kitti/dataset/mono_dataset.py
@@ -11,6 +11,7 @@
 import torch
 import torch.nn as nn
 import torch.utils.data
+from visualDet3D.utils.utils import alpha2theta_3d, theta2alpha_3d
 from visualDet3D.data.kitti.kittidata import KittiData, KittiObj, KittiCalib
 from visualDet3D.data.pipeline import build_augmentator
 import os
@@ -60,6 +61,8 @@ def __init__(self, cfg, split='training'):
 
     def _reproject(self, P2:np.ndarray, transformed_label:List[KittiObj]) -> Tuple[List[KittiObj], np.ndarray]:
         bbox3d_state = np.zeros([len(transformed_label), 7]) #[camera_x, camera_y, z, w, h, l, alpha]
+        for obj in transformed_label:
+            obj.alpha = theta2alpha_3d(obj.ry, obj.x, obj.z, P2)
         bbox3d_origin = torch.tensor([[obj.x, obj.y - 0.5 * obj.h, obj.z, obj.w, obj.h, obj.l, obj.alpha] for obj in transformed_label], dtype=torch.float32)
         abs_corner, homo_corner, _ = self.projector(bbox3d_origin, bbox3d_origin.new(P2))
         for i, obj in enumerate(transformed_label):
diff --git a/visualDet3D/data/kitti/dataset/stereo_dataset.py b/visualDet3D/data/kitti/dataset/stereo_dataset.py
new file mode 100644
index 0000000..b4145f0
--- /dev/null
+++ b/visualDet3D/data/kitti/dataset/stereo_dataset.py
@@ -0,0 +1,204 @@
+from __future__ import print_function, division
+import sys
+import os
+import torch
+import numpy as np
+import random
+import csv
+from typing import List, Tuple
+from torch.utils.data import Dataset, DataLoader
+import torch
+import torch.utils.data
+from visualDet3D.data.kitti.kittidata import KittiData, KittiObj, KittiCalib
+from visualDet3D.data.pipeline import build_augmentator
+
+import os
+import pickle
+import numpy as np
+from copy import deepcopy
+from visualDet3D.utils.utils import alpha2theta_3d, theta2alpha_3d, draw_3D_box
+from visualDet3D.networks.utils import BBox3dProjector
+from visualDet3D.networks.utils.registry import DATASET_DICT
+import sys
+from matplotlib import pyplot as plt
+ros_py_path = '/opt/ros/kinetic/lib/python2.7/dist-packages'
+if sys.version_info > (3, 0) and ros_py_path in sys.path:
+    #Python 3, compatible with a naive ros environment
+    sys.path.remove(ros_py_path)
+    import cv2
+    sys.path.append(ros_py_path)
+else:
+    #Python 2
+    import cv2
+
+@DATASET_DICT.register_module
+class KittiStereoDataset(torch.utils.data.Dataset):
+    """Some Information about KittiDataset"""
+    def __init__(self, cfg, split='training'):
+        super(KittiStereoDataset, self).__init__()
+        preprocessed_path   = cfg.path.preprocessed_path
+        obj_types           = cfg.obj_types
+        aug_cfg             = cfg.data.augmentation
+        is_train = (split == 'training')
+        imdb_file_path = os.path.join(preprocessed_path, split, 'imdb.pkl')
+        self.imdb = pickle.load(open(imdb_file_path, 'rb')) # list of kittiData
+        self.output_dict = {
+                "calib": True,
+                "image": True,
+                "image_3":True,
+                "label": False,
+                "velodyne": False
+            }
+        if is_train:
+            self.transform = build_augmentator(cfg.data.train_augmentation)
+        else:
+            self.transform = build_augmentator(cfg.data.test_augmentation)
+        self.projector = BBox3dProjector()
+        self.is_train = is_train
+        self.obj_types = obj_types
+        self.preprocessed_path = preprocessed_path
+
+    def _reproject(self, P2:np.ndarray, transformed_label:List[KittiObj]) -> Tuple[List[KittiObj], np.ndarray]:
+        bbox3d_state = np.zeros([len(transformed_label), 7]) #[camera_x, camera_y, z, w, h, l, alpha]
+        if len(transformed_label) > 0:
+            #for obj in transformed_label:
+            #    obj.alpha = theta2alpha_3d(obj.ry, obj.x, obj.z, P2)
+            bbox3d_origin = torch.tensor([[obj.x, obj.y - 0.5 * obj.h, obj.z, obj.w, obj.h, obj.l, obj.alpha] for obj in transformed_label], dtype=torch.float32)
+            try:
+                abs_corner, homo_corner, _ = self.projector.forward(bbox3d_origin, bbox3d_origin.new(P2))
+            except:
+                print('\n',bbox3d_origin.shape, len(transformed_label), len(label), label, transformed_label, bbox3d_origin)
+            for i, obj in enumerate(transformed_label):
+                extended_center = np.array([obj.x, obj.y - 0.5 * obj.h, obj.z, 1])[:, np.newaxis] #[4, 1]
+                extended_bottom = np.array([obj.x, obj.y, obj.z, 1])[:, np.newaxis] #[4, 1]
+                image_center = (P2 @ extended_center)[:, 0] #[3]
+                image_center[0:2] /= image_center[2]
+
+                image_bottom = (P2 @ extended_bottom)[:, 0] #[3]
+                image_bottom[0:2] /= image_bottom[2]
+                
+                bbox3d_state[i] = np.concatenate([image_center,
+                                                 [obj.w, obj.h, obj.l, obj.alpha]]) #[7]
+
+            max_xy, _= homo_corner[:, :, 0:2].max(dim = 1)  # [N,2]
+            min_xy, _= homo_corner[:, :, 0:2].min(dim = 1)  # [N,2]
+
+            result = torch.cat([min_xy, max_xy], dim=-1) #[:, 4]
+
+            bbox2d = result.cpu().numpy()
+
+            for i in range(len(transformed_label)):
+                transformed_label[i].bbox_l = bbox2d[i, 0]
+                transformed_label[i].bbox_t = bbox2d[i, 1]
+                transformed_label[i].bbox_r = bbox2d[i, 2]
+                transformed_label[i].bbox_b = bbox2d[i, 3]
+        return transformed_label, bbox3d_state
+        
+    def __getitem__(self, index):
+        kitti_data = self.imdb[index]
+        # The calib and label has been preloaded to minimize the time in each indexing
+        kitti_data.output_dict = self.output_dict
+        calib, left_image, right_image, _, _ = kitti_data.read_data()
+        calib.image_shape = left_image.shape
+        label = []
+        for obj in kitti_data.label:
+            if obj.type in self.obj_types:
+                label.append(obj)
+        transformed_left_image, transformed_right_image, P2, P3, transformed_label = self.transform(
+                left_image, right_image, deepcopy(calib.P2),deepcopy(calib.P3), deepcopy(label)
+        )
+        bbox3d_state = np.zeros([len(transformed_label), 7]) #[camera_x, camera_y, z, w, h, l, alpha]
+        
+        if len(transformed_label) > 0:
+            transformed_label, bbox3d_state = self._reproject(P2, transformed_label)
+
+        if self.is_train:
+            if abs(P2[0, 3]) < abs(P3[0, 3]): # not mirrored or swaped, disparity should base on pointclouds projecting through P2
+                disparity = cv2.imread(os.path.join(self.preprocessed_path, 'training', 'disp', "P2%06d.png" % index), -1)
+            else: # mirrored and swap, disparity should base on pointclouds projecting through P3, and also mirrored
+                disparity = cv2.imread(os.path.join(self.preprocessed_path, 'training', 'disp', "P3%06d.png" % index), -1)
+                disparity = disparity[:, ::-1]
+            disparity = disparity / 16.0
+        else:
+            disparity = None
+
+        bbox2d = np.array([[obj.bbox_l, obj.bbox_t, obj.bbox_r, obj.bbox_b] for obj in transformed_label])
+        
+        output_dict = {'calib': [P2, P3],
+                       'image': [transformed_left_image, transformed_right_image],
+                       'label': [obj.type for obj in transformed_label], 
+                       'bbox2d': bbox2d, #[N, 4] [x1, y1, x2, y2]
+                       'bbox3d': bbox3d_state,
+                       'original_shape': calib.image_shape,
+                       'disparity': disparity,
+                       'original_P':calib.P2.copy()}
+        return output_dict
+
+    def __len__(self):
+        return len(self.imdb)
+
+    @staticmethod
+    def collate_fn(batch):
+        left_images = np.array([item["image"][0] for item in batch])#[batch, H, W, 3]
+        left_images = left_images.transpose([0, 3, 1, 2])
+
+        right_images = np.array([item["image"][1] for item in batch])#[batch, H, W, 3]
+        right_images = right_images.transpose([0, 3, 1, 2])
+
+        P2 = [item['calib'][0] for item in batch]
+        P3 = [item['calib'][1] for item in batch]
+        label = [item['label'] for item in batch]
+        bbox2ds = [item['bbox2d'] for item in batch]
+        bbox3ds = [item['bbox3d'] for item in batch]
+        disparities = [item['disparity'] for item in batch]
+        if disparities[0] is None:
+            return torch.from_numpy(left_images).float(), torch.from_numpy(right_images).float(), torch.tensor(P2).float(), torch.tensor(P3).float(), label, bbox2ds, bbox3ds
+        else:
+            return torch.from_numpy(left_images).float(), torch.from_numpy(right_images).float(), torch.tensor(P2).float(), torch.tensor(P3).float(), label, bbox2ds, bbox3ds, torch.tensor(disparities).float()
+
+@DATASET_DICT.register_module
+class KittiStereoTestDataset(KittiStereoDataset):
+    def __init__(self, cfg, split='test'):
+        preprocessed_path   = cfg.path.preprocessed_path
+        obj_types           = cfg.obj_types
+        aug_cfg             = cfg.data.augmentation
+        super(KittiStereoTestDataset, self).__init__(cfg, split)
+        imdb_file_path = os.path.join(preprocessed_path, 'test', 'imdb.pkl')
+        self.imdb = pickle.load(open(imdb_file_path, 'rb')) # list of kittiData
+        self.output_dict = {
+                "calib": True,
+                "image": True,
+                "image_3":True,
+                "label": False,
+                "velodyne": False
+            }
+
+    def __getitem__(self, index):
+        kitti_data = self.imdb[index]
+        # The calib and label has been preloaded to minimize the time in each indexing
+        kitti_data.output_dict = self.output_dict
+        calib, left_image, right_image, _, _ = kitti_data.read_data()
+        calib.image_shape = left_image.shape
+
+        transformed_left_image, transformed_right_image, P2, P3 = self.transform(
+                left_image, right_image, deepcopy(calib.P2),deepcopy(calib.P3)
+        )
+
+        output_dict = {'calib': [P2, P3],
+                       'image': [transformed_left_image, transformed_right_image],
+                       'original_shape': calib.image_shape,
+                       'original_P':calib.P2.copy()}
+        return output_dict
+
+    @staticmethod
+    def collate_fn(batch):
+        left_images = np.array([item["image"][0] for item in batch])#[batch, H, W, 3]
+        left_images = left_images.transpose([0, 3, 1, 2])
+
+        right_images = np.array([item["image"][1] for item in batch])#[batch, H, W, 3]
+        right_images = right_images.transpose([0, 3, 1, 2])
+
+        P2 = [item['calib'][0] for item in batch]
+        P3 = [item['calib'][1] for item in batch]
+        return torch.from_numpy(left_images).float(), torch.from_numpy(right_images).float(), P2, P3
+
diff --git a/visualDet3D/data/kitti/utils.py b/visualDet3D/data/kitti/utils.py
index 3a9e21e..ca5a622 100644
--- a/visualDet3D/data/kitti/utils.py
+++ b/visualDet3D/data/kitti/utils.py
@@ -81,6 +81,83 @@ def _leftcam2imgplane(pts, P2):
     pixels[:, 1] /= pixels[:, 2] + 1e-6
     return pixels[:, :2]
 
+@jit(nopython=True, cache=True)
+def generate_dispariy_from_velo(pc_velo:np.ndarray,
+                                height:int,
+                                width:int,
+                                Tr_velo_to_cam:np.ndarray,
+                                R0_rect:np.ndarray,
+                                P2:np.ndarray,
+                                baseline:float=0.54):
+    """
+        Generate disparity map from point clouds.
+        Args:
+            pc_velo         : point clouds in lidar coordinate; np.array of shape [n, 3] -> [[x, y, z]; ...]
+            height, width   : output disparity map shape; int
+            Tr_velo_to_cam  : transform from lidar to camera; np.array [3, 4] -> [R | T]
+            R0_rect         : rotation transform into camera coordinates(z forward, x towards right); np.array [3, 4] -> [R | T]
+            P2              : transform from P0 camera coordinates to target image plane; np.array [3, 4] -> [R | T]
+            baseline        : baseline length in meter of the stereo setup; float
+        Output:
+            disp_map        : disparity map; np.array of [height, width], dtype=np.uint16; if disp_map==0 -> should be ignore
+    """
+    #pts_2d = calib.project_velo_to_image(pc_velo)
+    pts_cam = _lidar2leftcam(pc_velo, Tr_velo_to_cam, R0_rect)
+    pts_2d  = _leftcam2imgplane(pts_cam, P2)
+    fov_inds = (pts_2d[:, 0] < width - 1) & (pts_2d[:, 0] >= 0) & \
+               (pts_2d[:, 1] < height - 1) & (pts_2d[:, 1] >= 0)
+    fov_inds = fov_inds & (pc_velo[:, 0] > 2)
+    imgfov_pts_2d = pts_2d[fov_inds, :]
+    imgfov_pc_rect = pts_cam[fov_inds, :]
+    depth_map = np.ones((height, width)) * 1e9
+    imgfov_pts_2d =  imgfov_pts_2d.astype(np.int32)#np.round(imgfov_pts_2d).astype(int)
+    for i in range(imgfov_pts_2d.shape[0]):
+        depth = imgfov_pc_rect[i, 2]
+        depth_map[int(imgfov_pts_2d[i, 1]), int(imgfov_pts_2d[i, 0])] = depth
+
+    disp_map = (P2[0, 0] * baseline) / (depth_map) * 16
+    disp_map = disp_map.astype(np.uint16)
+    return disp_map
+
+@jit(nopython=True, cache=True)
+def generate_depth_from_velo(pc_velo:np.ndarray,
+                                height:int,
+                                width:int,
+                                Tr_velo_to_cam:np.ndarray,
+                                R0_rect:np.ndarray,
+                                P2:np.ndarray,
+                                base_depth:Optional[np.ndarray]=None):
+    """
+        Generate disparity map from point clouds.
+        Args:
+            pc_velo         : point clouds in lidar coordinate; np.array of shape [n, 3] -> [[x, y, z]; ...]
+            height, width   : output disparity map shape; int
+            Tr_velo_to_cam  : transform from lidar to camera; np.array [3, 4] -> [R | T]
+            R0_rect         : rotation transform into camera coordinates(z forward, x towards right); np.array [3, 4] -> [R | T]
+            P2              : transform from P0 camera coordinates to target image plane; np.array [3, 4] -> [R | T]
+            baseline        : baseline length in meter of the stereo setup; float
+        Output:
+            disp_map        : disparity map; np.array of [height, width], dtype=np.uint16; if disp_map==0 -> should be ignore
+    """
+    #pts_2d = calib.project_velo_to_image(pc_velo)
+    pts_cam = _lidar2leftcam(pc_velo, Tr_velo_to_cam, R0_rect)
+    pts_2d  = _leftcam2imgplane(pts_cam, P2)
+    fov_inds = (pts_2d[:, 0] < width - 1) & (pts_2d[:, 0] >= 0) & \
+               (pts_2d[:, 1] < height - 1) & (pts_2d[:, 1] >= 0)
+    fov_inds = fov_inds & (pc_velo[:, 0] > 2)
+    imgfov_pts_2d = pts_2d[fov_inds, :]
+    imgfov_pc_rect = pts_cam[fov_inds, :]
+
+    if base_depth is None:
+        depth_map = np.zeros((height, width))
+    else:
+        depth_map = base_depth
+    imgfov_pts_2d =  imgfov_pts_2d.astype(np.int32)#np.round(imgfov_pts_2d).astype(int)
+    for i in range(imgfov_pts_2d.shape[0]):
+        depth = imgfov_pc_rect[i, 2]
+        depth_map[int(imgfov_pts_2d[i, 1]), int(imgfov_pts_2d[i, 0])] = depth
+
+    return depth_map
 
 def write_result_to_file(base_result_path:str, 
                         index:int, scores, bbox_2d, bbox_3d_state_3d=None, thetas=None, obj_types=['Car', 'Pedestrian', 'Cyclist'], threshold=0.4):
diff --git a/visualDet3D/data/pipeline/augmentation_builder.py b/visualDet3D/data/pipeline/augmentation_builder.py
index 9787da7..f984491 100644
--- a/visualDet3D/data/pipeline/augmentation_builder.py
+++ b/visualDet3D/data/pipeline/augmentation_builder.py
@@ -3,14 +3,33 @@
 from easydict import EasyDict
 from visualDet3D.networks.utils.registry import AUGMENTATION_DICT
 from visualDet3D.data.kitti.kittidata import KittiObj
+
+def build_single_augmentator(cfg:EasyDict):
+    name:str = cfg.type_name
+    keywords:dict = getattr(cfg, 'keywords', dict())
+    return AUGMENTATION_DICT[name](**keywords)
+
+@AUGMENTATION_DICT.register_module
 class Compose(object):
     """
     Composes a set of functions which take in an image and an object, into a single transform
     """
-    def __init__(self, transforms:List[Callable], is_return_all=True):
-        self.transforms = transforms
+    # def __init__(self, transforms:List[Callable], is_return_all=True):
+    #     self.transforms = transforms
+    #     self.is_return_all = is_return_all
+
+    def __init__(self, aug_list:List[EasyDict], is_return_all=True):
+        self.transforms:List[Callable] = []
+        for item in aug_list:
+            self.transforms.append(build_single_augmentator(item))
         self.is_return_all = is_return_all
 
+    @classmethod
+    def from_transforms(cls, transforms:List[Callable]): 
+        instance:Compose = cls(aug_list=[])
+        instance.transforms = transforms
+        return instance
+
     def __call__(self, left_image:np.ndarray,
                        right_image:Union[None, np.ndarray]=None,
                        p2:Union[None, np.ndarray]=None,
@@ -34,12 +53,5 @@ def __call__(self, left_image:np.ndarray,
         return [item for item in return_list if item is not None]
 
 
-def build_augmentator(aug_cfg:EasyDict)->Compose:
-    transformers:List[Callable] = []
-    for item in aug_cfg:
-        name = item.type_name
-        keywords = getattr(item, 'keywords', dict())
-        transformers.append(
-            AUGMENTATION_DICT[name](**keywords)
-        )
-    return Compose(transformers, is_return_all=False)
+def build_augmentator(aug_cfg:List[EasyDict])->Compose:
+    return Compose(aug_cfg, is_return_all=False)
diff --git a/visualDet3D/data/pipeline/stereo_augmentator.py b/visualDet3D/data/pipeline/stereo_augmentator.py
index fd5cb4f..0a2be71 100644
--- a/visualDet3D/data/pipeline/stereo_augmentator.py
+++ b/visualDet3D/data/pipeline/stereo_augmentator.py
@@ -16,13 +16,15 @@
 import math
 import os
 import sys
+from easydict import EasyDict
+from typing import List
 from matplotlib import pyplot as plt
 from visualDet3D.networks.utils.utils import BBox3dProjector
-from visualDet3D.utils.utils import draw_3D_box
+from visualDet3D.utils.utils import draw_3D_box, theta2alpha_3d
 from visualDet3D.networks.utils.registry import AUGMENTATION_DICT
 from visualDet3D.data.kitti.kittidata import KittiObj
 import torch
-from .augmentation_builder import Compose
+from .augmentation_builder import Compose, build_single_augmentator
 
 @AUGMENTATION_DICT.register_module
 class ConvertToFloat(object):
@@ -293,6 +295,31 @@ def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None,
 
         return left_image, right_image, p2, p3, labels, image_gt, lidar
 
+@AUGMENTATION_DICT.register_module
+class FilterObject(object):
+    """
+        Filtering out object completely outside of the box;
+    """
+    def __init__(self):
+        pass
+
+    def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None, image_gt=None, lidar=None):
+        height, width = left_image.shape[0:2]
+
+        if labels is not None:
+            new_labels = []
+            if isinstance(labels, list):
+                # scale all coordinates
+                for obj in labels:
+                    is_outside = (
+                        obj.bbox_b < 0 or obj.bbox_t > height or obj.bbox_r < 0 or obj.bbox_l > width
+                    )
+                    if not is_outside:
+                        new_labels.append(obj)
+        else:
+            new_labels = None
+        
+        return left_image, right_image, p2, p3, new_labels, image_gt, lidar
 
 @AUGMENTATION_DICT.register_module
 class RandomCropToWidth(object):
@@ -402,13 +429,75 @@ def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None,
                         obj.ry = ry
 
                         # alpha 
-                        obj.alpha = ry - np.arctan2(-z, obj.x) - 0.5 * np.pi
-
+                        obj.alpha = theta2alpha_3d(ry, obj.x, z, p2)
+                
             if lidar is not None:
                 lidar[:, :, 0] = -lidar[:, :, 0]
         
         return left_image, right_image, p2, p3, labels, image_gt, lidar
 
+@AUGMENTATION_DICT.register_module
+class RandomWarpAffine(object):
+    """
+        Randomly random scale and random shift the image. Then resize to a fixed output size. 
+    """
+    def __init__(self, scale_lower=0.6, scale_upper=1.4, shift_border=128, output_w=1280, output_h=384):
+        self.scale_lower    = scale_lower
+        self.scale_upper    = scale_upper
+        self.shift_border   = shift_border
+        self.output_w       = output_w
+        self.output_h       = output_h
+
+    def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None, image_gt=None, lidar=None):
+        s_original = max(left_image.shape[0], left_image.shape[1])
+        center_original = np.array([left_image.shape[1] / 2., left_image.shape[0] / 2.], dtype=np.float32)
+        scale = s_original * np.random.uniform(self.scale_lower, self.scale_upper)
+        center_w = np.random.randint(low=self.shift_border, high=left_image.shape[1] - self.shift_border)
+        center_h = np.random.randint(low=self.shift_border, high=left_image.shape[0] - self.shift_border)
+
+        final_scale = max(self.output_w, self.output_h) / scale
+        final_shift_w = self.output_w / 2 - center_w * final_scale
+        final_shift_h = self.output_h / 2 - center_h * final_scale
+        affine_transform = np.array(
+            [
+                [final_scale, 0, final_shift_w],
+                [0, final_scale, final_shift_h]
+            ], dtype=np.float32
+        )
+
+        left_image = cv2.warpAffine(left_image, affine_transform,
+                                    (self.output_w, self.output_h), flags=cv2.INTER_LINEAR)
+        if right_image is not None:
+            right_image = cv2.warpAffine(right_image, affine_transform,
+                                    (self.output_w, self.output_h), flags=cv2.INTER_LINEAR)
+
+        if image_gt is not None:
+            image_gt = cv2.warpAffine(image_gt, affine_transform,
+                                    (self.output_w, self.output_h), flags=cv2.INTER_LINEAR)
+
+        if p2 is not None:
+            p2[0:2, :] *= final_scale
+            p2[0, 2] = p2[0, 2] + final_shift_w               # cy' = cy - dv
+            p2[0, 3] = p2[0, 3] + final_shift_w * p2[2, 3] # ty' = ty - dv * tz
+            p2[1, 2] = p2[1, 2] + final_shift_h               # cy' = cy - dv
+            p2[1, 3] = p2[1, 3] + final_shift_h * p2[2, 3] # ty' = ty - dv * tz
+
+        if p3 is not None:
+            p3[0:2, :] *= final_scale
+            p3[0, 2] = p3[0, 2] + final_shift_w               # cy' = cy - dv
+            p3[0, 3] = p3[0, 3] + final_shift_w * p3[2, 3] # ty' = ty - dv * tz
+            p3[1, 2] = p3[1, 2] + final_shift_h               # cy' = cy - dv
+            p3[1, 3] = p3[1, 3] + final_shift_h * p3[2, 3] # ty' = ty - dv * tz
+        
+        if labels:
+            if isinstance(labels, list):
+                for obj in labels:
+                    obj.bbox_l = obj.bbox_l * final_scale + final_shift_w
+                    obj.bbox_r = obj.bbox_r * final_scale + final_shift_w
+                    obj.bbox_t = obj.bbox_t * final_scale + final_shift_h
+                    obj.bbox_b = obj.bbox_b * final_scale + final_shift_h
+
+        return left_image, right_image, p2, p3, labels, image_gt, lidar
 
 @AUGMENTATION_DICT.register_module
 class RandomHue(object):
@@ -508,6 +597,35 @@ def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None,
                 right_image += delta
         return left_image, right_image, p2, p3, labels, image_gt, lidar
 
+@AUGMENTATION_DICT.register_module
+class RandomEigenvalueNoise(object):
+    """
+        Randomly apply noise in RGB color channels based on the eigenvalue and eigenvector of ImageNet
+    """
+    def __init__(self, distort_prob=1.0,
+                       alphastd=0.1,
+                       eigen_value=np.array([0.2141788, 0.01817699, 0.00341571], dtype=np.float32),
+                       eigen_vector=np.array([
+                            [-0.58752847, -0.69563484, 0.41340352],
+                            [-0.5832747, 0.00994535, -0.81221408],
+                            [-0.56089297, 0.71832671, 0.41158938]
+                        ], dtype=np.float32)
+                ):
+        self.distort_prob = distort_prob
+        self._eig_val = eigen_value
+        self._eig_vec = eigen_vector
+        self.alphastd = alphastd
+
+    def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None, image_gt=None, lidar=None):
+        if random.rand() <= self.distort_prob:
+            alpha = np.random.normal(scale=self.alphastd, size=(3, ))
+            noise = np.dot(self._eig_vec, self._eig_val * alpha) * 255
+
+            left_image += noise
+            if right_image is not None:
+                right_image += noise
+            
+        return left_image, right_image, p2, p3, labels, image_gt, lidar
 
 @AUGMENTATION_DICT.register_module
 class PhotometricDistort(object):
@@ -545,7 +663,7 @@ def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None,
         distortion.insert(0, self.rand_brightness)
 
         # compose transformation
-        distortion = Compose(distortion)
+        distortion = Compose.from_transforms(distortion)
 
         return distortion(left_image.copy(), right_image if right_image is None else right_image.copy(), p2, p3, labels, image_gt, lidar)
 
@@ -565,7 +683,7 @@ def __init__(self, cfg):
         self.distort_prob = cfg.distortProb
 
         if cfg.distortProb <= 0:
-            self.augment = Compose([
+            self.augment = Compose.from_transforms([
                 ConvertToFloat(),
                 CropTop(cfg.crop_top),
                 Resize(self.size),
@@ -573,7 +691,7 @@ def __init__(self, cfg):
                 Normalize(self.mean, self.stds)
             ])
         else:
-            self.augment = Compose([
+            self.augment = Compose.from_transforms([
                 ConvertToFloat(),
                 PhotometricDistort(self.distort_prob),
                 CropTop(cfg.crop_top),
@@ -598,7 +716,7 @@ def __init__(self, cfg):
         self.stds = cfg.rgb_std
         self.size = cfg.cropSize
 
-        self.preprocess = Compose([
+        self.preprocess = Compose.from_transforms([
             ConvertToFloat(),
             CropTop(cfg.crop_top),
             Resize(self.size),
@@ -612,3 +730,25 @@ def __call__(self, left_image, right_image, p2=None, p3=None, labels=None, image
         #img = np.transpose(img, [2, 0, 1])
 
         return left_image, right_image, p2, p3, labels, image_gt, lidar
+
+@AUGMENTATION_DICT.register_module
+class Shuffle(object):
+    """
+        Initialize a sequence of transformations. During function call, it will randomly shuffle the augmentation calls.
+
+        Can be used with Compose to build complex augmentation structures.
+    """
+    def __init__(self, aug_list:List[EasyDict]):
+        self.transforms = [
+            build_single_augmentator(aug_cfg) for aug_cfg in aug_list
+        ]
+
+    def __call__(self, left_image, right_image=None, p2=None, p3=None, labels=None, image_gt=None, lidar=None):
+        # We aim to keep the original order of the initialized transforms in self.transforms, so we only randomize the indexes.
+        shuffled_indexes = np.random.permutation(len(self.transforms))
+
+        for index in shuffled_indexes:
+            left_image, right_image, p2, p3, labels, image_gt, lidar = self.transforms[index](left_image, right_image, p2, p3, labels, image_gt, lidar)
+        
+        return left_image, right_image, p2, p3, labels, image_gt, lidar
+
diff --git a/visualDet3D/networks/backbones/__init__.py b/visualDet3D/networks/backbones/__init__.py
index 22079cb..0a05bd1 100644
--- a/visualDet3D/networks/backbones/__init__.py
+++ b/visualDet3D/networks/backbones/__init__.py
@@ -1 +1,13 @@
-from .resnet import resnet101, resnet152, resnet18, resnet34, resnet50, ResNet, resnet
\ No newline at end of file
+from .resnet import resnet101, resnet152, resnet18, resnet34, resnet50, ResNet, resnet
+from .dla import dlanet
+from visualDet3D.networks.utils.registry import BACKBONE_DICT
+
+def build_backbone(cfg):
+    temp_cfg = cfg.copy()
+    name = ""
+    if 'name' in temp_cfg:
+        name = temp_cfg.pop('name')
+    else:
+        name = 'resnet'
+
+    return BACKBONE_DICT[name](**temp_cfg)
diff --git a/visualDet3D/networks/backbones/dla.py b/visualDet3D/networks/backbones/dla.py
new file mode 100644
index 0000000..60038c9
--- /dev/null
+++ b/visualDet3D/networks/backbones/dla.py
@@ -0,0 +1,441 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import math
+from os.path import join
+
+import torch
+from torch import nn
+import torch.utils.model_zoo as model_zoo
+from typing import Tuple
+from visualDet3D.networks.utils.registry import BACKBONE_DICT
+
+BatchNorm = nn.BatchNorm2d
+
+WEB_ROOT = 'http://dl.yf.io/dla/models'
+
+
+model_hash={'dla34': 'ba72cf86',
+            'dla46_c': '2bfd52c3',
+            'dla46x_c': 'd761bae7',
+            'dla60x_c': 'b870c45c',
+            'dla60': '24839fc4',
+            'dla60x': 'd15cacda',
+            'dla102': 'd94d9790',
+            'dla102x': 'ad62be81',
+            'dla102x2': '262837b6',
+            'dla169': '0914e092'}
+
+def get_model_url(name):
+    return join(WEB_ROOT, 'imagenet',
+                '{}-{}.pth'.format(name, model_hash[name]))
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    "3x3 convolution with padding"
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    def __init__(self, inplanes, planes, stride=1, dilation=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3,
+                               stride=stride, padding=dilation,
+                               bias=False, dilation=dilation)
+        self.bn1 = BatchNorm(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
+                               stride=1, padding=dilation,
+                               bias=False, dilation=dilation)
+        self.bn2 = BatchNorm(planes)
+        self.stride = stride
+
+    def forward(self, x, residual=None):
+        if residual is None:
+            residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 2
+
+    def __init__(self, inplanes, planes, stride=1, dilation=1):
+        super(Bottleneck, self).__init__()
+        expansion = Bottleneck.expansion
+        bottle_planes = planes // expansion
+        self.conv1 = nn.Conv2d(inplanes, bottle_planes,
+                               kernel_size=1, bias=False)
+        self.bn1 = BatchNorm(bottle_planes)
+        self.conv2 = nn.Conv2d(bottle_planes, bottle_planes, kernel_size=3,
+                               stride=stride, padding=dilation,
+                               bias=False, dilation=dilation)
+        self.bn2 = BatchNorm(bottle_planes)
+        self.conv3 = nn.Conv2d(bottle_planes, planes,
+                               kernel_size=1, bias=False)
+        self.bn3 = BatchNorm(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.stride = stride
+
+    def forward(self, x, residual=None):
+        if residual is None:
+            residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class BottleneckX(nn.Module):
+    expansion = 2
+    cardinality = 32
+
+    def __init__(self, inplanes, planes, stride=1, dilation=1):
+        super(BottleneckX, self).__init__()
+        cardinality = BottleneckX.cardinality
+        # dim = int(math.floor(planes * (BottleneckV5.expansion / 64.0)))
+        # bottle_planes = dim * cardinality
+        bottle_planes = planes * cardinality // 32
+        self.conv1 = nn.Conv2d(inplanes, bottle_planes,
+                               kernel_size=1, bias=False)
+        self.bn1 = BatchNorm(bottle_planes)
+        self.conv2 = nn.Conv2d(bottle_planes, bottle_planes, kernel_size=3,
+                               stride=stride, padding=dilation, bias=False,
+                               dilation=dilation, groups=cardinality)
+        self.bn2 = BatchNorm(bottle_planes)
+        self.conv3 = nn.Conv2d(bottle_planes, planes,
+                               kernel_size=1, bias=False)
+        self.bn3 = BatchNorm(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.stride = stride
+
+    def forward(self, x, residual=None):
+        if residual is None:
+            residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Root(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size, residual):
+        super(Root, self).__init__()
+        self.conv = nn.Conv2d(
+            in_channels, out_channels, kernel_size,
+            stride=1, bias=False, padding=(kernel_size - 1) // 2)
+        self.bn = BatchNorm(out_channels)
+        self.relu = nn.ReLU(inplace=True)
+        self.residual = residual
+
+    def forward(self, *x):
+        children = x
+        x = self.conv(torch.cat(x, 1))
+        x = self.bn(x)
+        if self.residual:
+            x += children[0]
+        x = self.relu(x)
+
+        return x
+
+
+class Tree(nn.Module):
+    def __init__(self, levels, block, in_channels, out_channels, stride=1,
+                 level_root=False, root_dim=0, root_kernel_size=1,
+                 dilation=1, root_residual=False):
+        super(Tree, self).__init__()
+        if root_dim == 0:
+            root_dim = 2 * out_channels
+        if level_root:
+            root_dim += in_channels
+        if levels == 1:
+            self.tree1 = block(in_channels, out_channels, stride,
+                               dilation=dilation)
+            self.tree2 = block(out_channels, out_channels, 1,
+                               dilation=dilation)
+        else:
+            self.tree1 = Tree(levels - 1, block, in_channels, out_channels,
+                              stride, root_dim=0,
+                              root_kernel_size=root_kernel_size,
+                              dilation=dilation, root_residual=root_residual)
+            self.tree2 = Tree(levels - 1, block, out_channels, out_channels,
+                              root_dim=root_dim + out_channels,
+                              root_kernel_size=root_kernel_size,
+                              dilation=dilation, root_residual=root_residual)
+        if levels == 1:
+            self.root = Root(root_dim, out_channels, root_kernel_size,
+                             root_residual)
+        self.level_root = level_root
+        self.root_dim = root_dim
+        self.downsample = None
+        self.project = None
+        self.levels = levels
+        if stride > 1:
+            self.downsample = nn.MaxPool2d(stride, stride=stride)
+        if in_channels != out_channels:
+            self.project = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels,
+                          kernel_size=1, stride=1, bias=False),
+                BatchNorm(out_channels)
+            )
+
+    def forward(self, x, residual=None, children=None):
+        children = [] if children is None else children
+        bottom = self.downsample(x) if self.downsample else x
+        residual = self.project(bottom) if self.project else bottom
+        if self.level_root:
+            children.append(bottom)
+        x1 = self.tree1(x, residual)
+        if self.levels == 1:
+            x2 = self.tree2(x1)
+            x = self.root(x2, x1, *children)
+        else:
+            children.append(x1)
+            x = self.tree2(x1, children=children)
+        return x
+
+
+class DLA(nn.Module):
+    """
+        For DLA the downscale ratio:
+
+        -1: 1
+        0 : 1
+        1 : 2
+        2 : 4
+        3 : 8
+        4 : 16
+        5 : 32
+
+        DLA34: 
+        torch.Size([1, 16, 224, 224])
+        torch.Size([1, 16, 224, 224])
+        torch.Size([1, 32, 112, 112])
+        torch.Size([1, 64, 56, 56])
+        torch.Size([1, 128, 28, 28])
+        torch.Size([1, 256, 14, 14])
+        torch.Size([1, 512, 7, 7])
+    """
+    def __init__(self, levels, channels, num_classes=1000,
+                 block=BasicBlock, residual_root=False, out_indices:Tuple[int, ...]=(-1, 0, 1, 2, 3, 4, 5)
+                 ):
+        super(DLA, self).__init__()
+        self.channels = channels
+        self.out_indices = out_indices
+        self.num_classes = num_classes
+        self.base_layer = nn.Sequential(
+            nn.Conv2d(3, channels[0], kernel_size=7, stride=1,
+                      padding=3, bias=False),
+            BatchNorm(channels[0]),
+            nn.ReLU(inplace=True))
+        self.level0 = self._make_conv_level(
+            channels[0], channels[0], levels[0])
+        self.level1 = self._make_conv_level(
+            channels[0], channels[1], levels[1], stride=2)
+        self.level2 = Tree(levels[2], block, channels[1], channels[2], 2,
+                           level_root=False,
+                           root_residual=residual_root)
+        self.level3 = Tree(levels[3], block, channels[2], channels[3], 2,
+                           level_root=True, root_residual=residual_root)
+        self.level4 = Tree(levels[4], block, channels[3], channels[4], 2,
+                           level_root=True, root_residual=residual_root)
+        self.level5 = Tree(levels[5], block, channels[4], channels[5], 2,
+                           level_root=True, root_residual=residual_root)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+            elif isinstance(m, BatchNorm):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_level(self, block, inplanes, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or inplanes != planes:
+            downsample = nn.Sequential(
+                nn.MaxPool2d(stride, stride=stride),
+                nn.Conv2d(inplanes, planes,
+                          kernel_size=1, stride=1, bias=False),
+                BatchNorm(planes),
+            )
+
+        layers = []
+        layers.append(block(inplanes, planes, stride, downsample=downsample))
+        for i in range(1, blocks):
+            layers.append(block(inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def _make_conv_level(self, inplanes, planes, convs, stride=1, dilation=1):
+        modules = []
+        for i in range(convs):
+            modules.extend([
+                nn.Conv2d(inplanes, planes, kernel_size=3,
+                          stride=stride if i == 0 else 1,
+                          padding=dilation, bias=False, dilation=dilation),
+                BatchNorm(planes),
+                nn.ReLU(inplace=True)])
+            inplanes = planes
+        return nn.Sequential(*modules)
+
+    def forward(self, x):
+        y = []
+        x = self.base_layer(x)
+        if -1 in self.out_indices:
+            y.append(x)
+        for i in range(6):
+            x = getattr(self, 'level{}'.format(i))(x)
+            if i in self.out_indices:
+                y.append(x)
+        return y
+
+    def load_pretrained_model(self, data_name, name):
+        model_url = get_model_url(name)
+        print(model_url)
+        self.load_state_dict(model_zoo.load_url(model_url), strict=False)
+
+
+def dla34(pretrained=True, **kwargs):  # DLA-34
+    model = DLA([1, 1, 1, 2, 2, 1],
+                [16, 32, 64, 128, 256, 512],
+                block=BasicBlock, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla34')
+    return model
+
+
+def dla46_c(pretrained=True, **kwargs):  # DLA-46-C
+    Bottleneck.expansion = 2
+    model = DLA([1, 1, 1, 2, 2, 1],
+                [16, 32, 64, 64, 128, 256],
+                block=Bottleneck, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla46_c')
+    return model
+
+
+def dla46x_c(pretrained=True, **kwargs):  # DLA-X-46-C
+    BottleneckX.expansion = 2
+    model = DLA([1, 1, 1, 2, 2, 1],
+                [16, 32, 64, 64, 128, 256],
+                block=BottleneckX, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla46x_c')
+    return model
+
+
+def dla60x_c(pretrained=True, **kwargs):  # DLA-X-60-C
+    BottleneckX.expansion = 2
+    model = DLA([1, 1, 1, 2, 3, 1],
+                [16, 32, 64, 64, 128, 256],
+                block=BottleneckX, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla60x_c')
+    return model
+
+
+def dla60(pretrained=True, **kwargs):  # DLA-60
+    Bottleneck.expansion = 2
+    model = DLA([1, 1, 1, 2, 3, 1],
+                [16, 32, 128, 256, 512, 1024],
+                block=Bottleneck, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla60')
+    return model
+
+
+def dla60x(pretrained=True, **kwargs):  # DLA-X-60
+    BottleneckX.expansion = 2
+    model = DLA([1, 1, 1, 2, 3, 1],
+                [16, 32, 128, 256, 512, 1024],
+                block=BottleneckX, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla60x')
+    return model
+
+
+def dla102(pretrained=True, **kwargs):  # DLA-102
+    Bottleneck.expansion = 2
+    model = DLA([1, 1, 1, 3, 4, 1], [16, 32, 128, 256, 512, 1024],
+                block=Bottleneck, residual_root=True, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla102')
+    return model
+
+
+def dla102x(pretrained=True, **kwargs):  # DLA-X-102
+    BottleneckX.expansion = 2
+    model = DLA([1, 1, 1, 3, 4, 1], [16, 32, 128, 256, 512, 1024],
+                block=BottleneckX, residual_root=True, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla102x')
+    return model
+
+
+def dla102x2(pretrained=True, **kwargs):  # DLA-X-102 64
+    BottleneckX.cardinality = 64
+    model = DLA([1, 1, 1, 3, 4, 1], [16, 32, 128, 256, 512, 1024],
+                block=BottleneckX, residual_root=True, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla102x2')
+    return model
+
+
+def dla169(pretrained=True, **kwargs):  # DLA-169
+    Bottleneck.expansion = 2
+    model = DLA([1, 1, 2, 3, 5, 1], [16, 32, 128, 256, 512, 1024],
+                block=Bottleneck, residual_root=True, **kwargs)
+    if pretrained is not None:
+        model.load_pretrained_model(pretrained, 'dla169')
+    return model
+
+@BACKBONE_DICT.register_module
+def dlanet(depth, **kwargs):
+    if depth == 34:
+        model = dla34(**kwargs)
+    elif depth == 60:
+        model = dla60(**kwargs)
+    elif depth == 102:
+        model = dla102(**kwargs)
+    elif depth == 169:
+        model = dla169(**kwargs)
+    else:
+        raise ValueError(
+            'Unsupported model depth, must be one of 34, 60, 102, 169')
+    return model
\ No newline at end of file
diff --git a/visualDet3D/networks/detectors/KM3D.py b/visualDet3D/networks/detectors/KM3D.py
new file mode 100644
index 0000000..ab226d7
--- /dev/null
+++ b/visualDet3D/networks/detectors/KM3D.py
@@ -0,0 +1,88 @@
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import torch
+import math
+import time
+from torchvision.ops import nms
+from visualDet3D.networks.utils import DETECTOR_DICT
+from visualDet3D.networks.detectors.KM3D_core import KM3DCore
+from visualDet3D.networks.heads.km3d_head import KM3DHead
+from visualDet3D.networks.lib.blocks import AnchorFlatten
+from visualDet3D.networks.lib.look_ground import LookGround
+from visualDet3D.networks.lib.ops.dcn.deform_conv import DeformConv
+
+@DETECTOR_DICT.register_module
+class KM3D(nn.Module):
+    """
+        KM3D
+    """
+    def __init__(self, network_cfg):
+        super(KM3D, self).__init__()
+
+        self.obj_types = network_cfg.obj_types
+
+        self.build_head(network_cfg)
+
+        self.build_core(network_cfg)
+
+        self.network_cfg = network_cfg
+
+
+    def build_core(self, network_cfg):
+        self.core = KM3DCore(network_cfg.backbone)
+
+    def build_head(self, network_cfg):
+        self.bbox_head = KM3DHead(
+            **(network_cfg.head)
+        )
+
+    def training_forward(self, img_batch, annotations, meta):
+        """
+        Args:
+            img_batch: [B, C, H, W] tensor
+            annotations: check visualDet3D.utils.utils compound_annotation
+            meta:
+                calib: visualDet3D.kitti.data.kitti.KittiCalib or anything with obj.P2
+                epoch: current_epoch
+        Returns:
+            cls_loss, reg_loss: tensor of losses
+            loss_dict: [key, value] pair for logging
+        """
+
+        features  = self.core(dict(image=img_batch, P2=meta['P2']))
+        output_dict = self.bbox_head(features)
+
+        loss, loss_dict = self.bbox_head.loss(output_dict, annotations, meta)
+
+        return loss, loss_dict
+    
+    def test_forward(self, img_batch, P2):
+        """
+        Args:
+            img_batch: [B, C, H, W] tensor
+            calib: visualDet3D.kitti.data.kitti.KittiCalib or anything with obj.P2
+        Returns:
+            results: a nested list:
+                result[i] = detection_results for obj_types[i]
+                    each detection result is a list [scores, bbox, obj_type]:
+                        bbox = [bbox2d(length=4) , cx, cy, z, w, h, l, alpha]
+        """
+        assert img_batch.shape[0] == 1 # we recommmend image batch size = 1 for testing
+
+        features  = self.core(dict(image=img_batch, P2=P2))
+        output_dict = self.bbox_head(features)
+
+        scores, bboxes, cls_indexes = self.bbox_head.get_bboxes(output_dict, P2, img_batch)
+
+        return scores, bboxes, cls_indexes
+
+    def forward(self, inputs):
+
+        if isinstance(inputs, list) and len(inputs) == 3:
+            img_batch, annotations, meta = inputs
+            return self.training_forward(img_batch, annotations, meta)
+        else:
+            img_batch, calib = inputs
+            return self.test_forward(img_batch, calib)
+
diff --git a/visualDet3D/networks/detectors/KM3D_core.py b/visualDet3D/networks/detectors/KM3D_core.py
new file mode 100644
index 0000000..a8e2d8c
--- /dev/null
+++ b/visualDet3D/networks/detectors/KM3D_core.py
@@ -0,0 +1,34 @@
+import numpy as np
+import torch.nn as nn
+import torch
+import math
+import time
+from visualDet3D.networks.backbones import build_backbone
+
+class KM3DCore(nn.Module):
+    """Some Information about RTM3D_core"""
+    def __init__(self, backbone_arguments=dict()):
+        super(KM3DCore, self).__init__()
+        self.backbone = build_backbone(backbone_arguments)
+        output_features = 2048 if backbone_arguments['depth'] > 34 else 512
+        feature_size = 256
+
+        self.deconv_layers = nn.Sequential(
+            nn.ConvTranspose2d(output_features, feature_size, (4, 4), stride=(2, 2), padding=(1, 1), bias=False),
+            nn.BatchNorm2d(feature_size),
+            nn.ReLU(inplace=True),
+            nn.ConvTranspose2d(feature_size, feature_size, (4, 4), stride=(2, 2), padding=(1, 1), bias=False),
+            nn.BatchNorm2d(feature_size),
+            nn.ReLU(inplace=True),
+            nn.ConvTranspose2d(feature_size, feature_size, (4, 4), stride=(2, 2), padding=(1, 1), bias=False),
+            nn.BatchNorm2d(feature_size),
+            nn.ReLU(inplace=True),
+        )
+        for _, m in self.deconv_layers.named_modules():
+            if isinstance(m, nn.ConvTranspose2d):
+                nn.init.normal_(m.weight, std=0.001)
+                
+    def forward(self, x):
+        x = self.backbone(x['image'])
+        x = self.deconv_layers(x[0])
+        return x
diff --git a/visualDet3D/networks/detectors/__init__.py b/visualDet3D/networks/detectors/__init__.py
index 5566321..10d56c2 100644
--- a/visualDet3D/networks/detectors/__init__.py
+++ b/visualDet3D/networks/detectors/__init__.py
@@ -1,3 +1,5 @@
 from .retinanet_2d import RetinaNet
 from .yolomono3d_detector import Yolo3D, GroundAwareYolo3D
-from .unet_monodepth import MonoDepth
\ No newline at end of file
+from .unet_monodepth import MonoDepth
+from .yolostereo3d_detector import YoloStereo3DCore
+from .KM3D import KM3D
\ No newline at end of file
diff --git a/visualDet3D/networks/detectors/yolostereo3d_core.py b/visualDet3D/networks/detectors/yolostereo3d_core.py
new file mode 100644
index 0000000..b3b9817
--- /dev/null
+++ b/visualDet3D/networks/detectors/yolostereo3d_core.py
@@ -0,0 +1,126 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import time
+from visualDet3D.networks.lib.blocks import AnchorFlatten, ConvBnReLU
+from visualDet3D.networks.lib.ghost_module import ResGhostModule, GhostModule
+from visualDet3D.networks.lib.PSM_cost_volume import PSMCosineModule, CostVolume
+from visualDet3D.networks.backbones import resnet
+from visualDet3D.networks.backbones.resnet import BasicBlock
+from visualDet3D.networks.lib.look_ground import LookGround
+
+class CostVolumePyramid(nn.Module):
+    """Some Information about CostVolumePyramid"""
+    def __init__(self, depth_channel_4, depth_channel_8, depth_channel_16):
+        super(CostVolumePyramid, self).__init__()
+        self.depth_channel_4  = depth_channel_4 # 24
+        self.depth_channel_8  = depth_channel_8 # 24
+        self.depth_channel_16 = depth_channel_16 # 96
+
+        input_features = depth_channel_4 # 24
+        self.four_to_eight = nn.Sequential(
+            ResGhostModule(input_features, 3 * input_features, 3, ratio=3),
+            nn.AvgPool2d(2),
+            #nn.Conv2d(3 * input_features, 3 * input_features, 3, padding=1, bias=False),
+            #nn.BatchNorm2d(3 * input_features),
+            #nn.ReLU(),
+            BasicBlock(3 * input_features, 3 * input_features),
+        )
+        input_features = 3 * input_features + depth_channel_8 # 3 * 24 + 24 = 96
+        self.eight_to_sixteen = nn.Sequential(
+            ResGhostModule(input_features, 3 * input_features, 3, ratio=3),
+            nn.AvgPool2d(2),
+            BasicBlock(3 * input_features, 3 * input_features),
+            #nn.Conv2d(3 * input_features, 3 * input_features, 3, padding=1, bias=False),
+            #nn.BatchNorm2d(3 * input_features),
+            #nn.ReLU(),
+        )
+        input_features = 3 * input_features + depth_channel_16 # 3 * 96 + 96 = 384
+        self.depth_reason = nn.Sequential(
+            ResGhostModule(input_features, 3 * input_features, kernel_size=3, ratio=3),
+            BasicBlock(3 * input_features, 3 * input_features),
+            #nn.Conv2d(3 * input_features, 3 * input_features, 3, padding=1, bias=False),
+            #nn.BatchNorm2d(3 * input_features),
+            #nn.ReLU(),
+        )
+        self.output_channel_num = 3 * input_features #1152
+
+        self.depth_output = nn.Sequential(
+            nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True),
+            nn.Conv2d(self.output_channel_num, int(self.output_channel_num/2), 3, padding=1),
+            nn.BatchNorm2d(int(self.output_channel_num/2)),
+            nn.ReLU(),
+            nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True),
+            nn.Conv2d(int(self.output_channel_num/2), int(self.output_channel_num/4), 3, padding=1),
+            nn.BatchNorm2d(int(self.output_channel_num/4)),
+            nn.ReLU(),
+            nn.Conv2d(int(self.output_channel_num/4), 96, 1),
+        )
+
+
+    def forward(self, psv_volume_4, psv_volume_8, psv_volume_16):
+        psv_4_8 = self.four_to_eight(psv_volume_4)
+        psv_volume_8 = torch.cat([psv_4_8, psv_volume_8], dim=1)
+        psv_8_16 = self.eight_to_sixteen(psv_volume_8)
+        psv_volume_16 = torch.cat([psv_8_16, psv_volume_16], dim=1)
+        psv_16 = self.depth_reason(psv_volume_16)
+        if self.training:
+            return psv_16, self.depth_output(psv_16)
+        return psv_16, torch.zeros([psv_volume_4.shape[0], 1, psv_volume_4.shape[2], psv_volume_4.shape[3]])
+
+class StereoMerging(nn.Module):
+    def __init__(self, base_features):
+        super(StereoMerging, self).__init__()
+        self.cost_volume_0 = PSMCosineModule(downsample_scale=4, max_disp=96, input_features=base_features)
+        PSV_depth_0 = self.cost_volume_0.depth_channel
+
+        self.cost_volume_1 = PSMCosineModule(downsample_scale=8, max_disp=192, input_features=base_features * 2)
+        PSV_depth_1 = self.cost_volume_1.depth_channel
+
+        self.cost_volume_2 = CostVolume(downsample_scale=16, max_disp=192, input_features=base_features * 4, PSM_features=8)
+        PSV_depth_2 = self.cost_volume_2.output_channel
+
+        self.depth_reasoning = CostVolumePyramid(PSV_depth_0, PSV_depth_1, PSV_depth_2)
+        self.final_channel = self.depth_reasoning.output_channel_num + base_features * 4
+
+    def forward(self, left_x, right_x):
+        PSVolume_0 = self.cost_volume_0(left_x[0], right_x[0])
+        PSVolume_1 = self.cost_volume_1(left_x[1], right_x[1])
+        PSVolume_2 = self.cost_volume_2(left_x[2], right_x[2])
+        PSV_features, depth_output = self.depth_reasoning(PSVolume_0, PSVolume_1, PSVolume_2) # c = 1152
+        features = torch.cat([left_x[2], PSV_features], dim=1) # c = 1152 + 256 = 1408
+        return features, depth_output
+
+class YoloStereo3DCore(nn.Module):
+    """
+        Inference Structure of YoloStereo3D
+        Similar to YoloMono3D,
+        Left and Right image are fed into the backbone in batch. So they will affect each other with BatchNorm2d.
+    """
+    def __init__(self, backbone_arguments):
+        super(YoloStereo3DCore, self).__init__()
+        self.backbone =resnet(**backbone_arguments)
+
+        base_features = 256 if backbone_arguments['depth'] > 34 else 64
+        self.neck = StereoMerging(base_features)
+
+
+    def forward(self, images):
+
+        batch_size = images.shape[0]
+        left_images = images[:, 0:3, :, :]
+        right_images = images[:, 3:, :, :]
+
+        images = torch.cat([left_images, right_images], dim=0)
+
+        features = self.backbone(images)
+
+        left_features  = [feature[0:batch_size] for feature in features]
+        right_features = [feature[batch_size:]  for feature in features]
+
+        features, depth_output = self.neck(left_features, right_features)
+
+        output_dict = dict(features=features, depth_output=depth_output)
+        return output_dict
diff --git a/visualDet3D/networks/detectors/yolostereo3d_detector.py b/visualDet3D/networks/detectors/yolostereo3d_detector.py
new file mode 100644
index 0000000..b132167
--- /dev/null
+++ b/visualDet3D/networks/detectors/yolostereo3d_detector.py
@@ -0,0 +1,103 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision.ops import nms
+from visualDet3D.networks.utils.registry import DETECTOR_DICT
+from visualDet3D.utils.timer import profile
+from visualDet3D.networks.heads import losses
+from visualDet3D.networks.detectors.yolostereo3d_core import YoloStereo3DCore
+from visualDet3D.networks.heads.detection_3d_head import StereoHead
+from visualDet3D.networks.lib.blocks import AnchorFlatten, ConvBnReLU
+from visualDet3D.networks.backbones.resnet import BasicBlock
+
+
+
+@DETECTOR_DICT.register_module
+class Stereo3D(nn.Module):
+    """
+        Stereo3D
+    """
+    def __init__(self, network_cfg):
+        super(Stereo3D, self).__init__()
+
+        self.obj_types = network_cfg.obj_types
+
+        self.build_head(network_cfg)
+
+        self.build_core(network_cfg)
+
+        self.network_cfg = network_cfg
+
+    def build_core(self, network_cfg):
+        self.core = YoloStereo3DCore(network_cfg.backbone)
+
+    def build_head(self, network_cfg):
+        self.bbox_head = StereoHead(
+            **(network_cfg.head)
+        )
+
+        self.disparity_loss = losses.DisparityLoss(maxdisp=96)
+
+    def train_forward(self, left_images, right_images, annotations, P2, P3, disparity=None):
+        """
+        Args:
+            img_batch: [B, C, H, W] tensor
+            annotations: check visualDet3D.utils.utils compound_annotation
+            calib: visualDet3D.kitti.data.kitti.KittiCalib or anything with obj.P2
+        Returns:
+            cls_loss, reg_loss: tensor of losses
+            loss_dict: [key, value] pair for logging
+        """
+        output_dict = self.core(torch.cat([left_images, right_images], dim=1))
+        depth_output   = output_dict['depth_output']
+
+        cls_preds, reg_preds = self.bbox_head(
+                dict(
+                    features=output_dict['features'],
+                    P2=P2,
+                    image=left_images
+                )
+            )
+
+        anchors = self.bbox_head.get_anchor(left_images, P2)
+
+        cls_loss, reg_loss, loss_dict = self.bbox_head.loss(cls_preds, reg_preds, anchors, annotations, P2)
+
+        if reg_loss.mean() > 0 and not disparity is None and not depth_output is None:
+            disp_loss = 1.0 * self.disparity_loss(depth_output, disparity)
+            loss_dict['disparity_loss'] = disp_loss
+            reg_loss += disp_loss
+
+            self.depth_output = depth_output.detach()
+        else:
+            loss_dict['disparity_loss'] = torch.zeros_like(reg_loss)
+        return cls_loss, reg_loss, loss_dict
+
+    def test_forward(self, left_images, right_images, P2, P3):
+        assert left_images.shape[0] == 1 # we recommmend image batch size = 1 for testing
+
+        output_dict = self.core(torch.cat([left_images, right_images], dim=1))
+        depth_output   = output_dict['depth_output']
+
+        cls_preds, reg_preds = self.bbox_head(
+                dict(
+                    features=output_dict['features'],
+                    P2=P2,
+                    image=left_images
+                )
+            )
+
+        anchors = self.bbox_head.get_anchor(left_images, P2)
+
+        scores, bboxes, cls_indexes = self.bbox_head.get_bboxes(cls_preds, reg_preds, anchors, P2, left_images)
+        
+        return scores, bboxes, cls_indexes
+
+
+    def forward(self, inputs):
+
+        if isinstance(inputs, list) and len(inputs) >= 5:
+            return self.train_forward(*inputs)
+        else:
+            return self.test_forward(*inputs)
diff --git a/visualDet3D/networks/heads/detection_3d_head.py b/visualDet3D/networks/heads/detection_3d_head.py
index a184fef..8e66da5 100644
--- a/visualDet3D/networks/heads/detection_3d_head.py
+++ b/visualDet3D/networks/heads/detection_3d_head.py
@@ -13,7 +13,8 @@
 from visualDet3D.networks.utils.utils import calc_iou, BackProjection, BBox3dProjector
 from visualDet3D.networks.lib.fast_utils.hill_climbing import post_opt
 from visualDet3D.networks.utils.utils import ClipBoxes
-from visualDet3D.networks.lib.blocks import AnchorFlatten
+from visualDet3D.networks.lib.blocks import AnchorFlatten, ConvBnReLU
+from visualDet3D.networks.backbones.resnet import BasicBlock
 from visualDet3D.networks.lib.ops import ModulatedDeformConvPack
 from visualDet3D.networks.lib.look_ground import LookGround
 
@@ -387,7 +388,6 @@ def get_bboxes(self, cls_scores, reg_preds, anchors, P2s, img_batch=None):
             nms_bbox = bboxes[:, :4] + label.float().unsqueeze() * (max_coordinate)
             keep_inds = nms(nms_bbox, max_score, nms_iou_thr)
 
-
         bboxes      = bboxes[keep_inds]
         max_score   = max_score[keep_inds]
         label       = label[keep_inds]
@@ -492,3 +492,38 @@ def loss(self, cls_scores, reg_preds, anchors, annotations, P2s):
         reg_loss = weighted_regression_losses.mean(dim=0, keepdim=True)
 
         return cls_loss, reg_loss, dict(cls_loss=cls_loss, reg_loss=reg_loss, total_loss=cls_loss + reg_loss)
+
+class StereoHead(AnchorBasedDetection3DHead):
+    def init_layers(self, num_features_in,
+                          num_anchors:int,
+                          num_cls_output:int,
+                          num_reg_output:int,
+                          cls_feature_size:int=1024,
+                          reg_feature_size:int=1024,
+                          **kwargs):
+
+        self.cls_feature_extraction = nn.Sequential(
+            nn.Conv2d(num_features_in, cls_feature_size, kernel_size=3, padding=1),
+            nn.Dropout2d(0.3),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(cls_feature_size, cls_feature_size, kernel_size=3, padding=1),
+            nn.Dropout2d(0.3),
+            nn.ReLU(inplace=True),
+
+            nn.Conv2d(cls_feature_size, num_anchors*(num_cls_output), kernel_size=3, padding=1),
+            AnchorFlatten(num_cls_output)
+        )
+        self.cls_feature_extraction[-2].weight.data.fill_(0)
+        self.cls_feature_extraction[-2].bias.data.fill_(0)
+
+        self.reg_feature_extraction = nn.Sequential(
+
+            ConvBnReLU(num_features_in, reg_feature_size, (3, 3)),
+            BasicBlock(reg_feature_size, reg_feature_size),
+            nn.ReLU(),
+            nn.Conv2d(reg_feature_size, num_anchors*num_reg_output, kernel_size=3, padding=1),
+            AnchorFlatten(num_reg_output)
+        )
+
+        self.reg_feature_extraction[-2].weight.data.fill_(0)
+        self.reg_feature_extraction[-2].bias.data.fill_(0)
diff --git a/visualDet3D/networks/heads/km3d_head.py b/visualDet3D/networks/heads/km3d_head.py
new file mode 100644
index 0000000..afeae35
--- /dev/null
+++ b/visualDet3D/networks/heads/km3d_head.py
@@ -0,0 +1,357 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torchvision.ops import nms
+from easydict import EasyDict
+import numpy as np
+from typing import List, Tuple, Dict
+
+
+from visualDet3D.networks.heads.losses import SigmoidFocalLoss, ModifiedSmoothL1Loss
+from visualDet3D.networks.heads.anchors import Anchors
+from visualDet3D.networks.utils.utils import calc_iou, BackProjection, BBox3dProjector
+from visualDet3D.networks.lib.fast_utils.hill_climbing import post_opt
+from visualDet3D.networks.utils.utils import ClipBoxes
+from visualDet3D.networks.lib.blocks import AnchorFlatten
+from visualDet3D.networks.lib.ops import ModulatedDeformConvPack
+from visualDet3D.networks.lib.look_ground import LookGround
+from visualDet3D.networks.utils.rtm3d_utils import _transpose_and_gather_feat, compute_rot_loss, gen_position, Position_loss, _nms, _topk_channel, _topk
+from visualDet3D.utils.utils import convertRot2Alpha
+
+class KM3DHead(nn.Module):
+    """Some Information about KM3DHead"""
+    def __init__(self, num_classes:int=3,
+                       num_joints:int=9,
+                       max_objects:int=32,
+                       layer_cfg=EasyDict(),
+                       loss_cfg=EasyDict(),
+                       test_cfg=EasyDict()):
+        super(KM3DHead, self).__init__()
+        self._init_layers(**layer_cfg)
+        self.build_loss(**loss_cfg)
+        self.test_cfg = test_cfg
+        const = torch.Tensor(
+        [[-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1],
+        [-1, 0], [0, -1], [-1, 0], [0, -1]]).unsqueeze(0).unsqueeze(0)
+        self.register_buffer('const', const) # self.const
+
+        self.num_classes = num_classes
+        self.num_joints  = num_joints
+        self.max_objects = max_objects
+        self.clipper = ClipBoxes()
+
+    def build_loss(self, 
+                   gamma=2.0,
+                   output_w = 1280,
+                   rampup_length = 100,
+                   **kwargs):
+        pass #self.cls_hm_loss = SigmoidFocalLoss(gamma=gamma)
+        self.position_loss = Position_loss(output_w=output_w)
+        self.rampup_length = rampup_length
+
+    def exp_rampup(self, epoch=0):
+        if epoch < self.rampup_length:
+            epoch = np.clip(epoch, 0.0, self.rampup_length)
+            phase = 1.0 - epoch / self.rampup_length
+            return float(np.exp(-5.0 * phase * phase))
+        else:
+            return 1.0
+    
+    @staticmethod
+    def _neg_loss(pred, gt):
+        ''' Modified focal loss. Exactly the same as CornerNet.
+            Runs faster and costs a little bit more memory
+        Arguments:
+            pred (batch x c x h x w)
+            gt_regr (batch x c x h x w)
+        '''
+        pos_inds = gt.eq(1).float()
+        neg_inds = gt.lt(1).float()
+
+        neg_weights = torch.pow(1 - gt, 4)
+
+        loss = 0
+        pred_prob = torch.sigmoid(pred)
+
+        pos_loss = nn.functional.logsigmoid(pred) * torch.pow(1 - pred_prob, 2) * pos_inds
+        pos_loss = torch.where(
+            pred_prob > 0.99,
+            torch.zeros_like(pos_loss),
+            pos_loss
+        )
+        neg_loss = nn.functional.logsigmoid(- pred) * torch.pow(pred_prob, 2) * neg_weights * neg_inds
+        neg_loss = torch.where(
+            pred_prob < 0.01,
+            torch.zeros_like(neg_loss),
+            neg_loss
+        )
+
+        num_pos = pos_inds.float().sum()
+        pos_loss = pos_loss.sum()
+        neg_loss = neg_loss.sum()
+
+        if num_pos == 0:
+            loss = loss - neg_loss
+        else:
+            loss = loss - (pos_loss + neg_loss) / num_pos
+        return loss
+
+    @staticmethod
+    def _RegWeightedL1Loss(output, mask, ind, target, dep):
+        dep=dep.squeeze(2)
+        dep[dep<5]=dep[dep<5]*0.01
+        dep[dep >= 5] = torch.log10(dep[dep >=5]-4)+0.1
+        pred = _transpose_and_gather_feat(output, ind)
+        mask = mask.float()
+        # loss = F.l1_loss(pred * mask, target * mask, reduction='elementwise_mean')
+        #losss=torch.abs(pred * mask-target * mask)
+        #loss = F.l1_loss(pred * mask, target * mask, size_average=False)
+        loss=torch.abs(pred * mask-target * mask)
+        loss=torch.sum(loss,dim=2)*dep
+        loss=loss.sum()
+        loss = loss / (mask.sum() + 1e-4)
+
+        return loss
+
+    @staticmethod
+    def _RegL1Loss(output, mask, ind, target):
+        pred = _transpose_and_gather_feat(output, ind)
+        mask = mask.unsqueeze(2).expand_as(pred).float()
+        # loss = F.l1_loss(pred * mask, target * mask, reduction='elementwise_mean')
+        loss = F.l1_loss(pred * mask, target * mask, size_average=False)
+        loss = loss / (mask.sum() + 1e-4)
+        return loss
+
+    @staticmethod
+    def _RotLoss(output, mask, ind, rotbin, rotres):
+        pred = _transpose_and_gather_feat(output, ind)
+        loss = compute_rot_loss(pred, rotbin, rotres, mask)
+        return loss
+
+    def _init_layers(self, 
+                    input_features=256,
+                    head_features=64,
+                    head_dict=dict(),
+                     **kwargs):
+        # self.head_dict = head_dict 
+        self.head_layers = nn.ModuleDict()
+        for head_name, num_output in head_dict.items():
+            self.head_layers[head_name] = nn.Sequential(
+                    nn.Conv2d(input_features, head_features, 3, padding=1, bias=True),
+                    nn.ReLU(inplace=True),
+                    nn.Conv2d(head_features, num_output, 1)
+                )
+            
+            if 'hm' in head_name:
+                output_layer = self.head_layers[head_name][-1]
+                nn.init.constant_(output_layer.bias, -2.19)
+
+            else:
+                output_layer = self.head_layers[head_name][-1]
+                nn.init.normal_(output_layer.weight, std=0.001)
+                nn.init.constant_(output_layer.bias, 0)
+
+    def _decode(self, heat, wh, kps,dim,rot, prob=None,reg=None, hm_hp=None, hp_offset=None, K=100,meta=None,const=None):
+
+        batch, cat, height, width = heat.size()
+        num_joints = kps.shape[1] // 2
+        # heat = torch.sigmoid(heat)
+        # perform nms on heatmaps
+        # hm_show,_=torch.max(hm_hp,1)
+        # hm_show=hm_show.squeeze(0)
+        # hm_show=hm_show.detach().cpu().numpy().copy()
+        # plt.imshow(hm_show, 'gray')
+        # plt.show()
+
+        heat = _nms(heat)
+        scores, inds, clses, ys, xs = _topk(heat, K=K)
+
+        kps = _transpose_and_gather_feat(kps, inds)
+        kps = kps.view(batch, K, num_joints * 2)
+        kps[..., ::2] += xs.view(batch, K, 1).expand(batch, K, num_joints)
+        kps[..., 1::2] += ys.view(batch, K, 1).expand(batch, K, num_joints)
+        if reg is not None:
+            reg = _transpose_and_gather_feat(reg, inds)
+            reg = reg.view(batch, K, 2)
+            xs = xs.view(batch, K, 1) + reg[:, :, 0:1]
+            ys = ys.view(batch, K, 1) + reg[:, :, 1:2]
+        else:
+            xs = xs.view(batch, K, 1) + 0.5
+            ys = ys.view(batch, K, 1) + 0.5
+        wh = _transpose_and_gather_feat(wh, inds)
+        wh = wh.view(batch, K, 2)
+        clses = clses.view(batch, K, 1).float()
+        scores = scores.view(batch, K, 1)
+
+        bboxes = torch.cat([xs - wh[..., 0:1] / 2,
+                            ys - wh[..., 1:2] / 2,
+                            xs + wh[..., 0:1] / 2,
+                            ys + wh[..., 1:2] / 2], dim=2)
+        dim = _transpose_and_gather_feat(dim, inds)
+        dim = dim.view(batch, K, 3)
+        # dim[:, :, 0] = torch.exp(dim[:, :, 0]) * 1.63
+        # dim[:, :, 1] = torch.exp(dim[:, :, 1]) * 1.53
+        # dim[:, :, 2] = torch.exp(dim[:, :, 2]) * 3.88
+        rot = _transpose_and_gather_feat(rot, inds)
+        rot = rot.view(batch, K, 8)
+        prob = _transpose_and_gather_feat(prob, inds)[:,:,0]
+        prob = prob.view(batch, K, 1)
+        if hm_hp is not None:
+            hm_hp = _nms(hm_hp)
+            thresh = 0.1
+            kps = kps.view(batch, K, num_joints, 2).permute(
+                0, 2, 1, 3).contiguous()  # b x J x K x 2
+            reg_kps = kps.unsqueeze(3).expand(batch, num_joints, K, K, 2)
+            hm_score, hm_inds, hm_ys, hm_xs = _topk_channel(hm_hp, K=K)  # b x J x K
+            if hp_offset is not None:
+                hp_offset = _transpose_and_gather_feat(
+                    hp_offset, hm_inds.view(batch, -1))
+                hp_offset = hp_offset.view(batch, num_joints, K, 2)
+                hm_xs = hm_xs + hp_offset[:, :, :, 0]
+                hm_ys = hm_ys + hp_offset[:, :, :, 1]
+            else:
+                hm_xs = hm_xs + 0.5
+                hm_ys = hm_ys + 0.5
+            mask = (hm_score > thresh).float()
+            hm_score = (1 - mask) * -1 + mask * hm_score
+            hm_ys = (1 - mask) * (-10000) + mask * hm_ys
+            hm_xs = (1 - mask) * (-10000) + mask * hm_xs
+            hm_kps = torch.stack([hm_xs, hm_ys], dim=-1).unsqueeze(
+                2).expand(batch, num_joints, K, K, 2)
+            dist = (((reg_kps - hm_kps) ** 2).sum(dim=4) ** 0.5)
+            min_dist, min_ind = dist.min(dim=3)  # b x J x K
+            hm_score = hm_score.gather(2, min_ind).unsqueeze(-1)  # b x J x K x 1
+            min_dist = min_dist.unsqueeze(-1)
+            min_ind = min_ind.view(batch, num_joints, K, 1, 1).expand(
+                batch, num_joints, K, 1, 2)
+            hm_kps = hm_kps.gather(3, min_ind)
+            hm_kps = hm_kps.view(batch, num_joints, K, 2)
+            l = bboxes[:, :, 0].view(batch, 1, K, 1).expand(batch, num_joints, K, 1)
+            t = bboxes[:, :, 1].view(batch, 1, K, 1).expand(batch, num_joints, K, 1)
+            r = bboxes[:, :, 2].view(batch, 1, K, 1).expand(batch, num_joints, K, 1)
+            b = bboxes[:, :, 3].view(batch, 1, K, 1).expand(batch, num_joints, K, 1)
+            mask = (hm_kps[..., 0:1] < l) + (hm_kps[..., 0:1] > r) + \
+                (hm_kps[..., 1:2] < t) + (hm_kps[..., 1:2] > b) + \
+                (hm_score < thresh) + (min_dist > (torch.max(b - t, r - l) * 0.3))
+            mask = (mask > 0).float().expand(batch, num_joints, K, 2)
+            kps = (1 - mask) * hm_kps + mask * kps
+            kps = kps.permute(0, 2, 1, 3).contiguous().view(
+                batch, K, num_joints * 2)
+            hm_score=hm_score.permute(0, 2, 1, 3).squeeze(3).contiguous()
+        else:
+            hm_score = kps.new_zeros([1, K, 9])# dets[mask, 26:35]
+
+        kps *= 4 # restore back to scale 1
+        bboxes *= 4 # restore back to scale 1
+        
+        position,rot_y, alpha, kps_inv=gen_position(kps,dim,rot,meta,const)
+
+        detections = torch.cat([bboxes, scores, kps_inv, dim,hm_score,rot_y, position,prob,clses, alpha], dim=2)
+
+        return detections
+
+
+    def get_bboxes(self, output:dict, P2, img_batch=None):
+        output['hm'] = torch.sigmoid(output['hm'])
+        output['hm_hp'] = torch.sigmoid(output['hm_hp'])
+        reg = output['reg']
+        hm_hp = output['hm_hp']
+        hp_offset = output['hp_offset']
+        dets = self._decode(
+            output['hm'], output['wh'], output['hps'], output['dim'], output['rot'], prob=output['prob'], reg=reg, hm_hp=hm_hp, hp_offset=hp_offset, K=100, const=self.const, meta=dict(calib=P2)
+        )[0]
+
+        score_threshold = getattr(self.test_cfg, 'score_thr', 0.1)
+        mask = dets[:, 4] > score_threshold#[K]
+        bbox2d = dets[mask, 0:4]
+        scores = dets[mask, 4:5] #[K, 1]
+        kps_inv = dets[mask, 5:23] #[K, 18]
+        dims   = dets[mask, 23:26] #[w, h, l] ? 
+        hm_score = dets[mask, 26:35]
+        rot_y = dets[mask, 35:36]
+        position = dets[mask, 36:39]
+        prob = dets[mask, 39:40]
+        cls_indexes = dets[mask, 40:41].long()
+        alpha = dets[mask, 41:42]
+        
+        ## Project back to camera frame for final output
+        p2 = P2[0] #[3, 4]
+        fx = p2[0, 0]
+        fy = p2[1, 1]
+        cx = p2[0, 2]
+        cy = p2[1, 2]
+        tx = p2[0, 3]
+        ty = p2[1, 3]
+        z3d = position[:, 2:3] #[N, 1]
+        cx3d = (position[:, 0:1] * fx + tx + cx * z3d) / z3d
+        cy3d = (position[:, 1:2] * fy + ty + cy * z3d) / z3d
+    
+        if img_batch is not None:
+            bbox2d = self.clipper(bbox2d, img_batch)
+
+        bbox3d_3d = torch.cat(
+            [bbox2d,  cx3d, cy3d, z3d, dims, alpha], dim=1                  #cx, cy, z, w, h, l, alpha
+        )
+        
+        
+        cls_agnostic = getattr(self.test_cfg, 'cls_agnositc', True) # True -> directly NMS; False -> NMS with offsets, different categories will not collide
+        nms_iou_thr  = getattr(self.test_cfg, 'nms_iou_thr', 0.5)
+        
+
+        if cls_agnostic:
+            keep_inds = nms(bbox3d_3d[:, :4], scores[:, 0], nms_iou_thr)
+        else:
+            max_coordinate = bbox3d_3d.max()
+            nms_bbox = bbox3d_3d[:, :4] + cls_indexes.float() * (max_coordinate)
+            keep_inds = nms(nms_bbox, scores, nms_iou_thr)
+            
+        scores = scores[keep_inds, 0]
+        bbox3d_3d = bbox3d_3d[keep_inds]
+        cls_indexes = cls_indexes[keep_inds]
+        
+
+        return scores, bbox3d_3d, cls_indexes
+
+    def loss(self, output, annotations, meta):
+        P2 = meta['P2']
+        epoch = meta['epoch']
+
+        #output['hm'] = torch.sigmoid(output['hm'])
+        #output['hm_hp'] = torch.sigmoid(output['hm_hp'])
+
+        hm_loss = self._neg_loss(output['hm'], annotations['hm'])
+        hp_loss = self._RegWeightedL1Loss(output['hps'],annotations['hps_mask'], annotations['ind'], annotations['hps'],annotations['dep'])
+
+        wh_loss = self._RegL1Loss(output['wh'], annotations['reg_mask'],annotations['ind'], annotations['wh'])
+        dim_loss = self._RegL1Loss(output['dim'], annotations['reg_mask'],annotations['ind'], annotations['dim'])
+
+        rot_loss = self._RotLoss(output['rot'], annotations['reg_mask'], annotations['ind'], annotations['rotbin'], annotations['rotres'])
+        off_loss = self._RegL1Loss(output['reg'], annotations['reg_mask'], annotations['ind'], annotations['reg'])
+
+        hp_offset_loss = self._RegL1Loss(output['hp_offset'], annotations['hp_mask'], annotations['hp_ind'], annotations['hp_offset'])
+        hm_hp_loss = self._neg_loss(output['hm_hp'], annotations['hm_hp'])
+        coor_loss, prob_loss, box_score = self.position_loss(output, annotations, P2)
+
+        loss_stats = {'loss': box_score, 'hm_loss': hm_loss, 'hp_loss': hp_loss,
+                      'hm_hp_loss': hm_hp_loss, 'hp_offset_loss': hp_offset_loss,
+                      'wh_loss': wh_loss, 'off_loss': off_loss,'dim_loss': dim_loss,
+                      'rot_loss':rot_loss,'prob_loss':prob_loss,'box_score':box_score,'coor_loss':coor_loss}
+
+        weight_dict = {'hm_loss': 1, 'hp_loss': 1,
+                       'hm_hp_loss': 1, 'hp_offset_loss': 1,
+                       'wh_loss': 0.1, 'off_loss': 1, 'dim_loss': 2,
+                       'rot_loss': 0.2, 'prob_loss': self.exp_rampup(epoch), 'coor_loss': self.exp_rampup(epoch)}
+
+        loss = 0
+        for key, weight in weight_dict.items():
+            if key in loss_stats:
+                loss = loss + loss_stats[key] * weight
+        loss_stats['total_loss'] = loss
+        return loss, loss_stats
+
+    def forward(self, x):
+        ret = {}
+        for head in self.head_layers:
+            ret[head] = self.head_layers[head](x)
+        return ret
diff --git a/visualDet3D/networks/heads/losses.py b/visualDet3D/networks/heads/losses.py
index e68a846..d57ec05 100644
--- a/visualDet3D/networks/heads/losses.py
+++ b/visualDet3D/networks/heads/losses.py
@@ -4,6 +4,7 @@
 import torch
 import torch.nn as nn
 from visualDet3D.networks.utils.utils import calc_iou
+from visualDet3D.networks.lib.disparity_loss import stereo_focal_loss
 from visualDet3D.utils.timer import profile
 
 
@@ -116,4 +117,19 @@ def forward(self, preds:torch.Tensor, targets:torch.Tensor, eps:float=1e-8) -> t
         # IoU
         ious = overlap / union
         ious = torch.clamp(ious, min=eps)
-        return -ious.log()
\ No newline at end of file
+        return -ious.log()
+
+class DisparityLoss(nn.Module):
+    """Some Information about DisparityLoss"""
+    def __init__(self, maxdisp:int=64):
+        super(DisparityLoss, self).__init__()
+        #self.register_buffer("disp",torch.Tensor(np.reshape(np.array(range(maxdisp)),[1,maxdisp,1,1])))
+        self.criterion = stereo_focal_loss.StereoFocalLoss(maxdisp)
+
+    def forward(self, x:torch.Tensor, label:torch.Tensor)->torch.Tensor:
+        #x = torch.softmax(x, dim=1)
+        label = label.cuda().unsqueeze(1)
+        loss = self.criterion(x, label, variance=0.5)
+        #mask = (label > 0) * (label < 64)
+        #loss = nn.functional.smooth_l1_loss(disp[mask], label[mask])
+        return loss
\ No newline at end of file
diff --git a/visualDet3D/networks/lib/PSM_cost_volume.py b/visualDet3D/networks/lib/PSM_cost_volume.py
new file mode 100644
index 0000000..4831c5c
--- /dev/null
+++ b/visualDet3D/networks/lib/PSM_cost_volume.py
@@ -0,0 +1,130 @@
+"""
+    This script implements cost_volume module in the PSM networks
+"""
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.autograd import Variable
+from visualDet3D.utils.timer import profile
+def make_grid(grid_shape):
+    
+    #grid: (y, x, z)
+    grid_1ds = [torch.arange(-1, 1, 2.0/shape) for shape in grid_shape]
+    grids = torch.meshgrid(grid_1ds)
+    return grids
+
+class CostVolume(nn.Module):
+    """
+        While PSV module define depth dimension similar to the depth in real world
+
+        Cost Volume implementation in PSM network and its prior networks define this directly as disparity
+    """
+    def __init__(self, max_disp=192, downsample_scale=4, input_features=1024, PSM_features=64):
+        super(CostVolume, self).__init__()
+        self.max_disp = max_disp
+        self.downsample_scale = downsample_scale
+        self.depth_channel = int(self.max_disp / self.downsample_scale)
+        self.down_sample = nn.Sequential(
+            nn.Conv2d(input_features, PSM_features, 1),
+            nn.BatchNorm2d(PSM_features),
+            nn.ReLU(),
+        )
+        self.conv3d = nn.Sequential(
+            nn.Conv3d(2 * PSM_features, PSM_features, 3, padding=1),
+            nn.BatchNorm3d(PSM_features),
+            nn.ReLU(),
+            nn.Conv3d(PSM_features, PSM_features, 3, padding=1),
+            nn.BatchNorm3d(PSM_features),
+            nn.ReLU(),
+        )
+        self.output_channel = PSM_features * self.depth_channel
+    @profile("Cost Volume", 1, 10)
+    def forward(self, left_features, right_features):
+        batch_size, _, w, h = left_features.shape
+        left_features = self.down_sample(left_features)
+        right_features = self.down_sample(right_features)
+        cost = Variable(
+            torch.FloatTensor(left_features.size()[0],
+                              left_features.size()[1]*2,
+                              self.depth_channel,
+                              left_features.size()[2],  
+                              left_features.size()[3]).zero_(), 
+            volatile= not self.training
+        ).cuda()
+
+        for i in range(self.depth_channel):
+            if i > 0 :
+                 cost[:, :left_features.size()[1], i, :,i:]  = left_features[:,:,:,i:]
+                 cost[:, left_features.size()[1]:, i, :,i:]  = right_features[:,:,:,:-i]
+            else:
+                 cost[:, :left_features.size()[1], i, :,:]   = left_features
+                 cost[:, left_features.size()[1]:, i, :,:]   = right_features
+        cost = cost.contiguous()
+        cost = self.conv3d(cost) # .squeeze(1)
+        cost = cost.reshape(batch_size, -1, w, h).contiguous()
+        return cost
+
+
+class PSMCosineModule(nn.Module):
+    """Some Information about PSMCosineModule"""
+    def __init__(self, max_disp=192, downsample_scale=4, input_features=512):
+        super(PSMCosineModule, self).__init__()
+        self.max_disp = max_disp
+        self.downsample_scale = downsample_scale
+        self.depth_channel = int(self.max_disp / self.downsample_scale)
+        #self.distance_function = nn.CosineSimilarity(dim=1)
+
+    @profile("PSM Cos Volume", 1, 20)
+    def forward(self, left_features, right_features):
+        cost = Variable(
+            torch.FloatTensor(left_features.size()[0],
+                              self.depth_channel,
+                              left_features.size()[2],  
+                              left_features.size()[3]).zero_(), 
+            volatile= not self.training
+        ).cuda()
+
+        for i in range(self.depth_channel):
+            if i > 0 :
+                 cost[:, i, :,i:]  = (left_features[:,:,:,i:] * right_features[:,:,:,:-i]).mean(dim=1)
+            else:
+                 cost[:, i, :, :]  = (left_features * right_features).mean(dim=1)
+        cost = cost.contiguous()
+        return cost
+
+class DoublePSMCosineModule(PSMCosineModule):
+    """Some Information about DoublePSMCosineModule"""
+    def __init__(self, max_disp=192, downsample_scale=4):
+        super(DoublePSMCosineModule, self).__init__(max_disp=max_disp, downsample_scale=downsample_scale)
+        self.depth_channel = self.depth_channel
+
+    def forward(self, left_features, right_features):
+        b, c, h, w = left_features.shape
+        base_grid_y, base_grid_x = make_grid(right_features.shape[2:]) #[h, w]
+        base_grid_x = base_grid_x - 1.0 / right_features.shape[1] 
+        shifted_grid = torch.stack([base_grid_y, base_grid_x], dim=-1).cuda().unsqueeze(0).repeat(b, 1, 1, 1)
+        right_features_shifted = F.grid_sample(right_features, shifted_grid)
+        cost_1 = super(DoublePSMCosineModule, self)(left_features, right_features)
+        cost_2 = super(DoublePSMCosineModule, self)(left_features, right_features_shifted)
+        return torch.cat([cost_1, cost_2], dim=1)
+
+
+
+if __name__ == "__main__":
+    model = DoublePSMCosineModule(max_disp=192, downsample_scale=16).cuda()
+    left_feature = torch.randn(2, 128, 12, 56, requires_grad=True, device="cuda:0")
+    right_feature = torch.randn(2, 128, 12, 56, requires_grad=True, device="cuda:0")
+    output = model(left_feature, right_feature, 0, 0) #currently dummy
+    mean_1 = output.mean() 
+    mean_1.backward()
+    print(left_feature.grad.std())
+    print(model.depth_channel)
+    print(output.shape)
+    import time
+    start = time.time()
+    for _ in range(10):
+        output = model(left_feature, right_feature, 0, 0)
+    print(time.time() - start)
diff --git a/visualDet3D/networks/lib/disparity_loss/__init__.py b/visualDet3D/networks/lib/disparity_loss/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/visualDet3D/networks/lib/disparity_loss/disp2prob.py b/visualDet3D/networks/lib/disparity_loss/disp2prob.py
new file mode 100644
index 0000000..2e677ef
--- /dev/null
+++ b/visualDet3D/networks/lib/disparity_loss/disp2prob.py
@@ -0,0 +1,142 @@
+import warnings
+
+import torch
+import torch.nn.functional as F
+
+
+def isNaN(x):
+    return x != x
+
+
+class Disp2Prob(object):
+    """
+    Convert disparity map to matching probability volume
+        Args:
+            maxDisp, (int): the maximum of disparity
+            gtDisp, (torch.Tensor): in (..., Height, Width) layout
+            start_disp (int): the start searching disparity index, usually be 0
+            dilation (int): the step between near disparity index
+
+        Outputs:
+            probability, (torch.Tensor): in [BatchSize, maxDisp, Height, Width] layout
+
+
+    """
+    def __init__(self, maxDisp:int, gtDisp:torch.Tensor, start_disp:int=0, dilation:int=1):
+
+        if not isinstance(maxDisp, int):
+            raise TypeError('int is expected, got {}'.format(type(maxDisp)))
+
+        if not torch.is_tensor(gtDisp):
+            raise TypeError('tensor is expected, got {}'.format(type(gtDisp)))
+
+        if not isinstance(start_disp, int):
+            raise TypeError('int is expected, got {}'.format(type(start_disp)))
+
+        if not isinstance(dilation, int):
+            raise TypeError('int is expected, got {}'.format(type(dilation)))
+
+        if gtDisp.dim() == 2:  # single image H x W
+            gtDisp = gtDisp.view(1, 1, gtDisp.size(0), gtDisp.size(1))
+
+        if gtDisp.dim() == 3:  # multi image B x H x W
+            gtDisp = gtDisp.view(gtDisp.size(0), 1, gtDisp.size(1), gtDisp.size(2))
+
+        if gtDisp.dim() == 4:
+            if gtDisp.size(1) == 1:  # mult image B x 1 x H x W
+                gtDisp = gtDisp
+            else:
+                raise ValueError('2nd dimension size should be 1, got {}'.format(gtDisp.size(1)))
+
+        self.gtDisp = gtDisp
+        self.maxDisp = maxDisp
+        self.start_disp = start_disp
+        self.dilation = dilation
+        self.end_disp = start_disp + maxDisp - 1
+        self.disp_sample_number = (maxDisp + dilation -1) // dilation
+        self.eps = 1e-40
+
+    def getProb(self):
+        # [BatchSize, 1, Height, Width]
+        b, c, h, w = self.gtDisp.shape
+        assert c == 1
+
+        # if start_disp = 0, dilation = 1, then generate disparity candidates as [0, 1, 2, ... , maxDisp-1]
+        index = torch.linspace(self.start_disp, self.end_disp, self.disp_sample_number)
+        index = index.to(self.gtDisp.device)
+
+        # [BatchSize, maxDisp, Height, Width]
+        self.index = index.repeat(b, h, w, 1).permute(0, 3, 1, 2).contiguous()
+
+        # the gtDisp must be (start_disp, end_disp), otherwise, we have to mask it out
+        mask = (self.gtDisp > self.start_disp) & (self.gtDisp < self.end_disp)
+        mask = mask.detach().type_as(self.gtDisp)
+        self.gtDisp = self.gtDisp * mask
+
+        probability = self.calProb()
+
+        # let the outliers' probability to be 0
+        # in case divide or log 0, we plus a tiny constant value
+        probability = probability * mask + self.eps
+
+        # in case probability is NaN
+        if isNaN(probability.min()) or isNaN(probability.max()):
+            print('Probability ==> min: {}, max: {}'.format(probability.min(), probability.max()))
+            print('Disparity Ground Truth after mask out ==> min: {}, max: {}'.format(self.gtDisp.min(),
+                                                                                      self.gtDisp.max()))
+            raise ValueError(" \'probability contains NaN!")
+
+        return probability
+
+    def kick_invalid_half(self):
+        distance = self.gtDisp - self.index
+        invalid_index = distance < 0
+        # after softmax, the valid index with value 1e6 will approximately get 0
+        distance[invalid_index] = 1e6
+        return distance
+
+    def calProb(self):
+        raise NotImplementedError
+
+
+class LaplaceDisp2Prob(Disp2Prob):
+    # variance is the diversity of the Laplace distribution
+    def __init__(self, maxDisp, gtDisp, variance=1, start_disp=0, dilation=1):
+        super(LaplaceDisp2Prob, self).__init__(maxDisp, gtDisp, start_disp, dilation)
+        self.variance = variance
+
+    def calProb(self):
+        # 1/N * exp( - (d - d{gt}) / var), N is normalization factor, [BatchSize, maxDisp, Height, Width]
+        scaled_distance = ((-torch.abs(self.index - self.gtDisp)) / self.variance)
+        probability = F.softmax(scaled_distance, dim=1)
+
+        return probability
+
+
+class GaussianDisp2Prob(Disp2Prob):
+    # variance is the variance of the Gaussian distribution
+    def __init__(self, maxDisp, gtDisp, variance=1, start_disp=0, dilation=1):
+        super(GaussianDisp2Prob, self).__init__(maxDisp, gtDisp, start_disp, dilation)
+        self.variance = variance
+
+    def calProb(self):
+        # 1/N * exp( - (d - d{gt})^2 / b), N is normalization factor, [BatchSize, maxDisp, Height, Width]
+        distance = (torch.abs(self.index - self.gtDisp))
+        scaled_distance = (- distance.pow(2.0) / self.variance)
+        probability = F.softmax(scaled_distance, dim=1)
+
+        return probability
+
+class OneHotDisp2Prob(Disp2Prob):
+    # variance is the variance of the OneHot distribution
+    def __init__(self, maxDisp, gtDisp, variance=1, start_disp=0, dilation=1):
+        super(OneHotDisp2Prob, self).__init__(maxDisp, gtDisp, start_disp, dilation)
+        self.variance = variance
+
+    def getProb(self):
+
+        # |d - d{gt}| < variance, [BatchSize, maxDisp, Height, Width]
+        probability = torch.lt(torch.abs(self.index - self.gtDisp), self.variance).type_as(self.gtDisp)
+
+        return probability
+
diff --git a/visualDet3D/networks/lib/disparity_loss/stereo_focal_loss.py b/visualDet3D/networks/lib/disparity_loss/stereo_focal_loss.py
new file mode 100644
index 0000000..6a11297
--- /dev/null
+++ b/visualDet3D/networks/lib/disparity_loss/stereo_focal_loss.py
@@ -0,0 +1,121 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from .disp2prob import LaplaceDisp2Prob, GaussianDisp2Prob, OneHotDisp2Prob
+
+class StereoFocalLoss(object):
+    """
+    Under the same start disparity and maximum disparity, calculating all estimated cost volumes' loss
+        Args:
+            max_disp, (int): the max of Disparity. default: 192
+            start_disp, (int): the start searching disparity index, usually be 0
+            dilation (int): the step between near disparity index, it mainly used in gt probability volume generation
+            weights, (list of float or None): weight for each scale of estCost.
+            focal_coefficient, (float): stereo focal loss coefficient, details please refer to paper. default: 0.0
+            sparse, (bool): whether the ground-truth disparity is sparse, for example, KITTI is sparse, but SceneFlow is not. default: False
+
+        Inputs:
+            estCost, (Tensor or list of Tensor): the estimated cost volume, in (BatchSize, max_disp, Height, Width) layout
+            gtDisp, (Tensor): the ground truth disparity map, in (BatchSize, 1, Height, Width) layout.
+            variance, (Tensor or list of Tensor): the variance of distribution, details please refer to paper, in (BatchSize, 1, Height, Width) layout.
+
+        Outputs:
+            loss, (dict), the loss of each level
+
+        ..Note:
+            Before calculate loss, the estCost shouldn't be normalized,
+              because we will use softmax for normalization
+    """
+
+    def __init__(self, max_disp=192, start_disp=0, dilation=1, weights=None, focal_coefficient=0.0, sparse=False):
+        self.max_disp = max_disp
+        self.start_disp = start_disp
+        self.dilation = dilation
+        self.weights = weights
+        self.focal_coefficient = focal_coefficient
+        self.sparse = sparse
+        if sparse:
+            # sparse disparity ==> max_pooling
+            self.scale_func = F.adaptive_max_pool2d
+        else:
+            # dense disparity ==> avg_pooling
+            self.scale_func = F.adaptive_avg_pool2d
+
+    def loss_per_level(self, estCost, gtDisp, variance, dilation):
+        N, C, H, W = estCost.shape
+        scaled_gtDisp = gtDisp.clone()
+        scale = 1.0
+        if gtDisp.shape[-2] != H or gtDisp.shape[-1] != W:
+            # compute scale per level and scale gtDisp
+            scale = gtDisp.shape[-1] / (W * 1.0)
+            scaled_gtDisp = gtDisp.clone() / scale
+
+            scaled_gtDisp = self.scale_func(scaled_gtDisp, (H, W))
+
+        # mask for valid disparity
+        # (start_disp, max disparity / scale)
+        # Attention: the invalid disparity of KITTI is set as 0, be sure to mask it out
+        lower_bound = self.start_disp
+        upper_bound = lower_bound + int(self.max_disp/scale)
+        mask = (scaled_gtDisp > lower_bound) & (scaled_gtDisp < upper_bound)
+        mask = mask.detach_().type_as(scaled_gtDisp)
+        if mask.sum() < 1.0:
+            print('Stereo focal loss: there is no point\'s '
+                  'disparity is in [{},{})!'.format(lower_bound, upper_bound))
+            scaled_gtProb = torch.zeros_like(estCost)  # let this sample have loss with 0
+        else:
+            # transfer disparity map to probability map
+            mask_scaled_gtDisp = scaled_gtDisp * mask
+            scaled_gtProb = LaplaceDisp2Prob(int(self.max_disp/scale), mask_scaled_gtDisp, variance=variance,
+                                             start_disp=self.start_disp, dilation=dilation).getProb()
+
+        # stereo focal loss
+        estProb = F.log_softmax(estCost, dim=1)
+        weight = (1.0 - scaled_gtProb).pow(-self.focal_coefficient).type_as(scaled_gtProb)
+        loss = -((scaled_gtProb * estProb) * weight * mask.float()).sum(dim=1, keepdim=True).mean()
+
+        return loss
+
+    def __call__(self, estCost, gtDisp, variance):
+        if not isinstance(estCost, (list, tuple)):
+            estCost = [estCost]
+
+        if self.weights is None:
+            self.weights = 1.0
+
+        if not isinstance(self.weights, (list, tuple)):
+            self.weights = [self.weights] * len(estCost)
+
+        if not isinstance(self.dilation, (list, tuple)):
+            self.dilation = [self.dilation] * len(estCost)
+
+        if not isinstance(variance, (list, tuple)):
+            variance = [variance] * len(estCost)
+
+        # compute loss for per level
+        loss_all_level = []
+        for est_cost_per_lvl, var, dt in zip(estCost, variance, self.dilation):
+            loss_all_level.append(
+                self.loss_per_level(est_cost_per_lvl, gtDisp, var, dt))
+
+        # re-weight loss per level
+        loss = 0
+        for i, loss_per_level in enumerate(loss_all_level):
+            loss += self.weights[i] * loss_per_level
+
+        return loss
+
+    def __repr__(self):
+        repr_str = '{}\n'.format(self.__class__.__name__)
+        repr_str += ' ' * 4 + 'Max Disparity: {}\n'.format(self.max_disp)
+        repr_str += ' ' * 4 + 'Start disparity: {}\n'.format(self.start_disp)
+        repr_str += ' ' * 4 + 'Dilation rate: {}\n'.format(self.dilation)
+        repr_str += ' ' * 4 + 'Loss weight: {}\n'.format(self.weights)
+        repr_str += ' ' * 4 + 'Focal coefficient: {}\n'.format(self.focal_coefficient)
+        repr_str += ' ' * 4 + 'Disparity is sparse: {}\n'.format(self.sparse)
+
+        return repr_str
+
+    @property
+    def name(self):
+        return 'StereoFocalLoss'
diff --git a/visualDet3D/networks/lib/fast_utils/hill_climbing.py b/visualDet3D/networks/lib/fast_utils/hill_climbing.py
index 9d46a46..22f3d5d 100644
--- a/visualDet3D/networks/lib/fast_utils/hill_climbing.py
+++ b/visualDet3D/networks/lib/fast_utils/hill_climbing.py
@@ -14,12 +14,12 @@ def post_opt(bbox_2d, bbox3d_state_3d, P2, cx, cy):
     box_2d = bbox_2d.detach().cpu().numpy()
     state = bbox3d_state_3d.detach().cpu().numpy()
     x, y, z, w, h, l, alpha = state[0], state[1], state[2],state[3],state[4],state[5], state[6]
-    theta = convertAlpha2Rot([alpha], z, x)[0]
+    theta = convertAlpha2Rot(np.array([alpha]), cx, P2)[0]
     theta, ratio, w, h, l = post_optimization(p2, p2_inv, box_2d, cx, cy, z,
                                        w, h, l, theta, step_r_init=0.4, r_lim=0.01)
     z = z*ratio
     
-    alpha = convertRot2Alpha([theta], z, x)[0]
+    alpha = convertRot2Alpha(np.array([theta]), cx, P2)[0]
     return bbox3d_state_3d.new([cx,cy,z, w,h,l,alpha])
 
 @jit(nopython=True, cache=True)
diff --git a/visualDet3D/networks/lib/ghost_module.py b/visualDet3D/networks/lib/ghost_module.py
new file mode 100644
index 0000000..c95089e
--- /dev/null
+++ b/visualDet3D/networks/lib/ghost_module.py
@@ -0,0 +1,64 @@
+"""
+    This script implement ghost module from 
+    "GhostNet: More Features from Cheap Operations"
+    https://arxiv.org/pdf/1911.11907.pdf
+    Introduction in:
+    https://owen-liuyuxuan.github.io/papers_reading_sharing.github.io/Building_Blocks/GhostNet/
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import math
+
+
+class GhostModule(nn.Module):
+    """
+        Ghost Module from https://github.com/iamhankai/ghostnet.pytorch.
+
+    """
+    def __init__(self, inp, oup, kernel_size=1, ratio=2, dw_size=3, stride=1, relu=True):
+        super(GhostModule, self).__init__()
+        self.oup = oup
+        init_channels = math.ceil(oup / ratio)
+        new_channels = init_channels*(ratio-1)
+
+        self.primary_conv = nn.Sequential(
+            nn.AvgPool2d(stride) if stride > 1 else nn.Sequential(),
+            nn.Conv2d(inp, init_channels, kernel_size, 1, kernel_size//2, bias=False),
+            nn.BatchNorm2d(init_channels),
+            nn.ReLU(inplace=True) if relu else nn.Sequential(),
+        )
+
+        self.cheap_operation = nn.Sequential(
+            nn.Conv2d(init_channels, new_channels, dw_size, 1, dw_size//2, groups=init_channels, bias=False),
+            nn.BatchNorm2d(new_channels),
+            nn.ReLU(inplace=True) if relu else nn.Sequential(),
+        )
+
+    def forward(self, x):
+        x1 = self.primary_conv(x)
+        x2 = self.cheap_operation(x1)
+        out = torch.cat([x1,x2], dim=1)
+        return out[:,:self.oup,:,:]
+
+class ResGhostModule(GhostModule):
+    """Some Information about ResGhostModule"""
+    def __init__(self, inp, oup, kernel_size=1, ratio=2, dw_size=3, relu=True, stride=1):
+        assert(ratio > 2)
+        super(ResGhostModule, self).__init__(inp, oup-inp, kernel_size, ratio-1, dw_size, relu=relu, stride=stride)
+        self.oup = oup
+        if stride > 1:
+            self.downsampling = nn.AvgPool2d(kernel_size=stride, stride=stride)
+        else:
+            self.downsampling = None
+
+    def forward(self, x):
+        x1 = self.primary_conv(x)
+        x2 = self.cheap_operation(x1)
+
+        if not self.downsampling is None:
+            x = self.downsampling(x)
+        out = torch.cat([x, x1, x2], dim=1)
+        return out[:,:self.oup,:,:]
diff --git a/visualDet3D/networks/lib/ops/iou3d/__init__.py b/visualDet3D/networks/lib/ops/iou3d/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/visualDet3D/networks/lib/ops/iou3d/iou3d.py b/visualDet3D/networks/lib/ops/iou3d/iou3d.py
new file mode 100644
index 0000000..b9bcea5
--- /dev/null
+++ b/visualDet3D/networks/lib/ops/iou3d/iou3d.py
@@ -0,0 +1,103 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from .iou3d_cuda import boxes_iou_bev_gpu, boxes_overlap_bev_gpu, nms_normal_gpu, nms_gpu
+
+
+def boxes3d_to_bev_torch(boxes3d):
+    """
+    :param boxes3d: (N, 7) [x, y, z, h, w, l, ry]
+    :return:
+        boxes_bev: (N, 5) [x1, y1, x2, y2, ry]
+    """
+    boxes_bev = boxes3d.new(torch.Size((boxes3d.shape[0], 5)))
+
+    cu, cv = boxes3d[:, 0], boxes3d[:, 2]
+    half_l, half_w = boxes3d[:, 5] / 2, boxes3d[:, 4] / 2
+    boxes_bev[:, 0], boxes_bev[:, 1] = cu - half_l, cv - half_w
+    boxes_bev[:, 2], boxes_bev[:, 3] = cu + half_l, cv + half_w
+    boxes_bev[:, 4] = boxes3d[:, 6]
+    return boxes_bev
+
+def boxes_iou_bev(boxes_a, boxes_b):
+    """
+    :param boxes_a: (M, 5)
+    :param boxes_b: (N, 5)
+    :return:
+        ans_iou: (M, N)
+    """
+
+    ans_iou = torch.cuda.FloatTensor(torch.Size((boxes_a.shape[0], boxes_b.shape[0]))).zero_()
+
+    boxes_iou_bev_gpu(boxes_a.contiguous(), boxes_b.contiguous(), ans_iou)
+
+    return ans_iou
+
+def boxes_iou3d_gpu(boxes_a, boxes_b):
+    """
+    :param boxes_a: (N, 7) [x, y, z, h, w, l, ry]
+    :param boxes_b: (M, 7) [x, y, z, h, w, l, ry]
+    :return:
+        ans_iou: (M, N)
+    """
+    boxes_a_bev = boxes3d_to_bev_torch(boxes_a)
+    boxes_b_bev = boxes3d_to_bev_torch(boxes_b)
+
+    # bev overlap
+    overlaps_bev = torch.cuda.FloatTensor(torch.Size((boxes_a.shape[0], boxes_b.shape[0]))).zero_()  # (N, M)
+    boxes_overlap_bev_gpu(boxes_a_bev.contiguous(), boxes_b_bev.contiguous(), overlaps_bev)
+
+    # height overlap
+    boxes_a_height_min = (boxes_a[:, 1] - boxes_a[:, 3]).view(-1, 1)
+    boxes_a_height_max = boxes_a[:, 1].view(-1, 1)
+    boxes_b_height_min = (boxes_b[:, 1] - boxes_b[:, 3]).view(1, -1)
+    boxes_b_height_max = boxes_b[:, 1].view(1, -1)
+
+    max_of_min = torch.max(boxes_a_height_min, boxes_b_height_min)
+    min_of_max = torch.min(boxes_a_height_max, boxes_b_height_max)
+    overlaps_h = torch.clamp(min_of_max - max_of_min, min=0)
+
+    # 3d iou
+    overlaps_3d = overlaps_bev * overlaps_h
+
+    vol_a = (boxes_a[:, 3] * boxes_a[:, 4] * boxes_a[:, 5]).view(-1, 1)
+    vol_b = (boxes_b[:, 3] * boxes_b[:, 4] * boxes_b[:, 5]).view(1, -1)
+
+    iou3d = overlaps_3d / torch.clamp(vol_a + vol_b - overlaps_3d, min=1e-7)
+
+    return iou3d
+
+
+def nms_gpu(boxes, scores, thresh):
+    """
+    :param boxes: (N, 5) [x1, y1, x2, y2, ry]
+    :param scores: (N)
+    :param thresh:
+    :return:
+    """
+    # areas = (x2 - x1) * (y2 - y1)
+    order = scores.sort(0, descending=True)[1]
+
+    boxes = boxes[order].contiguous()
+
+    keep = torch.LongTensor(boxes.size(0))
+    num_out = nms_gpu(boxes, keep, thresh)
+    return order[keep[:num_out].cuda()].contiguous()
+
+
+def nms_normal_gpu(boxes, scores, thresh):
+    """
+    :param boxes: (N, 5) [x1, y1, x2, y2, ry]
+    :param scores: (N)
+    :param thresh:
+    :return:
+    """
+    # areas = (x2 - x1) * (y2 - y1)
+    order = scores.sort(0, descending=True)[1]
+
+    boxes = boxes[order].contiguous()
+
+    keep = torch.LongTensor(boxes.size(0))
+    num_out = nms_normal_gpu(boxes, keep, thresh)
+    return order[keep[:num_out].cuda()].contiguous()
\ No newline at end of file
diff --git a/visualDet3D/networks/lib/ops/iou3d/make.sh b/visualDet3D/networks/lib/ops/iou3d/make.sh
new file mode 100644
index 0000000..2fe7a5c
--- /dev/null
+++ b/visualDet3D/networks/lib/ops/iou3d/make.sh
@@ -0,0 +1,8 @@
+export CUDA_HOME=/usr/local/cuda
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda
+export CUDA_TOOLKIT_ROOT_DIR=$CUDA_HOME
+export LD_LIBRARY_PATH="$CUDA_HOME/extras/CUPTI/lib64:$LD_LIBRARY_PATH"
+export LIBRARY_PATH=$CUDA_HOME/lib64:$LIBRARY_PATH
+export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
+export CFLAGS="-fopenmp -I$CUDA_HOME/include $CFLAGS"
+python3 setup.py build_ext --inplace
diff --git a/visualDet3D/networks/lib/ops/iou3d/setup.py b/visualDet3D/networks/lib/ops/iou3d/setup.py
new file mode 100644
index 0000000..0b988eb
--- /dev/null
+++ b/visualDet3D/networks/lib/ops/iou3d/setup.py
@@ -0,0 +1,197 @@
+#!/usr/bin/env python
+import os
+import subprocess
+import time
+from setuptools import find_packages, setup
+
+import torch
+from torch.utils.cpp_extension import (BuildExtension, CppExtension,
+                                       CUDAExtension)
+
+
+def readme():
+    with open('README.md', encoding='utf-8') as f:
+        content = f.read()
+    return content
+
+
+def get_git_hash():
+
+    def _minimal_ext_cmd(cmd):
+        # construct minimal environment
+        env = {}
+        for k in ['SYSTEMROOT', 'PATH', 'HOME']:
+            v = os.environ.get(k)
+            if v is not None:
+                env[k] = v
+        # LANGUAGE is used on win32
+        env['LANGUAGE'] = 'C'
+        env['LANG'] = 'C'
+        env['LC_ALL'] = 'C'
+        out = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, env=env).communicate()[0]
+        return out
+
+    try:
+        out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD'])
+        sha = out.strip().decode('ascii')
+    except OSError:
+        sha = 'unknown'
+
+    return sha
+
+
+def get_hash():
+    if os.path.exists('.git'):
+        sha = get_git_hash()[:7]
+    elif os.path.exists(version_file):
+        try:
+            from mmdet.version import __version__
+            sha = __version__.split('+')[-1]
+        except ImportError:
+            raise ImportError('Unable to get git version')
+    else:
+        sha = 'unknown'
+
+    return sha
+
+
+
+def get_version():
+    with open(version_file, 'r') as f:
+        exec(compile(f.read(), version_file, 'exec'))
+    return locals()['__version__']
+
+
+def make_cuda_ext(name, module, sources, sources_cuda=[]):
+
+    define_macros = []
+    extra_compile_args = {'cxx': []}
+
+    if torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
+        define_macros += [('WITH_CUDA', None)]
+        extension = CUDAExtension
+        extra_compile_args['nvcc'] = [
+            '-D__CUDA_NO_HALF_OPERATORS__',
+            '-D__CUDA_NO_HALF_CONVERSIONS__',
+            '-D__CUDA_NO_HALF2_OPERATORS__',
+        ]
+        sources += sources_cuda
+    else:
+        print(f'Compiling {name} without CUDA')
+        extension = CppExtension
+        # raise EnvironmentError('CUDA is required to compile MMDetection!')
+
+    return extension(
+        name=f'{module}.{name}',
+        sources=[os.path.join(*module.split('.'), p) for p in sources],
+        define_macros=define_macros,
+        extra_compile_args=extra_compile_args)
+
+
+def parse_requirements(fname='requirements.txt', with_version=True):
+    """
+    Parse the package dependencies listed in a requirements file but strips
+    specific versioning information.
+
+    Args:
+        fname (str): path to requirements file
+        with_version (bool, default=False): if True include version specs
+
+    Returns:
+        List[str]: list of requirements items
+
+    CommandLine:
+        python -c "import setup; print(setup.parse_requirements())"
+    """
+    import sys
+    from os.path import exists
+    import re
+    require_fpath = fname
+
+    def parse_line(line):
+        """
+        Parse information from a line in a requirements text file
+        """
+        if line.startswith('-r '):
+            # Allow specifying requirements in other files
+            target = line.split(' ')[1]
+            for info in parse_require_file(target):
+                yield info
+        else:
+            info = {'line': line}
+            if line.startswith('-e '):
+                info['package'] = line.split('#egg=')[1]
+            else:
+                # Remove versioning from the package
+                pat = '(' + '|'.join(['>=', '==', '>']) + ')'
+                parts = re.split(pat, line, maxsplit=1)
+                parts = [p.strip() for p in parts]
+
+                info['package'] = parts[0]
+                if len(parts) > 1:
+                    op, rest = parts[1:]
+                    if ';' in rest:
+                        # Handle platform specific dependencies
+                        # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies
+                        version, platform_deps = map(str.strip,
+                                                     rest.split(';'))
+                        info['platform_deps'] = platform_deps
+                    else:
+                        version = rest  # NOQA
+                    info['version'] = (op, version)
+            yield info
+
+    def parse_require_file(fpath):
+        with open(fpath, 'r') as f:
+            for line in f.readlines():
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    for info in parse_line(line):
+                        yield info
+
+    def gen_packages_items():
+        if exists(require_fpath):
+            for info in parse_require_file(require_fpath):
+                parts = [info['package']]
+                if with_version and 'version' in info:
+                    parts.extend(info['version'])
+                if not sys.version.startswith('3.4'):
+                    # apparently package_deps are broken in 3.4
+                    platform_deps = info.get('platform_deps')
+                    if platform_deps is not None:
+                        parts.append(';' + platform_deps)
+                item = ''.join(parts)
+                yield item
+
+    packages = list(gen_packages_items())
+    return packages
+
+
+if __name__ == '__main__':
+    setup(
+        name='iou3d_cuda',
+        description='iou3d cuda',
+        keywords='computer vision, object detection',
+        packages=find_packages(exclude=('configs', 'tools', 'demo')),
+        classifiers=[
+            'Development Status :: 4 - Beta',
+            'License :: OSI Approved :: Apache Software License',
+            'Operating System :: OS Independent',
+            'Programming Language :: Python :: 3',
+            'Programming Language :: Python :: 3.5',
+            'Programming Language :: Python :: 3.6',
+            'Programming Language :: Python :: 3.7',
+        ],
+        license='Apache License 2.0',
+        ext_modules=[
+            make_cuda_ext(
+                name='iou3d_cuda',
+                module='.',
+                sources=['src/iou3d.cpp'],
+                sources_cuda=[
+                    'src/iou3d_kernel.cu'
+                ]),
+        ],
+        cmdclass={'build_ext': BuildExtension},
+        zip_safe=False)
diff --git a/visualDet3D/networks/lib/ops/iou3d/src/iou3d.cpp b/visualDet3D/networks/lib/ops/iou3d/src/iou3d.cpp
new file mode 100644
index 0000000..ee11ce1
--- /dev/null
+++ b/visualDet3D/networks/lib/ops/iou3d/src/iou3d.cpp
@@ -0,0 +1,180 @@
+#include <torch/serialize/tensor.h>
+#include <torch/extension.h>
+#include <vector>
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+
+#define CHECK_CUDA(x) TORCH_CHECK(x.device().is_cuda(), #x, " must be a CUDAtensor ")
+#define CHECK_CONTIGUOUS(x) TORCH_CHECK(x.is_contiguous(), #x, " must be contiguous ")
+#define CHECK_INPUT(x) CHECK_CUDA(x);CHECK_CONTIGUOUS(x)
+
+#define DIVUP(m,n) ((m) / (n) + ((m) % (n) > 0))
+
+#define CHECK_ERROR(ans) { gpuAssert((ans), __FILE__, __LINE__); }
+inline void gpuAssert(cudaError_t code, const char *file, int line, bool abort=true)
+{
+   if (code != cudaSuccess)
+   {
+      fprintf(stderr,"GPUassert: %s %s %d\n", cudaGetErrorString(code), file, line);
+      if (abort) exit(code);
+   }
+}
+
+const int THREADS_PER_BLOCK_NMS = sizeof(unsigned long long) * 8;
+
+
+void boxesoverlapLauncher(const int num_a, const float *boxes_a, const int num_b, const float *boxes_b, float *ans_overlap);
+void boxesioubevLauncher(const int num_a, const float *boxes_a, const int num_b, const float *boxes_b, float *ans_iou);
+void nmsLauncher(const float *boxes, unsigned long long * mask, int boxes_num, float nms_overlap_thresh);
+void nmsNormalLauncher(const float *boxes, unsigned long long * mask, int boxes_num, float nms_overlap_thresh);
+
+int boxes_overlap_bev_gpu(at::Tensor boxes_a, at::Tensor boxes_b, at::Tensor ans_overlap){
+    // params boxes_a: (N, 5) [x1, y1, x2, y2, ry]
+    // params boxes_b: (M, 5) 
+    // params ans_overlap: (N, M)
+    
+    CHECK_INPUT(boxes_a);
+    CHECK_INPUT(boxes_b);
+    CHECK_INPUT(ans_overlap);
+
+    int num_a = boxes_a.size(0);
+    int num_b = boxes_b.size(0);
+
+    const float * boxes_a_data = boxes_a.data_ptr<float>();
+    const float * boxes_b_data = boxes_b.data_ptr<float>();
+    float * ans_overlap_data = ans_overlap.data_ptr<float>();
+
+    boxesoverlapLauncher(num_a, boxes_a_data, num_b, boxes_b_data, ans_overlap_data);
+
+    return 1;
+}
+
+int boxes_iou_bev_gpu(at::Tensor boxes_a, at::Tensor boxes_b, at::Tensor ans_iou){
+    // params boxes_a: (N, 5) [x1, y1, x2, y2, ry]
+    // params boxes_b: (M, 5) 
+    // params ans_overlap: (N, M)
+    
+    CHECK_INPUT(boxes_a);
+    CHECK_INPUT(boxes_b);
+    CHECK_INPUT(ans_iou);
+
+    int num_a = boxes_a.size(0);
+    int num_b = boxes_b.size(0);
+
+    const float * boxes_a_data = boxes_a.data_ptr<float>();
+    const float * boxes_b_data = boxes_b.data_ptr<float>();
+    float * ans_iou_data = ans_iou.data_ptr<float>();
+
+    boxesioubevLauncher(num_a, boxes_a_data, num_b, boxes_b_data, ans_iou_data);
+
+    return 1;
+}
+
+int nms_gpu(at::Tensor boxes, at::Tensor keep, float nms_overlap_thresh){
+    // params boxes: (N, 5) [x1, y1, x2, y2, ry]
+    // params keep: (N)
+
+    CHECK_INPUT(boxes);
+    CHECK_CONTIGUOUS(keep);
+
+    int boxes_num = boxes.size(0);
+    const float * boxes_data = boxes.data_ptr<float>();
+    long * keep_data = keep.data_ptr<long>();
+
+    const int col_blocks = DIVUP(boxes_num, THREADS_PER_BLOCK_NMS);
+
+    unsigned long long *mask_data = NULL;
+    CHECK_ERROR(cudaMalloc((void**)&mask_data, boxes_num * col_blocks * sizeof(unsigned long long)));
+    nmsLauncher(boxes_data, mask_data, boxes_num, nms_overlap_thresh);
+
+    // unsigned long long mask_cpu[boxes_num * col_blocks];
+    // unsigned long long *mask_cpu = new unsigned long long [boxes_num * col_blocks];
+    std::vector<unsigned long long> mask_cpu(boxes_num * col_blocks);
+
+//    printf("boxes_num=%d, col_blocks=%d\n", boxes_num, col_blocks);
+    CHECK_ERROR(cudaMemcpy(&mask_cpu[0], mask_data, boxes_num * col_blocks * sizeof(unsigned long long),
+                           cudaMemcpyDeviceToHost));
+
+    cudaFree(mask_data);
+
+    unsigned long long remv_cpu[col_blocks];
+    memset(remv_cpu, 0, col_blocks * sizeof(unsigned long long));
+
+    int num_to_keep = 0;
+
+    for (int i = 0; i < boxes_num; i++){
+        int nblock = i / THREADS_PER_BLOCK_NMS;
+        int inblock = i % THREADS_PER_BLOCK_NMS;
+
+        if (!(remv_cpu[nblock] & (1ULL << inblock))){
+            keep_data[num_to_keep++] = i;
+            unsigned long long *p = &mask_cpu[0] + i * col_blocks;
+            for (int j = nblock; j < col_blocks; j++){
+                remv_cpu[j] |= p[j];
+            }
+        }
+    }
+    if ( cudaSuccess != cudaGetLastError() ) printf( "Error!\n" );
+
+    return num_to_keep;
+}
+
+
+int nms_normal_gpu(at::Tensor boxes, at::Tensor keep, float nms_overlap_thresh){
+    // params boxes: (N, 5) [x1, y1, x2, y2, ry]
+    // params keep: (N)
+
+    CHECK_INPUT(boxes);
+    CHECK_CONTIGUOUS(keep);
+
+    int boxes_num = boxes.size(0);
+    const float * boxes_data = boxes.data_ptr<float>();
+    long * keep_data = keep.data_ptr<long>();
+
+    const int col_blocks = DIVUP(boxes_num, THREADS_PER_BLOCK_NMS);
+
+    unsigned long long *mask_data = NULL;
+    CHECK_ERROR(cudaMalloc((void**)&mask_data, boxes_num * col_blocks * sizeof(unsigned long long)));
+    nmsNormalLauncher(boxes_data, mask_data, boxes_num, nms_overlap_thresh);
+
+    // unsigned long long mask_cpu[boxes_num * col_blocks];
+    // unsigned long long *mask_cpu = new unsigned long long [boxes_num * col_blocks];
+    std::vector<unsigned long long> mask_cpu(boxes_num * col_blocks);
+
+//    printf("boxes_num=%d, col_blocks=%d\n", boxes_num, col_blocks);
+    CHECK_ERROR(cudaMemcpy(&mask_cpu[0], mask_data, boxes_num * col_blocks * sizeof(unsigned long long),
+                           cudaMemcpyDeviceToHost));
+
+    cudaFree(mask_data);
+
+    unsigned long long remv_cpu[col_blocks];
+    memset(remv_cpu, 0, col_blocks * sizeof(unsigned long long));
+
+    int num_to_keep = 0;
+
+    for (int i = 0; i < boxes_num; i++){
+        int nblock = i / THREADS_PER_BLOCK_NMS;
+        int inblock = i % THREADS_PER_BLOCK_NMS;
+
+        if (!(remv_cpu[nblock] & (1ULL << inblock))){
+            keep_data[num_to_keep++] = i;
+            unsigned long long *p = &mask_cpu[0] + i * col_blocks;
+            for (int j = nblock; j < col_blocks; j++){
+                remv_cpu[j] |= p[j];
+            }
+        }
+    }
+    if ( cudaSuccess != cudaGetLastError() ) printf( "Error!\n" );
+
+    return num_to_keep;
+}
+
+
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("boxes_overlap_bev_gpu", &boxes_overlap_bev_gpu, "oriented boxes overlap");
+  m.def("boxes_iou_bev_gpu", &boxes_iou_bev_gpu, "oriented boxes iou");
+  m.def("nms_gpu", &nms_gpu, "oriented nms gpu");
+  m.def("nms_normal_gpu", &nms_normal_gpu, "nms gpu");
+}
+
diff --git a/visualDet3D/networks/lib/ops/iou3d/src/iou3d_kernel.cu b/visualDet3D/networks/lib/ops/iou3d/src/iou3d_kernel.cu
new file mode 100644
index 0000000..328a557
--- /dev/null
+++ b/visualDet3D/networks/lib/ops/iou3d/src/iou3d_kernel.cu
@@ -0,0 +1,387 @@
+/* 
+3D IoU Calculation and Rotated NMS(modified from 2D NMS written by others)
+Written by Shaoshuai Shi
+All Rights Reserved 2018. 
+*/
+
+#include <stdio.h>
+#define THREADS_PER_BLOCK 16
+#define DIVUP(m, n) ((m) / (n) + ((m) % (n) > 0))
+
+//#define DEBUG
+const int THREADS_PER_BLOCK_NMS = sizeof(unsigned long long) * 8; 
+const float EPS = 1e-8;
+struct Point {
+    float x, y;
+    __device__ Point() {}
+    __device__ Point(double _x, double _y){
+        x = _x, y = _y;
+    }
+
+    __device__ void set(float _x, float _y){
+        x = _x; y = _y;
+    }
+
+    __device__ Point operator +(const Point &b)const{
+        return Point(x + b.x, y + b.y);
+    }
+
+    __device__ Point operator -(const Point &b)const{
+        return Point(x - b.x, y - b.y);
+    }
+};
+
+__device__ inline float cross(const Point &a, const Point &b){
+    return a.x * b.y - a.y * b.x;
+}
+
+__device__ inline float cross(const Point &p1, const Point &p2, const Point &p0){
+    return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
+}
+
+__device__ int check_rect_cross(const Point &p1, const Point &p2, const Point &q1, const Point &q2){
+    int ret = min(p1.x,p2.x) <= max(q1.x,q2.x)  && 
+              min(q1.x,q2.x) <= max(p1.x,p2.x) &&
+              min(p1.y,p2.y) <= max(q1.y,q2.y) &&
+              min(q1.y,q2.y) <= max(p1.y,p2.y);
+    return ret;
+}
+
+__device__ inline int check_in_box2d(const float *box, const Point &p){
+    //params: box (5) [x1, y1, x2, y2, angle]
+    const float MARGIN = 1e-5;
+
+    float center_x = (box[0] + box[2]) / 2;
+    float center_y = (box[1] + box[3]) / 2;
+    float angle_cos = cos(-box[4]), angle_sin = sin(-box[4]);  // rotate the point in the opposite direction of box
+    float rot_x = (p.x - center_x) * angle_cos + (p.y - center_y) * angle_sin + center_x;
+    float rot_y = -(p.x - center_x) * angle_sin + (p.y - center_y) * angle_cos + center_y;
+#ifdef DEBUG
+    printf("box: (%.3f, %.3f, %.3f, %.3f, %.3f)\n", box[0], box[1], box[2], box[3], box[4]);
+    printf("center: (%.3f, %.3f), cossin(%.3f, %.3f), src(%.3f, %.3f), rot(%.3f, %.3f)\n", center_x, center_y,
+            angle_cos, angle_sin, p.x, p.y, rot_x, rot_y);
+#endif
+    return (rot_x > box[0] - MARGIN && rot_x < box[2] + MARGIN && rot_y > box[1] - MARGIN && rot_y < box[3] + MARGIN);
+}
+
+__device__ inline int intersection(const Point &p1, const Point &p0, const Point &q1, const Point &q0, Point &ans){
+    // fast exclusion 
+    if (check_rect_cross(p0, p1, q0, q1) == 0) return 0;
+
+    // check cross standing
+    float s1 = cross(q0, p1, p0);
+    float s2 = cross(p1, q1, p0);
+    float s3 = cross(p0, q1, q0);
+    float s4 = cross(q1, p1, q0);
+
+    if (!(s1 * s2 > 0 && s3 * s4 > 0)) return 0;
+
+    // calculate intersection of two lines
+    float s5 = cross(q1, p1, p0);
+    if(fabs(s5 - s1) > EPS){
+        ans.x = (s5 * q0.x - s1 * q1.x) / (s5 - s1);
+        ans.y = (s5 * q0.y - s1 * q1.y) / (s5 - s1);
+    
+    }
+    else{
+        float a0 = p0.y - p1.y, b0 = p1.x - p0.x, c0 = p0.x * p1.y - p1.x * p0.y;
+        float a1 = q0.y - q1.y, b1 = q1.x - q0.x, c1 = q0.x * q1.y - q1.x * q0.y;
+        float D = a0 * b1 - a1 * b0;
+
+        ans.x = (b0 * c1 - b1 * c0) / D;
+        ans.y = (a1 * c0 - a0 * c1) / D;
+    }
+    
+    return 1;
+}
+
+__device__ inline void rotate_around_center(const Point &center, const float angle_cos, const float angle_sin, Point &p){
+    float new_x = (p.x - center.x) * angle_cos + (p.y - center.y) * angle_sin + center.x;
+    float new_y = -(p.x - center.x) * angle_sin + (p.y - center.y) * angle_cos + center.y;
+    p.set(new_x, new_y);
+}
+
+__device__ inline int point_cmp(const Point &a, const Point &b, const Point &center){
+    return atan2(a.y - center.y, a.x - center.x) > atan2(b.y - center.y, b.x - center.x);
+}
+
+__device__ inline float box_overlap(const float *box_a, const float *box_b){
+    // params: box_a (5) [x1, y1, x2, y2, angle]
+    // params: box_b (5) [x1, y1, x2, y2, angle]
+    
+    float a_x1 = box_a[0], a_y1 = box_a[1], a_x2 = box_a[2], a_y2 = box_a[3], a_angle = box_a[4];
+    float b_x1 = box_b[0], b_y1 = box_b[1], b_x2 = box_b[2], b_y2 = box_b[3], b_angle = box_b[4];
+
+    Point center_a((a_x1 + a_x2) / 2, (a_y1 + a_y2) / 2);
+    Point center_b((b_x1 + b_x2) / 2, (b_y1 + b_y2) / 2);
+#ifdef DEBUG
+    printf("a: (%.3f, %.3f, %.3f, %.3f, %.3f), b: (%.3f, %.3f, %.3f, %.3f, %.3f)\n", a_x1, a_y1, a_x2, a_y2, a_angle,
+           b_x1, b_y1, b_x2, b_y2, b_angle);
+    printf("center a: (%.3f, %.3f), b: (%.3f, %.3f)\n", center_a.x, center_a.y, center_b.x, center_b.y);
+#endif
+
+    Point box_a_corners[5];
+    box_a_corners[0].set(a_x1, a_y1);
+    box_a_corners[1].set(a_x2, a_y1);
+    box_a_corners[2].set(a_x2, a_y2);
+    box_a_corners[3].set(a_x1, a_y2);
+
+    Point box_b_corners[5];
+    box_b_corners[0].set(b_x1, b_y1);
+    box_b_corners[1].set(b_x2, b_y1);
+    box_b_corners[2].set(b_x2, b_y2);
+    box_b_corners[3].set(b_x1, b_y2);
+
+    // get oriented corners 
+    float a_angle_cos = cos(a_angle), a_angle_sin = sin(a_angle);
+    float b_angle_cos = cos(b_angle), b_angle_sin = sin(b_angle);
+
+    for (int k = 0; k < 4; k++){
+#ifdef DEBUG
+        printf("before corner %d: a(%.3f, %.3f), b(%.3f, %.3f) \n", k, box_a_corners[k].x, box_a_corners[k].y, box_b_corners[k].x, box_b_corners[k].y);
+#endif
+        rotate_around_center(center_a, a_angle_cos, a_angle_sin, box_a_corners[k]);
+        rotate_around_center(center_b, b_angle_cos, b_angle_sin, box_b_corners[k]);
+#ifdef DEBUG
+        printf("corner %d: a(%.3f, %.3f), b(%.3f, %.3f) \n", k, box_a_corners[k].x, box_a_corners[k].y, box_b_corners[k].x, box_b_corners[k].y);
+#endif
+    }
+
+    box_a_corners[4] = box_a_corners[0];
+    box_b_corners[4] = box_b_corners[0];
+
+    // get intersection of lines
+    Point cross_points[16];
+    Point poly_center;
+    int cnt = 0, flag = 0;
+
+    poly_center.set(0, 0);
+    for (int i = 0; i < 4; i++){
+        for (int j = 0; j < 4; j++){
+            flag = intersection(box_a_corners[i + 1], box_a_corners[i], box_b_corners[j + 1], box_b_corners[j], cross_points[cnt]);
+            if (flag){
+                poly_center = poly_center + cross_points[cnt];
+                cnt++;
+            }
+        }
+    }
+
+    // check corners
+    for (int k = 0; k < 4; k++){
+        if (check_in_box2d(box_a, box_b_corners[k])){
+            poly_center = poly_center + box_b_corners[k];
+            cross_points[cnt] = box_b_corners[k];
+            cnt++;
+        }
+        if (check_in_box2d(box_b, box_a_corners[k])){
+            poly_center = poly_center + box_a_corners[k];
+            cross_points[cnt] = box_a_corners[k];
+            cnt++;
+        }
+    }
+
+    poly_center.x /= cnt;
+    poly_center.y /= cnt;
+
+    // sort the points of polygon
+    Point temp;
+    for (int j = 0; j < cnt - 1; j++){
+        for (int i = 0; i < cnt - j - 1; i++){
+            if (point_cmp(cross_points[i], cross_points[i + 1], poly_center)){
+                temp = cross_points[i]; 
+                cross_points[i] = cross_points[i + 1]; 
+                cross_points[i + 1] = temp;
+            }
+        }
+    }
+
+#ifdef DEBUG
+    printf("cnt=%d\n", cnt);
+    for (int i = 0; i < cnt; i++){
+        printf("All cross point %d: (%.3f, %.3f)\n", i, cross_points[i].x, cross_points[i].y);
+    }
+#endif
+
+    // get the overlap areas
+    float area = 0;
+    for (int k = 0; k < cnt - 1; k++){
+        area += cross(cross_points[k] - cross_points[0], cross_points[k + 1] - cross_points[0]);
+    }
+
+    return fabs(area) / 2.0;
+}
+
+__device__ inline float iou_bev(const float *box_a, const float *box_b){
+    // params: box_a (5) [x1, y1, x2, y2, angle]
+    // params: box_b (5) [x1, y1, x2, y2, angle]
+    float sa = (box_a[2] - box_a[0]) * (box_a[3] - box_a[1]);
+    float sb = (box_b[2] - box_b[0]) * (box_b[3] - box_b[1]);
+    float s_overlap = box_overlap(box_a, box_b);
+    return s_overlap / fmaxf(sa + sb - s_overlap, EPS);
+}
+
+__global__ void boxes_overlap_kernel(const int num_a, const float *boxes_a, const int num_b, const float *boxes_b, float *ans_overlap){
+    const int a_idx = blockIdx.y * THREADS_PER_BLOCK + threadIdx.y;
+    const int b_idx = blockIdx.x * THREADS_PER_BLOCK + threadIdx.x;
+    
+    if (a_idx >= num_a || b_idx >= num_b){
+        return;
+    }
+    const float * cur_box_a = boxes_a + a_idx * 5;
+    const float * cur_box_b = boxes_b + b_idx * 5;
+    float s_overlap = box_overlap(cur_box_a, cur_box_b);
+    ans_overlap[a_idx * num_b + b_idx] = s_overlap;
+}
+
+__global__ void boxes_iou_bev_kernel(const int num_a, const float *boxes_a, const int num_b, const float *boxes_b, float *ans_iou){
+    const int a_idx = blockIdx.y * THREADS_PER_BLOCK + threadIdx.y;
+    const int b_idx = blockIdx.x * THREADS_PER_BLOCK + threadIdx.x;
+    
+    if (a_idx >= num_a || b_idx >= num_b){
+        return;
+    }
+
+    const float * cur_box_a = boxes_a + a_idx * 5;
+    const float * cur_box_b = boxes_b + b_idx * 5;
+    float cur_iou_bev = iou_bev(cur_box_a, cur_box_b);
+    ans_iou[a_idx * num_b + b_idx] = cur_iou_bev;
+}
+
+__global__ void nms_kernel(const int boxes_num, const float nms_overlap_thresh,
+                           const float *boxes, unsigned long long *mask){
+    //params: boxes (N, 5) [x1, y1, x2, y2, ry]
+    //params: mask (N, N/THREADS_PER_BLOCK_NMS)
+
+    const int row_start = blockIdx.y;
+    const int col_start = blockIdx.x;
+
+    // if (row_start > col_start) return;
+
+    const int row_size = fminf(boxes_num - row_start * THREADS_PER_BLOCK_NMS, THREADS_PER_BLOCK_NMS);
+    const int col_size = fminf(boxes_num - col_start * THREADS_PER_BLOCK_NMS, THREADS_PER_BLOCK_NMS);
+
+    __shared__ float block_boxes[THREADS_PER_BLOCK_NMS * 5];
+
+    if (threadIdx.x < col_size) {
+        block_boxes[threadIdx.x * 5 + 0] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 0];
+        block_boxes[threadIdx.x * 5 + 1] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 1];
+        block_boxes[threadIdx.x * 5 + 2] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 2];
+        block_boxes[threadIdx.x * 5 + 3] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 3];
+        block_boxes[threadIdx.x * 5 + 4] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 4];
+    }
+    __syncthreads();
+
+    if (threadIdx.x < row_size) {
+        const int cur_box_idx = THREADS_PER_BLOCK_NMS * row_start + threadIdx.x;
+        const float *cur_box = boxes + cur_box_idx * 5;
+
+        int i = 0;
+        unsigned long long t = 0;
+        int start = 0;
+        if (row_start == col_start) {
+          start = threadIdx.x + 1;
+        }
+        for (i = start; i < col_size; i++) {
+            if (iou_bev(cur_box, block_boxes + i * 5) > nms_overlap_thresh){
+                t |= 1ULL << i;
+            }
+        }
+        const int col_blocks = DIVUP(boxes_num, THREADS_PER_BLOCK_NMS);
+        mask[cur_box_idx * col_blocks + col_start] = t;
+    }
+}
+
+
+__device__ inline float iou_normal(float const * const a, float const * const b) {
+    float left = fmaxf(a[0], b[0]), right = fminf(a[2], b[2]);
+    float top = fmaxf(a[1], b[1]), bottom = fminf(a[3], b[3]);
+    float width = fmaxf(right - left, 0.f), height = fmaxf(bottom - top, 0.f);
+    float interS = width * height;
+    float Sa = (a[2] - a[0]) * (a[3] - a[1]);
+    float Sb = (b[2] - b[0]) * (b[3] - b[1]);
+    return interS / fmaxf(Sa + Sb - interS, EPS);
+}
+
+
+__global__ void nms_normal_kernel(const int boxes_num, const float nms_overlap_thresh,
+                           const float *boxes, unsigned long long *mask){
+    //params: boxes (N, 5) [x1, y1, x2, y2, ry]
+    //params: mask (N, N/THREADS_PER_BLOCK_NMS)
+
+    const int row_start = blockIdx.y;
+    const int col_start = blockIdx.x;
+
+    // if (row_start > col_start) return;
+
+    const int row_size = fminf(boxes_num - row_start * THREADS_PER_BLOCK_NMS, THREADS_PER_BLOCK_NMS);
+    const int col_size = fminf(boxes_num - col_start * THREADS_PER_BLOCK_NMS, THREADS_PER_BLOCK_NMS);
+
+    __shared__ float block_boxes[THREADS_PER_BLOCK_NMS * 5];
+
+    if (threadIdx.x < col_size) {
+        block_boxes[threadIdx.x * 5 + 0] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 0];
+        block_boxes[threadIdx.x * 5 + 1] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 1];
+        block_boxes[threadIdx.x * 5 + 2] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 2];
+        block_boxes[threadIdx.x * 5 + 3] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 3];
+        block_boxes[threadIdx.x * 5 + 4] = boxes[(THREADS_PER_BLOCK_NMS * col_start + threadIdx.x) * 5 + 4];
+    }
+    __syncthreads();
+
+    if (threadIdx.x < row_size) {
+        const int cur_box_idx = THREADS_PER_BLOCK_NMS * row_start + threadIdx.x;
+        const float *cur_box = boxes + cur_box_idx * 5;
+
+        int i = 0;
+        unsigned long long t = 0;
+        int start = 0;
+        if (row_start == col_start) {
+          start = threadIdx.x + 1;
+        }
+        for (i = start; i < col_size; i++) {
+            if (iou_normal(cur_box, block_boxes + i * 5) > nms_overlap_thresh){
+                t |= 1ULL << i;
+            }
+        }
+        const int col_blocks = DIVUP(boxes_num, THREADS_PER_BLOCK_NMS);
+        mask[cur_box_idx * col_blocks + col_start] = t;
+    }
+}
+
+
+
+
+
+void boxesoverlapLauncher(const int num_a, const float *boxes_a, const int num_b, const float *boxes_b, float *ans_overlap){
+
+    dim3 blocks(DIVUP(num_b, THREADS_PER_BLOCK), DIVUP(num_a, THREADS_PER_BLOCK));  // blockIdx.x(col), blockIdx.y(row)
+    dim3 threads(THREADS_PER_BLOCK, THREADS_PER_BLOCK);
+    
+    boxes_overlap_kernel<<<blocks, threads>>>(num_a, boxes_a, num_b, boxes_b, ans_overlap);
+#ifdef DEBUG
+    cudaDeviceSynchronize();  // for using printf in kernel function
+#endif
+}
+
+void boxesioubevLauncher(const int num_a, const float *boxes_a, const int num_b, const float *boxes_b, float *ans_iou){
+
+    dim3 blocks(DIVUP(num_b, THREADS_PER_BLOCK), DIVUP(num_a, THREADS_PER_BLOCK));  // blockIdx.x(col), blockIdx.y(row)
+    dim3 threads(THREADS_PER_BLOCK, THREADS_PER_BLOCK);
+    
+    boxes_iou_bev_kernel<<<blocks, threads>>>(num_a, boxes_a, num_b, boxes_b, ans_iou);
+}
+
+
+void nmsLauncher(const float *boxes, unsigned long long * mask, int boxes_num, float nms_overlap_thresh){
+    dim3 blocks(DIVUP(boxes_num, THREADS_PER_BLOCK_NMS),
+                DIVUP(boxes_num, THREADS_PER_BLOCK_NMS));
+    dim3 threads(THREADS_PER_BLOCK_NMS);
+    nms_kernel<<<blocks, threads>>>(boxes_num, nms_overlap_thresh, boxes, mask);
+}
+
+
+void nmsNormalLauncher(const float *boxes, unsigned long long * mask, int boxes_num, float nms_overlap_thresh){
+    dim3 blocks(DIVUP(boxes_num, THREADS_PER_BLOCK_NMS),
+                DIVUP(boxes_num, THREADS_PER_BLOCK_NMS));
+    dim3 threads(THREADS_PER_BLOCK_NMS);
+    nms_normal_kernel<<<blocks, threads>>>(boxes_num, nms_overlap_thresh, boxes, mask);
+}
diff --git a/visualDet3D/networks/pipelines/testers.py b/visualDet3D/networks/pipelines/testers.py
index 38fb4fa..efa3925 100644
--- a/visualDet3D/networks/pipelines/testers.py
+++ b/visualDet3D/networks/pipelines/testers.py
@@ -27,3 +27,16 @@ def test_mono_detection(data, module:nn.Module,
 
     return scores, bbox, obj_types
 
+@PIPELINE_DICT.register_module
+@torch.no_grad()
+def test_stereo_detection(data, module:nn.Module,
+                     writer:SummaryWriter, 
+                     loss_logger:LossLogger=None, 
+                     global_step:int=None, 
+                     cfg:EasyDict=None) -> Tuple[torch.Tensor, torch.Tensor, List[str]]:
+    left_images, right_images, P2, P3 = data[0], data[1], data[2], data[3]
+
+    scores, bbox, obj_index = module([left_images.cuda().float().contiguous(), right_images.cuda().float().contiguous(), torch.tensor(P2).cuda().float(), torch.tensor(P3).cuda().float()])
+    obj_types = [cfg.obj_types[i.item()] for i in obj_index]
+
+    return scores, bbox, obj_types
\ No newline at end of file
diff --git a/visualDet3D/networks/pipelines/trainers.py b/visualDet3D/networks/pipelines/trainers.py
index 7ddba77..7b9eb3c 100644
--- a/visualDet3D/networks/pipelines/trainers.py
+++ b/visualDet3D/networks/pipelines/trainers.py
@@ -19,6 +19,7 @@ def train_mono_detection(data, module:nn.Module,
                      writer:SummaryWriter=None, 
                      loss_logger:LossLogger=None, 
                      global_step:int=None, 
+                     epoch_num:int=None,
                      cfg:EasyDict=EasyDict()):
     optimizer.zero_grad()
     # load data
@@ -58,6 +59,7 @@ def train_mono_depth(data, module:nn.Module,
                      writer:SummaryWriter=None, 
                      loss_logger:LossLogger=None, 
                      global_step:int=None, 
+                     epoch_num:int=None,
                      cfg:EasyDict=EasyDict()):
     optimizer.zero_grad()
     image, K, gts = data
@@ -78,3 +80,82 @@ def train_mono_depth(data, module:nn.Module,
     torch.nn.utils.clip_grad_norm_(module.parameters(), cfg.optimizer.clipped_gradient_norm)
 
     optimizer.step()
+
+@PIPELINE_DICT.register_module
+def train_stereo_detection(data, module:nn.Module,
+                     optimizer:optim.Optimizer,
+                     writer:SummaryWriter=None, 
+                     loss_logger:LossLogger=None, 
+                     global_step:int=None,
+                     epoch_num:int=None,
+                     cfg:EasyDict=EasyDict()):
+    optimizer.zero_grad()
+    left_images, right_images, P2, P3, labels, bbox2d, bbox_3d, disparity = data
+
+    # create compound array of annotation
+    max_length = np.max([len(label) for label in labels])
+    if max_length == 0:
+       return
+    annotation = compound_annotation(labels, max_length, bbox2d, bbox_3d, cfg.obj_types) #np.arraym, [batch, max_length, 4 + 1 + 7]
+
+    # Feed to the network
+    classification_loss, regression_loss, loss_dict = module(
+            [left_images.cuda().float().contiguous(), right_images.cuda().float().contiguous(),
+             left_images.new(annotation).cuda(),
+             P2.cuda(), P3.cuda(),
+             disparity.cuda().contiguous()]
+        )
+
+    classification_loss = classification_loss.mean()
+    regression_loss = regression_loss.mean()
+
+    if not loss_logger is None:
+        # Record loss in a average meter
+        loss_logger.update(loss_dict)
+    del loss_dict
+
+    if not optimizer is None:
+        loss = classification_loss + regression_loss
+
+    if bool(loss == 0):
+        del loss, loss_dict
+        return
+    loss.backward()
+    # clip loss norm
+    torch.nn.utils.clip_grad_norm_(module.parameters(), cfg.optimizer.clipped_gradient_norm)
+
+    optimizer.step()
+    optimizer.zero_grad()
+
+@PIPELINE_DICT.register_module
+def train_rtm3d(data, module:nn.Module,
+                     optimizer:optim.Optimizer,
+                     writer:SummaryWriter=None, 
+                     loss_logger:LossLogger=None, 
+                     global_step:int=None,
+                     epoch_num:int=None,
+                     cfg:EasyDict=EasyDict()):
+    optimizer.zero_grad()
+    image, K, gts = data
+    #outs = data
+    
+    for key in gts:
+        gts[key] = gts[key].cuda()
+    
+    # Feed to the network
+    loss, loss_dict = module(
+            [image.cuda().float().contiguous(), gts, dict(P2=image.new(K).cuda().float(), epoch=epoch_num)]
+        )
+
+    
+    if not loss_logger is None and loss > 0:
+        # Record loss in a average meter
+        loss_logger.update(loss_dict)
+
+    if bool(loss == 0):
+        return
+    loss.mean().backward()
+    # clip loss norm
+    if 'clipped_gradient_norm' in cfg.optimizer:
+        torch.nn.utils.clip_grad_norm_(module.parameters(), cfg.optimizer.clipped_gradient_norm)
+    optimizer.step()
diff --git a/visualDet3D/networks/utils/rtm3d_utils.py b/visualDet3D/networks/utils/rtm3d_utils.py
new file mode 100644
index 0000000..bcdb1b6
--- /dev/null
+++ b/visualDet3D/networks/utils/rtm3d_utils.py
@@ -0,0 +1,400 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from visualDet3D.networks.lib.ops.iou3d.iou3d import boxes_iou3d_gpu
+
+def compute_res_loss(output, target):
+    return F.smooth_l1_loss(output, target, reduction='elementwise_mean')
+
+def compute_bin_loss(output, target, mask):
+    mask = mask.expand_as(output)
+    output = output * mask.float()
+    return F.cross_entropy(output, target, reduction='elementwise_mean')
+
+def compute_rot_loss(output, target_bin, target_res, mask):
+    # output: (B, 128, 8) [bin1_cls[0], bin1_cls[1], bin1_sin, bin1_cos,
+    #                 bin2_cls[0], bin2_cls[1], bin2_sin, bin2_cos]
+    # target_bin: (B, 128, 2) [bin1_cls, bin2_cls]
+    # target_res: (B, 128, 2) [bin1_res, bin2_res]
+    # mask: (B, 128, 1)
+    # import pdb; pdb.set_trace()
+    output = output.view(-1, 8)
+    target_bin = target_bin.view(-1, 2)
+    target_res = target_res.view(-1, 2)
+    mask = mask.view(-1, 1)
+    loss_bin1 = compute_bin_loss(output[:, 0:2], target_bin[:, 0], mask)
+    loss_bin2 = compute_bin_loss(output[:, 4:6], target_bin[:, 1], mask)
+    loss_res = torch.zeros_like(loss_bin1)
+    if target_bin[:, 0].nonzero().shape[0] > 0:
+        idx1 = target_bin[:, 0].nonzero()[:, 0]
+        valid_output1 = torch.index_select(output, 0, idx1.long())
+        valid_target_res1 = torch.index_select(target_res, 0, idx1.long())
+        loss_sin1 = compute_res_loss(
+            valid_output1[:, 2], torch.sin(valid_target_res1[:, 0]))
+        loss_cos1 = compute_res_loss(
+            valid_output1[:, 3], torch.cos(valid_target_res1[:, 0]))
+        loss_res += loss_sin1 + loss_cos1
+    if target_bin[:, 1].nonzero().shape[0] > 0:
+        idx2 = target_bin[:, 1].nonzero()[:, 0]
+        valid_output2 = torch.index_select(output, 0, idx2.long())
+        valid_target_res2 = torch.index_select(target_res, 0, idx2.long())
+        loss_sin2 = compute_res_loss(
+            valid_output2[:, 6], torch.sin(valid_target_res2[:, 1]))
+        loss_cos2 = compute_res_loss(
+            valid_output2[:, 7], torch.cos(valid_target_res2[:, 1]))
+        loss_res += loss_sin2 + loss_cos2
+    return loss_bin1 + loss_bin2 + loss_res
+
+
+def gaussian_radius(det_size, min_overlap=0.7):
+    height, width = det_size
+
+    a1  = 1
+    b1  = (height + width)
+    c1  = width * height * (1 - min_overlap) / (1 + min_overlap)
+    sq1 = np.sqrt(b1 ** 2 - 4 * a1 * c1)
+    r1  = (b1 + sq1) / 2
+
+    a2  = 4
+    b2  = 2 * (height + width)
+    c2  = (1 - min_overlap) * width * height
+    sq2 = np.sqrt(b2 ** 2 - 4 * a2 * c2)
+    r2  = (b2 + sq2) / 2
+
+    a3  = 4 * min_overlap
+    b3  = -2 * min_overlap * (height + width)
+    c3  = (min_overlap - 1) * width * height
+    sq3 = np.sqrt(b3 ** 2 - 4 * a3 * c3)
+    r3  = (b3 + sq3) / 2
+    return min(r1, r2, r3)
+
+def compute_radius(det_size, min_overlap=0.7):
+    height, width = det_size[0], det_size[1]
+
+    a2 = 4
+    b2 = 2 * (height + width)
+    c2 = (1 - min_overlap) * width * height
+    sq2 = np.sqrt(b2 ** 2 - 4 * a2 * c2)
+    r2 = (b2 - sq2) / (2 * a2)
+
+    return r2
+
+def gaussian2D(shape, sigma=1):
+    m, n = [(ss - 1.) / 2. for ss in shape]
+    y, x = np.ogrid[-m:m + 1, -n:n + 1]
+    h = np.exp(-(x * x + y * y) / (2 * sigma * sigma))
+    h[h < np.finfo(h.dtype).eps * h.max()] = 0
+
+    return h
+
+def gen_hm_radius(heatmap, center, radius, k=1):
+    diameter = 2 * radius + 1
+    gaussian = gaussian2D((diameter, diameter), sigma=diameter / 6)
+
+    x, y = int(center[0]), int(center[1])
+
+    height, width = heatmap.shape[0:2]
+
+    left, right = min(x, radius), min(width - x, radius + 1)
+    top, bottom = min(y, radius), min(height - y, radius + 1)
+
+    masked_heatmap = heatmap[y - top:y + bottom, x - left:x + right]
+    masked_gaussian = gaussian[radius - top:radius + bottom, radius - left:radius + right]
+    if min(masked_gaussian.shape) > 0 and min(masked_heatmap.shape) > 0:  # TODO debug
+        np.maximum(masked_heatmap, masked_gaussian * k, out=masked_heatmap)
+
+    return heatmap
+
+def project_to_image(pts_3d, P):
+    # pts_3d: n x 3
+    # P: 3 x 4
+    # return: n x 2
+    pts_3d_homo = np.concatenate([pts_3d, np.ones((pts_3d.shape[0], 1), dtype=np.float32)], axis=1)
+    pts_2d = np.dot(P, pts_3d_homo.transpose(1, 0)).transpose(1, 0)
+    pts_2d = pts_2d[:, :2] / pts_2d[:, 2:]
+
+    return pts_2d.astype(np.int)
+
+
+def _nms(heat, kernel=3):
+    pad = (kernel - 1) // 2
+    hmax = F.max_pool2d(heat, (kernel, kernel), stride=1, padding=pad)
+    keep = (hmax == heat).float()
+
+    return heat * keep
+
+
+def _gather_feat(feat, ind, mask=None):
+    dim = feat.size(2)
+    ind = ind.unsqueeze(2).expand(ind.size(0), ind.size(1), dim)
+    feat = feat.gather(1, ind)
+    if mask is not None:
+        mask = mask.unsqueeze(2).expand_as(feat)
+        feat = feat[mask]
+        feat = feat.view(-1, dim)
+    return feat
+
+
+def _transpose_and_gather_feat(feat, ind):
+    feat = feat.permute(0, 2, 3, 1).contiguous()
+    feat = feat.view(feat.size(0), -1, feat.size(3))
+    feat = _gather_feat(feat, ind)
+    return feat
+
+def _topk(scores, K=40):
+    batch, cat, height, width = scores.size()
+
+    topk_scores, topk_inds = torch.topk(scores.view(batch, cat, -1), K)
+
+    topk_inds = topk_inds % (height * width)
+    topk_ys = (topk_inds / width).int().float()
+    topk_xs = (topk_inds % width).int().float()
+
+    topk_score, topk_ind = torch.topk(topk_scores.view(batch, -1), K)
+    topk_clses = (topk_ind / K).int()
+    topk_inds = _gather_feat(topk_inds.view(batch, -1, 1), topk_ind).view(batch, K)
+    topk_ys = _gather_feat(topk_ys.view(batch, -1, 1), topk_ind).view(batch, K)
+    topk_xs = _gather_feat(topk_xs.view(batch, -1, 1), topk_ind).view(batch, K)
+
+    return topk_score, topk_inds, topk_clses, topk_ys, topk_xs
+
+
+def _topk_channel(scores, K=40):
+    batch, cat, height, width = scores.size()
+
+    topk_scores, topk_inds = torch.topk(scores.view(batch, cat, -1), K)
+
+    topk_inds = topk_inds % (height * width)
+    topk_ys = (topk_inds / width).int().float()
+    topk_xs = (topk_inds % width).int().float()
+
+    return topk_scores, topk_inds, topk_ys, topk_xs
+
+class Position_loss(nn.Module):
+    def __init__(self, output_w):
+        super(Position_loss, self).__init__()
+
+        const = torch.Tensor(
+            [[-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1],
+             [-1, 0], [0, -1], [-1, 0], [0, -1]]) #, [-1, 0], [0, -1]])
+        self.register_buffer('const', const.unsqueeze(0).unsqueeze(0)) # b,c,2
+        self.output_w = output_w
+
+        self.num_joints = 9
+
+    def forward(self, output, batch, calib):
+        dim = _transpose_and_gather_feat(output['dim'], batch['ind'])
+        rot = _transpose_and_gather_feat(output['rot'], batch['ind'])
+        prob = _transpose_and_gather_feat(output['prob'], batch['ind'])
+        kps = _transpose_and_gather_feat(output['hps'], batch['ind'])
+        rot=rot.detach()### solving............
+        
+        b = dim.size(0)
+        c = dim.size(1)
+
+        mask = batch['hps_mask']
+        mask = mask.float()
+        
+        cys = (batch['ind'] / self.output_w).int().float()
+        cxs = (batch['ind'] % self.output_w).int().float()
+        kps[..., ::2] = kps[..., ::2] + cxs.view(b, c, 1).expand(b, c, self.num_joints)
+        kps[..., 1::2] = kps[..., 1::2] + cys.view(b, c, 1).expand(b, c, self.num_joints)
+
+        meta = dict(calib=calib)
+        const = torch.Tensor(
+                [[-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1], [-1, 0], [0, -1],
+                [-1, 0], [0, -1], [-1, 0], [0, -1]]).unsqueeze(0).unsqueeze(0).cuda()
+        pinv,rot_y,alpha_pre, _ = gen_position(kps.reshape(b, kps.shape[1], 9, 2) * 4, dim, rot, meta, const)
+
+
+        kps_mask = mask
+
+        mask2 = torch.sum(kps_mask, dim=2)
+        loss_mask = mask2 > 15
+        
+
+        pinv = pinv.view(b, c, 3, 1).squeeze(3)
+
+        dim_mask = dim<0
+        dim = torch.clamp(dim, 0 , 10)
+        dim_mask_score_mask = torch.sum(dim_mask, dim=2)
+        dim_mask_score_mask = 1 - (dim_mask_score_mask > 0).int()
+        dim_mask_score_mask = dim_mask_score_mask.float()
+        
+        off_set = (calib[:, 0, 3]) / calib[:, 0, 0] # [B, 1]
+        
+        box_pred = torch.cat((pinv, dim, rot_y), dim=2).detach()
+        loss = (pinv - batch['location'])
+        loss_norm = torch.norm(loss, p=2, dim=2)
+        loss_mask = loss_mask.float()
+        loss = loss_norm * loss_mask
+        mask_num = (loss_mask != 0).sum()
+        
+        loss = loss.sum() / (mask_num + 1)
+        dim_gt = batch['dim'].clone()  # b,c,3
+        location_gt = batch['location']
+        ori_gt = batch['ori']
+        dim_gt[dim_mask] = 0
+        
+        
+
+        gt_box = torch.cat((location_gt, dim_gt, ori_gt), dim=2)
+        box_pred = box_pred.view(b * c, -1)
+        gt_box = gt_box.view(b * c, -1)
+
+        box_score = boxes_iou3d_gpu(box_pred, gt_box)
+        box_score = torch.diag(box_score).view(b, c)
+        prob = prob.squeeze(2)
+        box_score = box_score * loss_mask * dim_mask_score_mask
+        loss_prob = F.binary_cross_entropy_with_logits(prob, box_score.detach(), reduce=False)
+        loss_prob = loss_prob * loss_mask * dim_mask_score_mask
+        loss_prob = torch.sum(loss_prob, dim=1)
+        loss_prob = loss_prob.sum() / (mask_num + 1)
+        box_score = box_score * loss_mask
+
+        box_score = box_score.sum() / (mask_num + 1e-3)
+        return loss, loss_prob, box_score
+def gen_position(kps,dim,rot,meta,const):
+    """ Decode rotation and generate position. Notice that
+    unlike the official implementation, we do not transform back to pre-augmentation images.
+    And we also compenstate for the offset in camera in this function.
+
+    We also change the order of the keypoints to the default projection order in this repo,
+    therefore the way we construct least-square matrix also changed.
+
+    Args:
+        kps [torch.Tensor]: [B, C, 9, 2], keypoints relative offset from the center_int in augmented scale 4. network prediction. 
+        dim [torch.Tensor]: [B, C, 3], width/height/length, the order is different.
+        rot [torch.Tensor]: [B, C, 8], rotation prediction from the network.
+        meta [Dict]: meta['calib'].shape = [B, 3, 4] -> calibration matrix for augmented images.
+        const [torch.Tensor]: const.shape = [1, 1, 16], constant helping parameter used in optimization.
+    Returns:
+        position [torch.Tensor]: [B, C, 3], 3D position.
+        rot_y [torch.Tensor]: [B, C, 1], 3D rotation theta. Decoded.
+        alpna_pre [torch.Tensor]: [B, C, 1], observation angle alpha decoded. The typo is consistent with the official typo.
+        kps [torch.Tensor]: [B, C, 18], basically same with the input (not transformed here).
+    """
+    b=kps.size(0)
+    c=kps.size(1)
+    calib=meta['calib']
+    off_set = (calib[:, 0, 3]) / calib[:, 0, 0] # [B, 1]
+
+    #opinv = opinv.unsqueeze(1)
+    #opinv = opinv.expand(b, c, -1, -1).contiguous().view(-1, 2, 3).float()
+    kps = kps.view(b, c, -1, 2).permute(0, 1, 3, 2)
+    #hom = torch.ones(b, c, 1, 9).cuda()
+    #kps = torch.cat((kps, hom), dim=2).view(-1, 3, 9)
+    #kps = torch.bmm(opinv, kps).view(b, c, 2, 9)
+    kps = kps.permute(0, 1, 3, 2).contiguous().view(b, c, -1)  # 16.32,18
+    si = torch.zeros_like(kps[:, :, 0:1]) + calib[:, 0:1, 0:1]
+
+    alpha_idx = rot[:, :, 1] > rot[:, :, 5]
+    alpha_idx = alpha_idx.float()
+    alpha1 = torch.atan(rot[:, :, 2] / rot[:, :, 3]) + (-0.5 * np.pi)
+    alpha2 = torch.atan(rot[:, :, 6] / rot[:, :, 7]) + (0.5 * np.pi)
+    alpna_pre = alpha1 * alpha_idx + alpha2 * (1 - alpha_idx)
+    alpna_pre = alpna_pre.unsqueeze(2)
+
+    # alpna_pre=rot_gt
+
+    rot_y = alpna_pre + torch.atan2(kps[:, :, 16:17] - calib[:, 0:1, 2:3], si)
+    rot_y[rot_y > np.pi] = rot_y[rot_y > np.pi] - 2 * np.pi
+    rot_y[rot_y < - np.pi] = rot_y[rot_y < - np.pi] + 2 * np.pi
+
+    calib = calib.unsqueeze(1)
+    calib = calib.expand(b, c, -1, -1).contiguous()
+    kpoint = kps[:, :, :16]
+    f = calib[:, :, 0, 0].unsqueeze(2)
+    f = f.expand_as(kpoint)
+    cx, cy = calib[:, :, 0, 2].unsqueeze(2), calib[:, :, 1, 2].unsqueeze(2)
+    cxy = torch.cat((cx, cy), dim=2)
+    cxy = cxy.repeat(1, 1, 8)  # b,c,16
+    kp_norm = (kpoint - cxy) / f
+
+    l = dim[:, :, 2:3]
+    h = dim[:, :, 1:2]
+    w = dim[:, :, 0:1]
+    cosori = torch.cos(rot_y)
+    sinori = torch.sin(rot_y)
+
+    B = torch.zeros_like(kpoint)
+    C = torch.zeros_like(kpoint)
+
+    kp = kp_norm.unsqueeze(3)  # b,c,16,1
+    const = const.expand(b, c, -1, -1)
+    A = torch.cat([const, kp], dim=3)
+
+    ## The order of the point has been changed, so should the matrixes
+    # B[:, :, 0:1] = l * 0.5 * cosori + w * 0.5 * sinori
+    # B[:, :, 1:2] = h * 0.5
+    # B[:, :, 2:3] = l * 0.5 * cosori - w * 0.5 * sinori
+    # B[:, :, 3:4] = h * 0.5
+    # B[:, :, 4:5] = -l * 0.5 * cosori - w * 0.5 * sinori
+    # B[:, :, 5:6] = h * 0.5
+    # B[:, :, 6:7] = -l * 0.5 * cosori + w * 0.5 * sinori
+    # B[:, :, 7:8] = h * 0.5
+    # B[:, :, 8:9] = l * 0.5 * cosori + w * 0.5 * sinori
+    # B[:, :, 9:10] = -h * 0.5
+    # B[:, :, 10:11] = l * 0.5 * cosori - w * 0.5 * sinori
+    # B[:, :, 11:12] = -h * 0.5
+    # B[:, :, 12:13] = -l * 0.5 * cosori - w * 0.5 * sinori
+    # B[:, :, 13:14] = -h * 0.5
+    # B[:, :, 14:15] = -l * 0.5 * cosori + w * 0.5 * sinori
+    # B[:, :, 15:16] = -h * 0.5
+
+    B[:, :, 0:1]    = - l * 0.5 * cosori - w * 0.5 * sinori
+    B[:, :, 1:2]    = - h * 0.5
+    B[:, :, 2:3]    = - l * 0.5 * cosori + w * 0.5 * sinori
+    B[:, :, 3:4]    = - h * 0.5
+    B[:, :, 4:5]    = - l * 0.5 * cosori + w * 0.5 * sinori
+    B[:, :, 5:6]    =   h * 0.5
+    B[:, :, 6:7]    =   l * 0.5 * cosori + w * 0.5 * sinori
+    B[:, :, 7:8]    =   h * 0.5
+    B[:, :, 8:9]    =   l * 0.5 * cosori + w * 0.5 * sinori
+    B[:, :, 9:10]   = - h * 0.5
+    B[:, :, 10:11]  =   l * 0.5 * cosori - w * 0.5 * sinori
+    B[:, :, 11:12]  = - h * 0.5
+    B[:, :, 12:13]  =   l * 0.5 * cosori - w * 0.5 * sinori
+    B[:, :, 13:14]  =   h * 0.5
+    B[:, :, 14:15]  = - l * 0.5 * cosori - w * 0.5 * sinori
+    B[:, :, 15:16]  =   h * 0.5
+
+    C[:, :, 0:1]    =   l * 0.5 * sinori - w * 0.5 * cosori # - l * 0.5 * cosori - w * 0.5 * sinori
+    C[:, :, 1:2]    =   l * 0.5 * sinori - w * 0.5 * cosori
+    C[:, :, 2:3]    =   l * 0.5 * sinori + w * 0.5 * cosori # - l * 0.5 * cosori + w * 0.5 * sinori
+    C[:, :, 3:4]    =   l * 0.5 * sinori + w * 0.5 * cosori
+    C[:, :, 4:5]    =   l * 0.5 * sinori + w * 0.5 * cosori # - l * 0.5 * cosori + w * 0.5 * sinori
+    C[:, :, 5:6]    =   l * 0.5 * sinori + w * 0.5 * cosori
+    C[:, :, 6:7]    = - l * 0.5 * sinori + w * 0.5 * cosori # l * 0.5 * cosori + w * 0.5 * sinori
+    C[:, :, 7:8]    = - l * 0.5 * sinori + w * 0.5 * cosori
+    C[:, :, 8:9]    = - l * 0.5 * sinori + w * 0.5 * cosori # l * 0.5 * cosori + w * 0.5 * sinori
+    C[:, :, 9:10]   = - l * 0.5 * sinori + w * 0.5 * cosori
+    C[:, :, 10:11]  = - l * 0.5 * sinori - w * 0.5 * cosori # l * 0.5 * cosori - w * 0.5 * sinori
+    C[:, :, 11:12]  = - l * 0.5 * sinori - w * 0.5 * cosori
+    C[:, :, 12:13]  = - l * 0.5 * sinori - w * 0.5 * cosori #  l * 0.5 * cosori - w * 0.5 * sinori
+    C[:, :, 13:14]  = - l * 0.5 * sinori - w * 0.5 * cosori
+    C[:, :, 14:15]  =   l * 0.5 * sinori - w * 0.5 * cosori # - l * 0.5 * cosori - w * 0.5 * sinori
+    C[:, :, 15:16]  =   l * 0.5 * sinori - w * 0.5 * cosori
+
+    B = B - kp_norm * C
+
+    # A=A*kps_mask1
+    A = A.double() # For Numerical Stability. We add this line after repeated debugging.
+    AT = A.permute(0, 1, 3, 2)
+    AT = AT.view(b * c, 3, 16)
+    A = A.view(b * c, 16, 3)
+    B = B.view(b * c, 16, 1).float()
+    # mask = mask.unsqueeze(2)
+
+    pinv = torch.bmm(AT, A)
+    pinv = torch.inverse(pinv + torch.randn_like(pinv) * 1e-8)  # b*c 3 3
+    pinv = torch.bmm(pinv, AT).float() # Change back to Float
+    pinv = torch.bmm(pinv, B)
+    pinv = pinv.view(b, c, 3, 1).squeeze(3)
+
+    #pinv[:, :, 1] = pinv[:, :, 1] + dim[:, :, 0] / 2 ## No need to transfer to bottom point. We always use the center point unless in writing to KITTI
+    pinv[:, :, 0] -= off_set.unsqueeze(1)
+        
+    return pinv,rot_y,alpna_pre, kps
diff --git a/visualDet3D/networks/utils/utils.py b/visualDet3D/networks/utils/utils.py
index a5e8e7c..b61b186 100644
--- a/visualDet3D/networks/utils/utils.py
+++ b/visualDet3D/networks/utils/utils.py
@@ -5,6 +5,7 @@
 import numpy as np
 import cv2
 from functools import wraps
+from visualDet3D.utils.utils import alpha2theta_3d, theta2alpha_3d
 
 
 def get_num_parameters(model):
@@ -224,13 +225,13 @@ def forward(self, bbox_3d, tensor_p2):
                 unnormalize bbox_3d [N, 7] with  x, y, z, w, h, l, alpha
                 tensor_p2: tensor of [3, 4]
             output:
-                [N, 8, 3] with corner point in camera frame
+                [N, 8, 3] with corner point in camera frame # 8 is determined by the shape of self.corner_matrix
                 [N, 8, 3] with corner point in image frame
                 [N, ] thetas
         """
         relative_eight_corners = 0.5 * self.corner_matrix * bbox_3d[:, 3:6].unsqueeze(1)  # [N, 8, 3]
         # [batch, N, ]
-        thetas = bbox_3d[:, 6] + torch.atan2(-bbox_3d[:, 2], bbox_3d[:, 0]) + 0.5 * np.pi
+        thetas = alpha2theta_3d(bbox_3d[..., 6], bbox_3d[..., 0], bbox_3d[..., 2], tensor_p2)
         _cos = torch.cos(thetas).unsqueeze(1)  # [N, 1]
         _sin = torch.sin(thetas).unsqueeze(1)  # [N, 1]
         rotated_corners_x, rotated_corners_z = (
@@ -243,7 +244,7 @@ def forward(self, bbox_3d, tensor_p2):
         abs_corners = rotated_corners + \
             bbox_3d[:, 0:3].unsqueeze(1)  # [N, 8, 3]
         camera_corners = torch.cat([abs_corners,
-            abs_corners.new_ones([abs_corners.shape[0], 8, 1])],
+            abs_corners.new_ones([abs_corners.shape[0], self.corner_matrix.shape[0], 1])],
             dim=-1).unsqueeze(3)  # [N, 8, 4, 1]
         camera_coord = torch.matmul(tensor_p2, camera_corners).squeeze(-1)  # [N, 8, 3]
 
diff --git a/visualDet3D/utils/utils.py b/visualDet3D/utils/utils.py
index e3a087b..ceaafa1 100644
--- a/visualDet3D/utils/utils.py
+++ b/visualDet3D/utils/utils.py
@@ -1,3 +1,4 @@
+import torch
 import numpy as np
 import cv2
 import sys
@@ -26,21 +27,57 @@ def log(self, step):
             name = key + '/' + self.data_split
             self.recorder.add_scalar(name, self.loss_stats[key].avg, step)
 
-def convertAlpha2Rot(alpha, z3d, x3d):
-    
-    ry3d = alpha + np.arctan2(-z3d, x3d) + 0.5 * np.pi
+def convertAlpha2Rot(alpha, cx, P2):
+    cx_p2 = P2[..., 0, 2]
+    fx_p2 = P2[..., 0, 0]
+    ry3d = alpha + np.arctan2(cx - cx_p2, fx_p2)
     ry3d[np.where(ry3d > np.pi)] -= 2 * np.pi
     ry3d[np.where(ry3d <= -np.pi)] += 2 * np.pi
     return ry3d
 
 
-def convertRot2Alpha(ry3d, z3d, x3d):
-
-    alpha = ry3d - np.arctan2(-z3d, x3d) - 0.5 * np.pi
+def convertRot2Alpha(ry3d, cx, P2):
+    cx_p2 = P2[..., 0, 2]
+    fx_p2 = P2[..., 0, 0]
+    alpha = ry3d - np.arctan2(cx - cx_p2, fx_p2)
     alpha[alpha > np.pi] -= 2 * np.pi
     alpha[alpha <= -np.pi] += 2 * np.pi
     return alpha
 
+def alpha2theta_3d(alpha, x, z, P2):
+    """ Convert alpha to theta with 3D position
+    Args:
+        alpha [torch.Tensor/ float or np.ndarray]: size: [...]
+        x     []: size: [...]
+        z     []: size: [...]
+        P2    [torch.Tensor/ np.ndarray]: size: [3, 4]
+    Returns:
+        theta []: size: [...]
+    """
+    offset = P2[0, 3] / P2[0, 0]
+    if isinstance(alpha, torch.Tensor):
+        theta = alpha + torch.atan2(x + offset, z)
+    else:
+        theta = alpha + np.arctan2(x + offset, z)
+    return theta
+
+def theta2alpha_3d(theta, x, z, P2):
+    """ Convert theta to alpha with 3D position
+    Args:
+        theta [torch.Tensor/ float or np.ndarray]: size: [...]
+        x     []: size: [...]
+        z     []: size: [...]
+        P2    [torch.Tensor/ np.ndarray]: size: [3, 4]
+    Returns:
+        alpha []: size: [...]
+    """
+    offset = P2[0, 3] / P2[0, 0]
+    if isinstance(theta, torch.Tensor):
+        alpha = theta - torch.atan2(x + offset, z)
+    else:
+        alpha = theta - np.arctan2(x + offset, z)
+    return alpha
+
 def draw_3D_box(img, corners, color = (255, 255, 0)):
     """
         draw 3D box in image with OpenCV,