Showing preview only (1,557K chars total). Download the full file or copy to clipboard to get everything.
Repository: hailanyi/TED
Branch: master
Commit: c2e4847e3acf
Files: 182
Total size: 1.4 MB
Directory structure:
gitextract_kkhpxbxf/
├── LICENSE
├── README.md
├── data/
│ └── kitti/
│ └── ImageSets/
│ ├── test.txt
│ ├── train.txt
│ └── val.txt
├── pcdet/
│ ├── __init__.py
│ ├── config.py
│ ├── datasets/
│ │ ├── __init__.py
│ │ ├── augmentor/
│ │ │ ├── X_transform.py
│ │ │ ├── augmentor_utils.py
│ │ │ ├── data_augmentor.py
│ │ │ └── database_sampler.py
│ │ ├── dataset.py
│ │ ├── kitti/
│ │ │ ├── kitti_dataset.py
│ │ │ ├── kitti_dataset_mm.py
│ │ │ └── kitti_object_eval_python/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── eval.py
│ │ │ ├── evaluate.py
│ │ │ ├── kitti_common.py
│ │ │ └── rotate_iou.py
│ │ └── processor/
│ │ ├── data_processor.py
│ │ └── point_feature_encoder.py
│ ├── models/
│ │ ├── __init__.py
│ │ ├── backbones_2d/
│ │ │ ├── __init__.py
│ │ │ ├── base_bev_backbone.py
│ │ │ └── map_to_bev/
│ │ │ ├── __init__.py
│ │ │ ├── height_compression.py
│ │ │ └── pointpillar_scatter.py
│ │ ├── backbones_3d/
│ │ │ ├── __init__.py
│ │ │ ├── pfe/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── bev_features_interpolation.py
│ │ │ │ └── voxel_set_abstraction.py
│ │ │ ├── pointnet2_backbone.py
│ │ │ ├── spconv_backbone.py
│ │ │ ├── spconv_unet.py
│ │ │ └── vfe/
│ │ │ ├── __init__.py
│ │ │ ├── mean_vfe.py
│ │ │ ├── pillar_vfe.py
│ │ │ └── vfe_template.py
│ │ ├── dense_heads/
│ │ │ ├── __init__.py
│ │ │ ├── anchor_head_multi.py
│ │ │ ├── anchor_head_single.py
│ │ │ ├── anchor_head_template.py
│ │ │ ├── center_head.py
│ │ │ ├── point_head_box.py
│ │ │ ├── point_head_simple.py
│ │ │ ├── point_head_template.py
│ │ │ ├── point_intra_part_head.py
│ │ │ └── target_assigner/
│ │ │ ├── anchor_generator.py
│ │ │ ├── atss_target_assigner.py
│ │ │ └── axis_aligned_target_assigner.py
│ │ ├── detectors/
│ │ │ ├── __init__.py
│ │ │ ├── detector3d_template.py
│ │ │ └── voxel_rcnn.py
│ │ ├── model_utils/
│ │ │ ├── centernet_utils.py
│ │ │ ├── ctrans.py
│ │ │ └── model_nms_utils.py
│ │ └── roi_heads/
│ │ ├── __init__.py
│ │ ├── roi_head_template.py
│ │ ├── target_assigner/
│ │ │ ├── proposal_target_layer.py
│ │ │ └── proposal_target_layer3.py
│ │ └── ted_head.py
│ ├── ops/
│ │ ├── dcn/
│ │ │ ├── __init__.py
│ │ │ ├── deform_conv.py
│ │ │ ├── setup.py
│ │ │ └── src/
│ │ │ ├── deform_conv_cuda.cpp
│ │ │ ├── deform_conv_cuda_kernel.cu
│ │ │ ├── deform_pool_cuda.cpp
│ │ │ └── deform_pool_cuda_kernel.cu
│ │ ├── iou3d_nms/
│ │ │ ├── iou3d_nms_utils.py
│ │ │ └── src/
│ │ │ ├── iou3d_cpu.cpp
│ │ │ ├── iou3d_cpu.h
│ │ │ ├── iou3d_nms.cpp
│ │ │ ├── iou3d_nms.h
│ │ │ ├── iou3d_nms_api.cpp
│ │ │ └── iou3d_nms_kernel.cu
│ │ ├── pointnet2/
│ │ │ ├── pointnet2_batch/
│ │ │ │ ├── pointnet2_modules.py
│ │ │ │ ├── pointnet2_utils.py
│ │ │ │ └── src/
│ │ │ │ ├── ball_query.cpp
│ │ │ │ ├── ball_query_gpu.cu
│ │ │ │ ├── ball_query_gpu.h
│ │ │ │ ├── cuda_utils.h
│ │ │ │ ├── group_points.cpp
│ │ │ │ ├── group_points_gpu.cu
│ │ │ │ ├── group_points_gpu.h
│ │ │ │ ├── interpolate.cpp
│ │ │ │ ├── interpolate_gpu.cu
│ │ │ │ ├── interpolate_gpu.h
│ │ │ │ ├── pointnet2_api.cpp
│ │ │ │ ├── sampling.cpp
│ │ │ │ ├── sampling_gpu.cu
│ │ │ │ └── sampling_gpu.h
│ │ │ └── pointnet2_stack/
│ │ │ ├── pointnet2_modules.py
│ │ │ ├── pointnet2_utils.py
│ │ │ ├── src/
│ │ │ │ ├── ball_query.cpp
│ │ │ │ ├── ball_query_deform.cpp
│ │ │ │ ├── ball_query_deform_gpu.cu
│ │ │ │ ├── ball_query_deform_gpu.h
│ │ │ │ ├── ball_query_gpu.cu
│ │ │ │ ├── ball_query_gpu.h
│ │ │ │ ├── cuda_utils.h
│ │ │ │ ├── group_points.cpp
│ │ │ │ ├── group_points_gpu.cu
│ │ │ │ ├── group_points_gpu.h
│ │ │ │ ├── interpolate.cpp
│ │ │ │ ├── interpolate_gpu.cu
│ │ │ │ ├── interpolate_gpu.h
│ │ │ │ ├── pointnet2_api.cpp
│ │ │ │ ├── sampling.cpp
│ │ │ │ ├── sampling_gpu.cu
│ │ │ │ ├── sampling_gpu.h
│ │ │ │ ├── vector_pool.cpp
│ │ │ │ ├── vector_pool_gpu.cu
│ │ │ │ ├── vector_pool_gpu.h
│ │ │ │ ├── voxel_query.cpp
│ │ │ │ ├── voxel_query_gpu.cu
│ │ │ │ └── voxel_query_gpu.h
│ │ │ ├── voxel_pool_modules.py
│ │ │ └── voxel_query_utils.py
│ │ ├── roiaware_pool3d/
│ │ │ ├── roiaware_pool3d_utils.py
│ │ │ └── src/
│ │ │ ├── roiaware_pool3d.cpp
│ │ │ └── roiaware_pool3d_kernel.cu
│ │ ├── roipoint_pool3d/
│ │ │ ├── roipoint_pool3d_utils.py
│ │ │ └── src/
│ │ │ ├── roipoint_pool3d.cpp
│ │ │ └── roipoint_pool3d_kernel.cu
│ │ └── votr_ops/
│ │ ├── src/
│ │ │ ├── build_attention_indices.cpp
│ │ │ ├── build_attention_indices_gpu.cu
│ │ │ ├── build_attention_indices_gpu.h
│ │ │ ├── build_mapping.cpp
│ │ │ ├── build_mapping_gpu.cu
│ │ │ ├── build_mapping_gpu.h
│ │ │ ├── group_features.cpp
│ │ │ ├── group_features_gpu.cu
│ │ │ ├── group_features_gpu.h
│ │ │ ├── votr_api.cpp
│ │ │ └── votr_cuda_utils.h
│ │ └── votr_utils.py
│ ├── utils/
│ │ ├── __init__.py
│ │ ├── bbloss.py
│ │ ├── box_coder_utils.py
│ │ ├── box_np_ops.py
│ │ ├── box_utils.py
│ │ ├── calibration_kitti.py
│ │ ├── common_utils.py
│ │ ├── commu_utils.py
│ │ ├── loss_utils.py
│ │ ├── object3d_kitti.py
│ │ ├── odiou_loss.py
│ │ ├── spconv_utils.py
│ │ └── transform_utils.py
│ └── version.py
├── requirements.txt
├── setup.py
└── tools/
├── PENet/
│ ├── CoordConv.py
│ ├── LICENSE
│ ├── basic.py
│ ├── criteria.py
│ ├── dataloaders/
│ │ ├── calib_cam_to_cam.txt
│ │ ├── calibration_kitti.py
│ │ ├── kitti_loader.py
│ │ ├── my_loader.py
│ │ ├── spconv_utils.py
│ │ └── transforms.py
│ ├── helper.py
│ ├── main.py
│ ├── metrics.py
│ ├── model.py
│ └── vis_utils.py
├── cfgs/
│ ├── dataset_configs/
│ │ └── kitti_dataset.yaml
│ └── models/
│ └── kitti/
│ ├── TED-M.yaml
│ └── TED-S.yaml
├── dist_test.sh
├── dist_train.sh
├── eval_utils/
│ └── eval_utils.py
├── test.py
├── train.py
├── train_utils/
│ ├── optimization/
│ │ ├── __init__.py
│ │ ├── fastai_optim.py
│ │ └── learning_schedules_fastai.py
│ └── train_utils.py
└── visual_utils/
└── visualize_utils.py
================================================
FILE CONTENTS
================================================
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: README.md
================================================
# Transformation-Equivariant 3D Object Detection for Autonomous Driving
This is a improved version of [TED](https://arxiv.org/abs/2211.11962) by a multiple refinement design.
This code is mainly based on [OpenPCDet](https://github.com/open-mmlab/OpenPCDet) and [CasA](https://github.com/hailanyi/CasA), some codes are from
[PENet](https://github.com/JUGGHM/PENet_ICRA2021) and [SFD](https://github.com/LittlePey/SFD).
## Detection Framework
The overall detection framework is shown below.
(1) Transformation-equivariant Sparse Convolution (TeSpConv) backbone; (2) Transformation-equivariant Bird Eye View (TeBEV) pooling;
(3) Multi-grid pooling and multi-refinement.
TeSpConv applies shared weights on multiple transformed point clouds to record the transformation-equivariant voxel features.
TeBEV pooling aligns and aggregates the scene-level equivariant features into lightweight representations for proposal generation.
Multi-grid pooling and multi-refinement align and aggregate the instance-level invariant features for proposal refinement.
## Model Zoo
We release two models, which are based on LiDAR-only and multi-modal data respectively. We denoted the two models as TED-S and TED-M respectively.
* All models are trained with 8 V100 GPUs and are available for download.
* The models are trained with train split (3712 samples) of KITTI dataset
* The results are the 3D AP(R40) of Car on the *val* set of KITTI dataset.
* These models are not suitable to directly report results on KITTI test set, please use slightly lower score threshold and train the models on all or 80% training data to achieve a desirable performance on KITTI test set.
| |Modality|GPU memory of training| Easy | Mod. | Hard | download |
|---------------------------------------------|----------:|----------:|:-------:|:-------:|:-------:|:---------:|
| [TED-S](tools/cfgs/models/kitti/TED-S.yaml)|LiDAR only|~12 GB |93.25 |87.99| 86.28| [google](https://drive.google.com/file/d/1hqoj-lV4Cr3m7U3EphdCSjHmhBlekRm8/view?usp=sharing) / [baidu(p91t)](https://pan.baidu.com/s/1ecobwO673ScrGYOHbooGIw) / 36M |
| [TED-M](tools/cfgs/models/kitti/TED-M.yaml)|LiDAR+RGB |~15 GB| 95.62 |89.24 |86.77 | [google](https://drive.google.com/file/d/1hXe1at-LKogTfWorALmq6djjYqhKX7nD/view?usp=sharing) / [baidu(nkr5)](https://pan.baidu.com/s/1FP80452dfM09YtE8DBaicQ) / 65M|
## Getting Started
```
conda create -n spconv2 python=3.9
conda activate spconv2
pip install torch==1.8.1+cu111 torchvision==0.9.1+cu111 torchaudio==0.8.1 -f https://download.pytorch.org/whl/torch_stable.html
pip install numpy==1.19.5 protobuf==3.19.4 scikit-image==0.19.2 waymo-open-dataset-tf-2-5-0 nuscenes-devkit==1.0.5 spconv-cu111 numba scipy pyyaml easydict fire tqdm shapely matplotlib opencv-python addict pyquaternion awscli open3d pandas future pybind11 tensorboardX tensorboard Cython prefetch-generator
```
### Dependency
Our released implementation is tested on.
+ Ubuntu 18.04
+ Python 3.6.9
+ PyTorch 1.8.1
+ Spconv 1.2.1
+ NVIDIA CUDA 11.1
+ 8x Tesla V100 GPUs
We also tested on.
+ Ubuntu 18.04
+ Python 3.9.13
+ PyTorch 1.8.1
+ Spconv 2.1.22 # pip install spconv-cu111
+ NVIDIA CUDA 11.1
+ 2x 3090 GPUs
### Prepare dataset
Please download the official [KITTI 3D object detection](http://www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=3d) dataset and organize the downloaded files as follows (the road planes could be downloaded from [[road plane]](https://drive.google.com/file/d/1d5mq0RXRnvHPVeKx6Q612z0YRO1t2wAp/view?usp=sharing), which are optional for data augmentation in the training):
```
TED
├── data
│ ├── kitti
│ │ │── ImageSets
│ │ │── training
│ │ │ ├──calib & velodyne & label_2 & image_2 & (optional: planes)
│ │ │── testing
│ │ │ ├──calib & velodyne & image_2
├── pcdet
├── tools
```
You need creat a 'velodyne_depth' dataset to run our multimodal detector:
You can download our preprocessed data from [google (13GB)](https://drive.google.com/file/d/1xki9v_zsQMM8vMVNo0ENi1Mh_GNMjHUg/view?usp=sharing), [baidu (a20o)](https://pan.baidu.com/s/1OH4KIVoSSH7ea3-3CqkZRQ), or generate the data by yourself:
* [Install this project](#installation).
* Download the PENet depth completion model [here (500M)](https://drive.google.com/file/d/1RDdKlKJcas-G5OA49x8OoqcUDiYYZgeM/view?usp=sharing) and put it into ```tools/PENet```.
* Then run the following code to generate RGB pseudo points.
```
cd tools/PENet
python3 main.py --detpath [your path like: ../../data/kitti/training]
```
After 'velodyne_depth' generation, run following command to creat dataset infos:
```
cd ../..
python3 -m pcdet.datasets.kitti.kitti_dataset create_kitti_infos tools/cfgs/dataset_configs/kitti_dataset.yaml
python3 -m pcdet.datasets.kitti.kitti_dataset_mm create_kitti_infos tools/cfgs/dataset_configs/kitti_dataset.yaml
```
Anyway, the data structure should be:
```
TED
├── data
│ ├── kitti
│ │ │── ImageSets
│ │ │── training
│ │ │ ├──calib & velodyne & label_2 & image_2 & (optional: planes) & velodyne_depth
│ │ │── testing
│ │ │ ├──calib & velodyne & image_2 & velodyne_depth
│ │ │── gt_database
│ │ │── gt_database_mm
│ │ │── kitti_dbinfos_train_mm.pkl
│ │ │── kitti_dbinfos_train.pkl
│ │ │── kitti_infos_test.pkl
│ │ │── kitti_infos_train.pkl
│ │ │── kitti_infos_trainval.pkl
│ │ │── kitti_infos_val.pkl
├── pcdet
├── tools
```
### Installation
```
git clone https://github.com/hailanyi/TED.git
cd TED
python3 setup.py develop
```
### Training
Single GPU train:
```
cd tools
python3 train.py --cfg_file ${CONFIG_FILE}
```
For example, if you train the TED-S model:
```
cd tools
python3 train.py --cfg_file cfgs/models/kitti/TED-S.yaml
```
Multiple GPU train:
You can modify the gpu number in the dist_train.sh and run
```
cd tools
sh dist_train.sh
```
The log infos are saved into log.txt
You can run ```cat log.txt``` to view the training process.
### Evaluation
```
cd tools
python3 test.py --cfg_file ${CONFIG_FILE} --batch_size ${BATCH_SIZE} --ckpt ${CKPT}
```
For example, if you test the TED-S model:
```
cd tools
python3 test.py --cfg_file cfgs/models/kitti/TED-S.yaml --ckpt TED-S.pth
```
Multiple GPU test: you need modify the gpu number in the dist_test.sh and run
```
sh dist_test.sh
```
The log infos are saved into log-test.txt
You can run ```cat log-test.txt``` to view the test results.
## License
This code is released under the [Apache 2.0 license](LICENSE).
## Acknowledgement
[CasA](https://github.com/hailanyi/CasA)
[OpenPCDet](https://github.com/open-mmlab/OpenPCDet)
[PENet](https://github.com/JUGGHM/PENet_ICRA2021)
[SFD](https://github.com/LittlePey/SFD)
## Citation
@inproceedings{TED,
title={Transformation-Equivariant 3D Object Detection for Autonomous Driving},
author={Wu, Hai and Wen, Chenglu and Li, Wei and Yang, Ruigang and Wang, Cheng},
year={2023},
booktitle={AAAI}
}
================================================
FILE: data/kitti/ImageSets/test.txt
================================================
000000
000001
000002
000003
000004
000005
000006
000007
000008
000009
000010
000011
000012
000013
000014
000015
000016
000017
000018
000019
000020
000021
000022
000023
000024
000025
000026
000027
000028
000029
000030
000031
000032
000033
000034
000035
000036
000037
000038
000039
000040
000041
000042
000043
000044
000045
000046
000047
000048
000049
000050
000051
000052
000053
000054
000055
000056
000057
000058
000059
000060
000061
000062
000063
000064
000065
000066
000067
000068
000069
000070
000071
000072
000073
000074
000075
000076
000077
000078
000079
000080
000081
000082
000083
000084
000085
000086
000087
000088
000089
000090
000091
000092
000093
000094
000095
000096
000097
000098
000099
000100
000101
000102
000103
000104
000105
000106
000107
000108
000109
000110
000111
000112
000113
000114
000115
000116
000117
000118
000119
000120
000121
000122
000123
000124
000125
000126
000127
000128
000129
000130
000131
000132
000133
000134
000135
000136
000137
000138
000139
000140
000141
000142
000143
000144
000145
000146
000147
000148
000149
000150
000151
000152
000153
000154
000155
000156
000157
000158
000159
000160
000161
000162
000163
000164
000165
000166
000167
000168
000169
000170
000171
000172
000173
000174
000175
000176
000177
000178
000179
000180
000181
000182
000183
000184
000185
000186
000187
000188
000189
000190
000191
000192
000193
000194
000195
000196
000197
000198
000199
000200
000201
000202
000203
000204
000205
000206
000207
000208
000209
000210
000211
000212
000213
000214
000215
000216
000217
000218
000219
000220
000221
000222
000223
000224
000225
000226
000227
000228
000229
000230
000231
000232
000233
000234
000235
000236
000237
000238
000239
000240
000241
000242
000243
000244
000245
000246
000247
000248
000249
000250
000251
000252
000253
000254
000255
000256
000257
000258
000259
000260
000261
000262
000263
000264
000265
000266
000267
000268
000269
000270
000271
000272
000273
000274
000275
000276
000277
000278
000279
000280
000281
000282
000283
000284
000285
000286
000287
000288
000289
000290
000291
000292
000293
000294
000295
000296
000297
000298
000299
000300
000301
000302
000303
000304
000305
000306
000307
000308
000309
000310
000311
000312
000313
000314
000315
000316
000317
000318
000319
000320
000321
000322
000323
000324
000325
000326
000327
000328
000329
000330
000331
000332
000333
000334
000335
000336
000337
000338
000339
000340
000341
000342
000343
000344
000345
000346
000347
000348
000349
000350
000351
000352
000353
000354
000355
000356
000357
000358
000359
000360
000361
000362
000363
000364
000365
000366
000367
000368
000369
000370
000371
000372
000373
000374
000375
000376
000377
000378
000379
000380
000381
000382
000383
000384
000385
000386
000387
000388
000389
000390
000391
000392
000393
000394
000395
000396
000397
000398
000399
000400
000401
000402
000403
000404
000405
000406
000407
000408
000409
000410
000411
000412
000413
000414
000415
000416
000417
000418
000419
000420
000421
000422
000423
000424
000425
000426
000427
000428
000429
000430
000431
000432
000433
000434
000435
000436
000437
000438
000439
000440
000441
000442
000443
000444
000445
000446
000447
000448
000449
000450
000451
000452
000453
000454
000455
000456
000457
000458
000459
000460
000461
000462
000463
000464
000465
000466
000467
000468
000469
000470
000471
000472
000473
000474
000475
000476
000477
000478
000479
000480
000481
000482
000483
000484
000485
000486
000487
000488
000489
000490
000491
000492
000493
000494
000495
000496
000497
000498
000499
000500
000501
000502
000503
000504
000505
000506
000507
000508
000509
000510
000511
000512
000513
000514
000515
000516
000517
000518
000519
000520
000521
000522
000523
000524
000525
000526
000527
000528
000529
000530
000531
000532
000533
000534
000535
000536
000537
000538
000539
000540
000541
000542
000543
000544
000545
000546
000547
000548
000549
000550
000551
000552
000553
000554
000555
000556
000557
000558
000559
000560
000561
000562
000563
000564
000565
000566
000567
000568
000569
000570
000571
000572
000573
000574
000575
000576
000577
000578
000579
000580
000581
000582
000583
000584
000585
000586
000587
000588
000589
000590
000591
000592
000593
000594
000595
000596
000597
000598
000599
000600
000601
000602
000603
000604
000605
000606
000607
000608
000609
000610
000611
000612
000613
000614
000615
000616
000617
000618
000619
000620
000621
000622
000623
000624
000625
000626
000627
000628
000629
000630
000631
000632
000633
000634
000635
000636
000637
000638
000639
000640
000641
000642
000643
000644
000645
000646
000647
000648
000649
000650
000651
000652
000653
000654
000655
000656
000657
000658
000659
000660
000661
000662
000663
000664
000665
000666
000667
000668
000669
000670
000671
000672
000673
000674
000675
000676
000677
000678
000679
000680
000681
000682
000683
000684
000685
000686
000687
000688
000689
000690
000691
000692
000693
000694
000695
000696
000697
000698
000699
000700
000701
000702
000703
000704
000705
000706
000707
000708
000709
000710
000711
000712
000713
000714
000715
000716
000717
000718
000719
000720
000721
000722
000723
000724
000725
000726
000727
000728
000729
000730
000731
000732
000733
000734
000735
000736
000737
000738
000739
000740
000741
000742
000743
000744
000745
000746
000747
000748
000749
000750
000751
000752
000753
000754
000755
000756
000757
000758
000759
000760
000761
000762
000763
000764
000765
000766
000767
000768
000769
000770
000771
000772
000773
000774
000775
000776
000777
000778
000779
000780
000781
000782
000783
000784
000785
000786
000787
000788
000789
000790
000791
000792
000793
000794
000795
000796
000797
000798
000799
000800
000801
000802
000803
000804
000805
000806
000807
000808
000809
000810
000811
000812
000813
000814
000815
000816
000817
000818
000819
000820
000821
000822
000823
000824
000825
000826
000827
000828
000829
000830
000831
000832
000833
000834
000835
000836
000837
000838
000839
000840
000841
000842
000843
000844
000845
000846
000847
000848
000849
000850
000851
000852
000853
000854
000855
000856
000857
000858
000859
000860
000861
000862
000863
000864
000865
000866
000867
000868
000869
000870
000871
000872
000873
000874
000875
000876
000877
000878
000879
000880
000881
000882
000883
000884
000885
000886
000887
000888
000889
000890
000891
000892
000893
000894
000895
000896
000897
000898
000899
000900
000901
000902
000903
000904
000905
000906
000907
000908
000909
000910
000911
000912
000913
000914
000915
000916
000917
000918
000919
000920
000921
000922
000923
000924
000925
000926
000927
000928
000929
000930
000931
000932
000933
000934
000935
000936
000937
000938
000939
000940
000941
000942
000943
000944
000945
000946
000947
000948
000949
000950
000951
000952
000953
000954
000955
000956
000957
000958
000959
000960
000961
000962
000963
000964
000965
000966
000967
000968
000969
000970
000971
000972
000973
000974
000975
000976
000977
000978
000979
000980
000981
000982
000983
000984
000985
000986
000987
000988
000989
000990
000991
000992
000993
000994
000995
000996
000997
000998
000999
001000
001001
001002
001003
001004
001005
001006
001007
001008
001009
001010
001011
001012
001013
001014
001015
001016
001017
001018
001019
001020
001021
001022
001023
001024
001025
001026
001027
001028
001029
001030
001031
001032
001033
001034
001035
001036
001037
001038
001039
001040
001041
001042
001043
001044
001045
001046
001047
001048
001049
001050
001051
001052
001053
001054
001055
001056
001057
001058
001059
001060
001061
001062
001063
001064
001065
001066
001067
001068
001069
001070
001071
001072
001073
001074
001075
001076
001077
001078
001079
001080
001081
001082
001083
001084
001085
001086
001087
001088
001089
001090
001091
001092
001093
001094
001095
001096
001097
001098
001099
001100
001101
001102
001103
001104
001105
001106
001107
001108
001109
001110
001111
001112
001113
001114
001115
001116
001117
001118
001119
001120
001121
001122
001123
001124
001125
001126
001127
001128
001129
001130
001131
001132
001133
001134
001135
001136
001137
001138
001139
001140
001141
001142
001143
001144
001145
001146
001147
001148
001149
001150
001151
001152
001153
001154
001155
001156
001157
001158
001159
001160
001161
001162
001163
001164
001165
001166
001167
001168
001169
001170
001171
001172
001173
001174
001175
001176
001177
001178
001179
001180
001181
001182
001183
001184
001185
001186
001187
001188
001189
001190
001191
001192
001193
001194
001195
001196
001197
001198
001199
001200
001201
001202
001203
001204
001205
001206
001207
001208
001209
001210
001211
001212
001213
001214
001215
001216
001217
001218
001219
001220
001221
001222
001223
001224
001225
001226
001227
001228
001229
001230
001231
001232
001233
001234
001235
001236
001237
001238
001239
001240
001241
001242
001243
001244
001245
001246
001247
001248
001249
001250
001251
001252
001253
001254
001255
001256
001257
001258
001259
001260
001261
001262
001263
001264
001265
001266
001267
001268
001269
001270
001271
001272
001273
001274
001275
001276
001277
001278
001279
001280
001281
001282
001283
001284
001285
001286
001287
001288
001289
001290
001291
001292
001293
001294
001295
001296
001297
001298
001299
001300
001301
001302
001303
001304
001305
001306
001307
001308
001309
001310
001311
001312
001313
001314
001315
001316
001317
001318
001319
001320
001321
001322
001323
001324
001325
001326
001327
001328
001329
001330
001331
001332
001333
001334
001335
001336
001337
001338
001339
001340
001341
001342
001343
001344
001345
001346
001347
001348
001349
001350
001351
001352
001353
001354
001355
001356
001357
001358
001359
001360
001361
001362
001363
001364
001365
001366
001367
001368
001369
001370
001371
001372
001373
001374
001375
001376
001377
001378
001379
001380
001381
001382
001383
001384
001385
001386
001387
001388
001389
001390
001391
001392
001393
001394
001395
001396
001397
001398
001399
001400
001401
001402
001403
001404
001405
001406
001407
001408
001409
001410
001411
001412
001413
001414
001415
001416
001417
001418
001419
001420
001421
001422
001423
001424
001425
001426
001427
001428
001429
001430
001431
001432
001433
001434
001435
001436
001437
001438
001439
001440
001441
001442
001443
001444
001445
001446
001447
001448
001449
001450
001451
001452
001453
001454
001455
001456
001457
001458
001459
001460
001461
001462
001463
001464
001465
001466
001467
001468
001469
001470
001471
001472
001473
001474
001475
001476
001477
001478
001479
001480
001481
001482
001483
001484
001485
001486
001487
001488
001489
001490
001491
001492
001493
001494
001495
001496
001497
001498
001499
001500
001501
001502
001503
001504
001505
001506
001507
001508
001509
001510
001511
001512
001513
001514
001515
001516
001517
001518
001519
001520
001521
001522
001523
001524
001525
001526
001527
001528
001529
001530
001531
001532
001533
001534
001535
001536
001537
001538
001539
001540
001541
001542
001543
001544
001545
001546
001547
001548
001549
001550
001551
001552
001553
001554
001555
001556
001557
001558
001559
001560
001561
001562
001563
001564
001565
001566
001567
001568
001569
001570
001571
001572
001573
001574
001575
001576
001577
001578
001579
001580
001581
001582
001583
001584
001585
001586
001587
001588
001589
001590
001591
001592
001593
001594
001595
001596
001597
001598
001599
001600
001601
001602
001603
001604
001605
001606
001607
001608
001609
001610
001611
001612
001613
001614
001615
001616
001617
001618
001619
001620
001621
001622
001623
001624
001625
001626
001627
001628
001629
001630
001631
001632
001633
001634
001635
001636
001637
001638
001639
001640
001641
001642
001643
001644
001645
001646
001647
001648
001649
001650
001651
001652
001653
001654
001655
001656
001657
001658
001659
001660
001661
001662
001663
001664
001665
001666
001667
001668
001669
001670
001671
001672
001673
001674
001675
001676
001677
001678
001679
001680
001681
001682
001683
001684
001685
001686
001687
001688
001689
001690
001691
001692
001693
001694
001695
001696
001697
001698
001699
001700
001701
001702
001703
001704
001705
001706
001707
001708
001709
001710
001711
001712
001713
001714
001715
001716
001717
001718
001719
001720
001721
001722
001723
001724
001725
001726
001727
001728
001729
001730
001731
001732
001733
001734
001735
001736
001737
001738
001739
001740
001741
001742
001743
001744
001745
001746
001747
001748
001749
001750
001751
001752
001753
001754
001755
001756
001757
001758
001759
001760
001761
001762
001763
001764
001765
001766
001767
001768
001769
001770
001771
001772
001773
001774
001775
001776
001777
001778
001779
001780
001781
001782
001783
001784
001785
001786
001787
001788
001789
001790
001791
001792
001793
001794
001795
001796
001797
001798
001799
001800
001801
001802
001803
001804
001805
001806
001807
001808
001809
001810
001811
001812
001813
001814
001815
001816
001817
001818
001819
001820
001821
001822
001823
001824
001825
001826
001827
001828
001829
001830
001831
001832
001833
001834
001835
001836
001837
001838
001839
001840
001841
001842
001843
001844
001845
001846
001847
001848
001849
001850
001851
001852
001853
001854
001855
001856
001857
001858
001859
001860
001861
001862
001863
001864
001865
001866
001867
001868
001869
001870
001871
001872
001873
001874
001875
001876
001877
001878
001879
001880
001881
001882
001883
001884
001885
001886
001887
001888
001889
001890
001891
001892
001893
001894
001895
001896
001897
001898
001899
001900
001901
001902
001903
001904
001905
001906
001907
001908
001909
001910
001911
001912
001913
001914
001915
001916
001917
001918
001919
001920
001921
001922
001923
001924
001925
001926
001927
001928
001929
001930
001931
001932
001933
001934
001935
001936
001937
001938
001939
001940
001941
001942
001943
001944
001945
001946
001947
001948
001949
001950
001951
001952
001953
001954
001955
001956
001957
001958
001959
001960
001961
001962
001963
001964
001965
001966
001967
001968
001969
001970
001971
001972
001973
001974
001975
001976
001977
001978
001979
001980
001981
001982
001983
001984
001985
001986
001987
001988
001989
001990
001991
001992
001993
001994
001995
001996
001997
001998
001999
002000
002001
002002
002003
002004
002005
002006
002007
002008
002009
002010
002011
002012
002013
002014
002015
002016
002017
002018
002019
002020
002021
002022
002023
002024
002025
002026
002027
002028
002029
002030
002031
002032
002033
002034
002035
002036
002037
002038
002039
002040
002041
002042
002043
002044
002045
002046
002047
002048
002049
002050
002051
002052
002053
002054
002055
002056
002057
002058
002059
002060
002061
002062
002063
002064
002065
002066
002067
002068
002069
002070
002071
002072
002073
002074
002075
002076
002077
002078
002079
002080
002081
002082
002083
002084
002085
002086
002087
002088
002089
002090
002091
002092
002093
002094
002095
002096
002097
002098
002099
002100
002101
002102
002103
002104
002105
002106
002107
002108
002109
002110
002111
002112
002113
002114
002115
002116
002117
002118
002119
002120
002121
002122
002123
002124
002125
002126
002127
002128
002129
002130
002131
002132
002133
002134
002135
002136
002137
002138
002139
002140
002141
002142
002143
002144
002145
002146
002147
002148
002149
002150
002151
002152
002153
002154
002155
002156
002157
002158
002159
002160
002161
002162
002163
002164
002165
002166
002167
002168
002169
002170
002171
002172
002173
002174
002175
002176
002177
002178
002179
002180
002181
002182
002183
002184
002185
002186
002187
002188
002189
002190
002191
002192
002193
002194
002195
002196
002197
002198
002199
002200
002201
002202
002203
002204
002205
002206
002207
002208
002209
002210
002211
002212
002213
002214
002215
002216
002217
002218
002219
002220
002221
002222
002223
002224
002225
002226
002227
002228
002229
002230
002231
002232
002233
002234
002235
002236
002237
002238
002239
002240
002241
002242
002243
002244
002245
002246
002247
002248
002249
002250
002251
002252
002253
002254
002255
002256
002257
002258
002259
002260
002261
002262
002263
002264
002265
002266
002267
002268
002269
002270
002271
002272
002273
002274
002275
002276
002277
002278
002279
002280
002281
002282
002283
002284
002285
002286
002287
002288
002289
002290
002291
002292
002293
002294
002295
002296
002297
002298
002299
002300
002301
002302
002303
002304
002305
002306
002307
002308
002309
002310
002311
002312
002313
002314
002315
002316
002317
002318
002319
002320
002321
002322
002323
002324
002325
002326
002327
002328
002329
002330
002331
002332
002333
002334
002335
002336
002337
002338
002339
002340
002341
002342
002343
002344
002345
002346
002347
002348
002349
002350
002351
002352
002353
002354
002355
002356
002357
002358
002359
002360
002361
002362
002363
002364
002365
002366
002367
002368
002369
002370
002371
002372
002373
002374
002375
002376
002377
002378
002379
002380
002381
002382
002383
002384
002385
002386
002387
002388
002389
002390
002391
002392
002393
002394
002395
002396
002397
002398
002399
002400
002401
002402
002403
002404
002405
002406
002407
002408
002409
002410
002411
002412
002413
002414
002415
002416
002417
002418
002419
002420
002421
002422
002423
002424
002425
002426
002427
002428
002429
002430
002431
002432
002433
002434
002435
002436
002437
002438
002439
002440
002441
002442
002443
002444
002445
002446
002447
002448
002449
002450
002451
002452
002453
002454
002455
002456
002457
002458
002459
002460
002461
002462
002463
002464
002465
002466
002467
002468
002469
002470
002471
002472
002473
002474
002475
002476
002477
002478
002479
002480
002481
002482
002483
002484
002485
002486
002487
002488
002489
002490
002491
002492
002493
002494
002495
002496
002497
002498
002499
002500
002501
002502
002503
002504
002505
002506
002507
002508
002509
002510
002511
002512
002513
002514
002515
002516
002517
002518
002519
002520
002521
002522
002523
002524
002525
002526
002527
002528
002529
002530
002531
002532
002533
002534
002535
002536
002537
002538
002539
002540
002541
002542
002543
002544
002545
002546
002547
002548
002549
002550
002551
002552
002553
002554
002555
002556
002557
002558
002559
002560
002561
002562
002563
002564
002565
002566
002567
002568
002569
002570
002571
002572
002573
002574
002575
002576
002577
002578
002579
002580
002581
002582
002583
002584
002585
002586
002587
002588
002589
002590
002591
002592
002593
002594
002595
002596
002597
002598
002599
002600
002601
002602
002603
002604
002605
002606
002607
002608
002609
002610
002611
002612
002613
002614
002615
002616
002617
002618
002619
002620
002621
002622
002623
002624
002625
002626
002627
002628
002629
002630
002631
002632
002633
002634
002635
002636
002637
002638
002639
002640
002641
002642
002643
002644
002645
002646
002647
002648
002649
002650
002651
002652
002653
002654
002655
002656
002657
002658
002659
002660
002661
002662
002663
002664
002665
002666
002667
002668
002669
002670
002671
002672
002673
002674
002675
002676
002677
002678
002679
002680
002681
002682
002683
002684
002685
002686
002687
002688
002689
002690
002691
002692
002693
002694
002695
002696
002697
002698
002699
002700
002701
002702
002703
002704
002705
002706
002707
002708
002709
002710
002711
002712
002713
002714
002715
002716
002717
002718
002719
002720
002721
002722
002723
002724
002725
002726
002727
002728
002729
002730
002731
002732
002733
002734
002735
002736
002737
002738
002739
002740
002741
002742
002743
002744
002745
002746
002747
002748
002749
002750
002751
002752
002753
002754
002755
002756
002757
002758
002759
002760
002761
002762
002763
002764
002765
002766
002767
002768
002769
002770
002771
002772
002773
002774
002775
002776
002777
002778
002779
002780
002781
002782
002783
002784
002785
002786
002787
002788
002789
002790
002791
002792
002793
002794
002795
002796
002797
002798
002799
002800
002801
002802
002803
002804
002805
002806
002807
002808
002809
002810
002811
002812
002813
002814
002815
002816
002817
002818
002819
002820
002821
002822
002823
002824
002825
002826
002827
002828
002829
002830
002831
002832
002833
002834
002835
002836
002837
002838
002839
002840
002841
002842
002843
002844
002845
002846
002847
002848
002849
002850
002851
002852
002853
002854
002855
002856
002857
002858
002859
002860
002861
002862
002863
002864
002865
002866
002867
002868
002869
002870
002871
002872
002873
002874
002875
002876
002877
002878
002879
002880
002881
002882
002883
002884
002885
002886
002887
002888
002889
002890
002891
002892
002893
002894
002895
002896
002897
002898
002899
002900
002901
002902
002903
002904
002905
002906
002907
002908
002909
002910
002911
002912
002913
002914
002915
002916
002917
002918
002919
002920
002921
002922
002923
002924
002925
002926
002927
002928
002929
002930
002931
002932
002933
002934
002935
002936
002937
002938
002939
002940
002941
002942
002943
002944
002945
002946
002947
002948
002949
002950
002951
002952
002953
002954
002955
002956
002957
002958
002959
002960
002961
002962
002963
002964
002965
002966
002967
002968
002969
002970
002971
002972
002973
002974
002975
002976
002977
002978
002979
002980
002981
002982
002983
002984
002985
002986
002987
002988
002989
002990
002991
002992
002993
002994
002995
002996
002997
002998
002999
003000
003001
003002
003003
003004
003005
003006
003007
003008
003009
003010
003011
003012
003013
003014
003015
003016
003017
003018
003019
003020
003021
003022
003023
003024
003025
003026
003027
003028
003029
003030
003031
003032
003033
003034
003035
003036
003037
003038
003039
003040
003041
003042
003043
003044
003045
003046
003047
003048
003049
003050
003051
003052
003053
003054
003055
003056
003057
003058
003059
003060
003061
003062
003063
003064
003065
003066
003067
003068
003069
003070
003071
003072
003073
003074
003075
003076
003077
003078
003079
003080
003081
003082
003083
003084
003085
003086
003087
003088
003089
003090
003091
003092
003093
003094
003095
003096
003097
003098
003099
003100
003101
003102
003103
003104
003105
003106
003107
003108
003109
003110
003111
003112
003113
003114
003115
003116
003117
003118
003119
003120
003121
003122
003123
003124
003125
003126
003127
003128
003129
003130
003131
003132
003133
003134
003135
003136
003137
003138
003139
003140
003141
003142
003143
003144
003145
003146
003147
003148
003149
003150
003151
003152
003153
003154
003155
003156
003157
003158
003159
003160
003161
003162
003163
003164
003165
003166
003167
003168
003169
003170
003171
003172
003173
003174
003175
003176
003177
003178
003179
003180
003181
003182
003183
003184
003185
003186
003187
003188
003189
003190
003191
003192
003193
003194
003195
003196
003197
003198
003199
003200
003201
003202
003203
003204
003205
003206
003207
003208
003209
003210
003211
003212
003213
003214
003215
003216
003217
003218
003219
003220
003221
003222
003223
003224
003225
003226
003227
003228
003229
003230
003231
003232
003233
003234
003235
003236
003237
003238
003239
003240
003241
003242
003243
003244
003245
003246
003247
003248
003249
003250
003251
003252
003253
003254
003255
003256
003257
003258
003259
003260
003261
003262
003263
003264
003265
003266
003267
003268
003269
003270
003271
003272
003273
003274
003275
003276
003277
003278
003279
003280
003281
003282
003283
003284
003285
003286
003287
003288
003289
003290
003291
003292
003293
003294
003295
003296
003297
003298
003299
003300
003301
003302
003303
003304
003305
003306
003307
003308
003309
003310
003311
003312
003313
003314
003315
003316
003317
003318
003319
003320
003321
003322
003323
003324
003325
003326
003327
003328
003329
003330
003331
003332
003333
003334
003335
003336
003337
003338
003339
003340
003341
003342
003343
003344
003345
003346
003347
003348
003349
003350
003351
003352
003353
003354
003355
003356
003357
003358
003359
003360
003361
003362
003363
003364
003365
003366
003367
003368
003369
003370
003371
003372
003373
003374
003375
003376
003377
003378
003379
003380
003381
003382
003383
003384
003385
003386
003387
003388
003389
003390
003391
003392
003393
003394
003395
003396
003397
003398
003399
003400
003401
003402
003403
003404
003405
003406
003407
003408
003409
003410
003411
003412
003413
003414
003415
003416
003417
003418
003419
003420
003421
003422
003423
003424
003425
003426
003427
003428
003429
003430
003431
003432
003433
003434
003435
003436
003437
003438
003439
003440
003441
003442
003443
003444
003445
003446
003447
003448
003449
003450
003451
003452
003453
003454
003455
003456
003457
003458
003459
003460
003461
003462
003463
003464
003465
003466
003467
003468
003469
003470
003471
003472
003473
003474
003475
003476
003477
003478
003479
003480
003481
003482
003483
003484
003485
003486
003487
003488
003489
003490
003491
003492
003493
003494
003495
003496
003497
003498
003499
003500
003501
003502
003503
003504
003505
003506
003507
003508
003509
003510
003511
003512
003513
003514
003515
003516
003517
003518
003519
003520
003521
003522
003523
003524
003525
003526
003527
003528
003529
003530
003531
003532
003533
003534
003535
003536
003537
003538
003539
003540
003541
003542
003543
003544
003545
003546
003547
003548
003549
003550
003551
003552
003553
003554
003555
003556
003557
003558
003559
003560
003561
003562
003563
003564
003565
003566
003567
003568
003569
003570
003571
003572
003573
003574
003575
003576
003577
003578
003579
003580
003581
003582
003583
003584
003585
003586
003587
003588
003589
003590
003591
003592
003593
003594
003595
003596
003597
003598
003599
003600
003601
003602
003603
003604
003605
003606
003607
003608
003609
003610
003611
003612
003613
003614
003615
003616
003617
003618
003619
003620
003621
003622
003623
003624
003625
003626
003627
003628
003629
003630
003631
003632
003633
003634
003635
003636
003637
003638
003639
003640
003641
003642
003643
003644
003645
003646
003647
003648
003649
003650
003651
003652
003653
003654
003655
003656
003657
003658
003659
003660
003661
003662
003663
003664
003665
003666
003667
003668
003669
003670
003671
003672
003673
003674
003675
003676
003677
003678
003679
003680
003681
003682
003683
003684
003685
003686
003687
003688
003689
003690
003691
003692
003693
003694
003695
003696
003697
003698
003699
003700
003701
003702
003703
003704
003705
003706
003707
003708
003709
003710
003711
003712
003713
003714
003715
003716
003717
003718
003719
003720
003721
003722
003723
003724
003725
003726
003727
003728
003729
003730
003731
003732
003733
003734
003735
003736
003737
003738
003739
003740
003741
003742
003743
003744
003745
003746
003747
003748
003749
003750
003751
003752
003753
003754
003755
003756
003757
003758
003759
003760
003761
003762
003763
003764
003765
003766
003767
003768
003769
003770
003771
003772
003773
003774
003775
003776
003777
003778
003779
003780
003781
003782
003783
003784
003785
003786
003787
003788
003789
003790
003791
003792
003793
003794
003795
003796
003797
003798
003799
003800
003801
003802
003803
003804
003805
003806
003807
003808
003809
003810
003811
003812
003813
003814
003815
003816
003817
003818
003819
003820
003821
003822
003823
003824
003825
003826
003827
003828
003829
003830
003831
003832
003833
003834
003835
003836
003837
003838
003839
003840
003841
003842
003843
003844
003845
003846
003847
003848
003849
003850
003851
003852
003853
003854
003855
003856
003857
003858
003859
003860
003861
003862
003863
003864
003865
003866
003867
003868
003869
003870
003871
003872
003873
003874
003875
003876
003877
003878
003879
003880
003881
003882
003883
003884
003885
003886
003887
003888
003889
003890
003891
003892
003893
003894
003895
003896
003897
003898
003899
003900
003901
003902
003903
003904
003905
003906
003907
003908
003909
003910
003911
003912
003913
003914
003915
003916
003917
003918
003919
003920
003921
003922
003923
003924
003925
003926
003927
003928
003929
003930
003931
003932
003933
003934
003935
003936
003937
003938
003939
003940
003941
003942
003943
003944
003945
003946
003947
003948
003949
003950
003951
003952
003953
003954
003955
003956
003957
003958
003959
003960
003961
003962
003963
003964
003965
003966
003967
003968
003969
003970
003971
003972
003973
003974
003975
003976
003977
003978
003979
003980
003981
003982
003983
003984
003985
003986
003987
003988
003989
003990
003991
003992
003993
003994
003995
003996
003997
003998
003999
004000
004001
004002
004003
004004
004005
004006
004007
004008
004009
004010
004011
004012
004013
004014
004015
004016
004017
004018
004019
004020
004021
004022
004023
004024
004025
004026
004027
004028
004029
004030
004031
004032
004033
004034
004035
004036
004037
004038
004039
004040
004041
004042
004043
004044
004045
004046
004047
004048
004049
004050
004051
004052
004053
004054
004055
004056
004057
004058
004059
004060
004061
004062
004063
004064
004065
004066
004067
004068
004069
004070
004071
004072
004073
004074
004075
004076
004077
004078
004079
004080
004081
004082
004083
004084
004085
004086
004087
004088
004089
004090
004091
004092
004093
004094
004095
004096
004097
004098
004099
004100
004101
004102
004103
004104
004105
004106
004107
004108
004109
004110
004111
004112
004113
004114
004115
004116
004117
004118
004119
004120
004121
004122
004123
004124
004125
004126
004127
004128
004129
004130
004131
004132
004133
004134
004135
004136
004137
004138
004139
004140
004141
004142
004143
004144
004145
004146
004147
004148
004149
004150
004151
004152
004153
004154
004155
004156
004157
004158
004159
004160
004161
004162
004163
004164
004165
004166
004167
004168
004169
004170
004171
004172
004173
004174
004175
004176
004177
004178
004179
004180
004181
004182
004183
004184
004185
004186
004187
004188
004189
004190
004191
004192
004193
004194
004195
004196
004197
004198
004199
004200
004201
004202
004203
004204
004205
004206
004207
004208
004209
004210
004211
004212
004213
004214
004215
004216
004217
004218
004219
004220
004221
004222
004223
004224
004225
004226
004227
004228
004229
004230
004231
004232
004233
004234
004235
004236
004237
004238
004239
004240
004241
004242
004243
004244
004245
004246
004247
004248
004249
004250
004251
004252
004253
004254
004255
004256
004257
004258
004259
004260
004261
004262
004263
004264
004265
004266
004267
004268
004269
004270
004271
004272
004273
004274
004275
004276
004277
004278
004279
004280
004281
004282
004283
004284
004285
004286
004287
004288
004289
004290
004291
004292
004293
004294
004295
004296
004297
004298
004299
004300
004301
004302
004303
004304
004305
004306
004307
004308
004309
004310
004311
004312
004313
004314
004315
004316
004317
004318
004319
004320
004321
004322
004323
004324
004325
004326
004327
004328
004329
004330
004331
004332
004333
004334
004335
004336
004337
004338
004339
004340
004341
004342
004343
004344
004345
004346
004347
004348
004349
004350
004351
004352
004353
004354
004355
004356
004357
004358
004359
004360
004361
004362
004363
004364
004365
004366
004367
004368
004369
004370
004371
004372
004373
004374
004375
004376
004377
004378
004379
004380
004381
004382
004383
004384
004385
004386
004387
004388
004389
004390
004391
004392
004393
004394
004395
004396
004397
004398
004399
004400
004401
004402
004403
004404
004405
004406
004407
004408
004409
004410
004411
004412
004413
004414
004415
004416
004417
004418
004419
004420
004421
004422
004423
004424
004425
004426
004427
004428
004429
004430
004431
004432
004433
004434
004435
004436
004437
004438
004439
004440
004441
004442
004443
004444
004445
004446
004447
004448
004449
004450
004451
004452
004453
004454
004455
004456
004457
004458
004459
004460
004461
004462
004463
004464
004465
004466
004467
004468
004469
004470
004471
004472
004473
004474
004475
004476
004477
004478
004479
004480
004481
004482
004483
004484
004485
004486
004487
004488
004489
004490
004491
004492
004493
004494
004495
004496
004497
004498
004499
004500
004501
004502
004503
004504
004505
004506
004507
004508
004509
004510
004511
004512
004513
004514
004515
004516
004517
004518
004519
004520
004521
004522
004523
004524
004525
004526
004527
004528
004529
004530
004531
004532
004533
004534
004535
004536
004537
004538
004539
004540
004541
004542
004543
004544
004545
004546
004547
004548
004549
004550
004551
004552
004553
004554
004555
004556
004557
004558
004559
004560
004561
004562
004563
004564
004565
004566
004567
004568
004569
004570
004571
004572
004573
004574
004575
004576
004577
004578
004579
004580
004581
004582
004583
004584
004585
004586
004587
004588
004589
004590
004591
004592
004593
004594
004595
004596
004597
004598
004599
004600
004601
004602
004603
004604
004605
004606
004607
004608
004609
004610
004611
004612
004613
004614
004615
004616
004617
004618
004619
004620
004621
004622
004623
004624
004625
004626
004627
004628
004629
004630
004631
004632
004633
004634
004635
004636
004637
004638
004639
004640
004641
004642
004643
004644
004645
004646
004647
004648
004649
004650
004651
004652
004653
004654
004655
004656
004657
004658
004659
004660
004661
004662
004663
004664
004665
004666
004667
004668
004669
004670
004671
004672
004673
004674
004675
004676
004677
004678
004679
004680
004681
004682
004683
004684
004685
004686
004687
004688
004689
004690
004691
004692
004693
004694
004695
004696
004697
004698
004699
004700
004701
004702
004703
004704
004705
004706
004707
004708
004709
004710
004711
004712
004713
004714
004715
004716
004717
004718
004719
004720
004721
004722
004723
004724
004725
004726
004727
004728
004729
004730
004731
004732
004733
004734
004735
004736
004737
004738
004739
004740
004741
004742
004743
004744
004745
004746
004747
004748
004749
004750
004751
004752
004753
004754
004755
004756
004757
004758
004759
004760
004761
004762
004763
004764
004765
004766
004767
004768
004769
004770
004771
004772
004773
004774
004775
004776
004777
004778
004779
004780
004781
004782
004783
004784
004785
004786
004787
004788
004789
004790
004791
004792
004793
004794
004795
004796
004797
004798
004799
004800
004801
004802
004803
004804
004805
004806
004807
004808
004809
004810
004811
004812
004813
004814
004815
004816
004817
004818
004819
004820
004821
004822
004823
004824
004825
004826
004827
004828
004829
004830
004831
004832
004833
004834
004835
004836
004837
004838
004839
004840
004841
004842
004843
004844
004845
004846
004847
004848
004849
004850
004851
004852
004853
004854
004855
004856
004857
004858
004859
004860
004861
004862
004863
004864
004865
004866
004867
004868
004869
004870
004871
004872
004873
004874
004875
004876
004877
004878
004879
004880
004881
004882
004883
004884
004885
004886
004887
004888
004889
004890
004891
004892
004893
004894
004895
004896
004897
004898
004899
004900
004901
004902
004903
004904
004905
004906
004907
004908
004909
004910
004911
004912
004913
004914
004915
004916
004917
004918
004919
004920
004921
004922
004923
004924
004925
004926
004927
004928
004929
004930
004931
004932
004933
004934
004935
004936
004937
004938
004939
004940
004941
004942
004943
004944
004945
004946
004947
004948
004949
004950
004951
004952
004953
004954
004955
004956
004957
004958
004959
004960
004961
004962
004963
004964
004965
004966
004967
004968
004969
004970
004971
004972
004973
004974
004975
004976
004977
004978
004979
004980
004981
004982
004983
004984
004985
004986
004987
004988
004989
004990
004991
004992
004993
004994
004995
004996
004997
004998
004999
005000
005001
005002
005003
005004
005005
005006
005007
005008
005009
005010
005011
005012
005013
005014
005015
005016
005017
005018
005019
005020
005021
005022
005023
005024
005025
005026
005027
005028
005029
005030
005031
005032
005033
005034
005035
005036
005037
005038
005039
005040
005041
005042
005043
005044
005045
005046
005047
005048
005049
005050
005051
005052
005053
005054
005055
005056
005057
005058
005059
005060
005061
005062
005063
005064
005065
005066
005067
005068
005069
005070
005071
005072
005073
005074
005075
005076
005077
005078
005079
005080
005081
005082
005083
005084
005085
005086
005087
005088
005089
005090
005091
005092
005093
005094
005095
005096
005097
005098
005099
005100
005101
005102
005103
005104
005105
005106
005107
005108
005109
005110
005111
005112
005113
005114
005115
005116
005117
005118
005119
005120
005121
005122
005123
005124
005125
005126
005127
005128
005129
005130
005131
005132
005133
005134
005135
005136
005137
005138
005139
005140
005141
005142
005143
005144
005145
005146
005147
005148
005149
005150
005151
005152
005153
005154
005155
005156
005157
005158
005159
005160
005161
005162
005163
005164
005165
005166
005167
005168
005169
005170
005171
005172
005173
005174
005175
005176
005177
005178
005179
005180
005181
005182
005183
005184
005185
005186
005187
005188
005189
005190
005191
005192
005193
005194
005195
005196
005197
005198
005199
005200
005201
005202
005203
005204
005205
005206
005207
005208
005209
005210
005211
005212
005213
005214
005215
005216
005217
005218
005219
005220
005221
005222
005223
005224
005225
005226
005227
005228
005229
005230
005231
005232
005233
005234
005235
005236
005237
005238
005239
005240
005241
005242
005243
005244
005245
005246
005247
005248
005249
005250
005251
005252
005253
005254
005255
005256
005257
005258
005259
005260
005261
005262
005263
005264
005265
005266
005267
005268
005269
005270
005271
005272
005273
005274
005275
005276
005277
005278
005279
005280
005281
005282
005283
005284
005285
005286
005287
005288
005289
005290
005291
005292
005293
005294
005295
005296
005297
005298
005299
005300
005301
005302
005303
005304
005305
005306
005307
005308
005309
005310
005311
005312
005313
005314
005315
005316
005317
005318
005319
005320
005321
005322
005323
005324
005325
005326
005327
005328
005329
005330
005331
005332
005333
005334
005335
005336
005337
005338
005339
005340
005341
005342
005343
005344
005345
005346
005347
005348
005349
005350
005351
005352
005353
005354
005355
005356
005357
005358
005359
005360
005361
005362
005363
005364
005365
005366
005367
005368
005369
005370
005371
005372
005373
005374
005375
005376
005377
005378
005379
005380
005381
005382
005383
005384
005385
005386
005387
005388
005389
005390
005391
005392
005393
005394
005395
005396
005397
005398
005399
005400
005401
005402
005403
005404
005405
005406
005407
005408
005409
005410
005411
005412
005413
005414
005415
005416
005417
005418
005419
005420
005421
005422
005423
005424
005425
005426
005427
005428
005429
005430
005431
005432
005433
005434
005435
005436
005437
005438
005439
005440
005441
005442
005443
005444
005445
005446
005447
005448
005449
005450
005451
005452
005453
005454
005455
005456
005457
005458
005459
005460
005461
005462
005463
005464
005465
005466
005467
005468
005469
005470
005471
005472
005473
005474
005475
005476
005477
005478
005479
005480
005481
005482
005483
005484
005485
005486
005487
005488
005489
005490
005491
005492
005493
005494
005495
005496
005497
005498
005499
005500
005501
005502
005503
005504
005505
005506
005507
005508
005509
005510
005511
005512
005513
005514
005515
005516
005517
005518
005519
005520
005521
005522
005523
005524
005525
005526
005527
005528
005529
005530
005531
005532
005533
005534
005535
005536
005537
005538
005539
005540
005541
005542
005543
005544
005545
005546
005547
005548
005549
005550
005551
005552
005553
005554
005555
005556
005557
005558
005559
005560
005561
005562
005563
005564
005565
005566
005567
005568
005569
005570
005571
005572
005573
005574
005575
005576
005577
005578
005579
005580
005581
005582
005583
005584
005585
005586
005587
005588
005589
005590
005591
005592
005593
005594
005595
005596
005597
005598
005599
005600
005601
005602
005603
005604
005605
005606
005607
005608
005609
005610
005611
005612
005613
005614
005615
005616
005617
005618
005619
005620
005621
005622
005623
005624
005625
005626
005627
005628
005629
005630
005631
005632
005633
005634
005635
005636
005637
005638
005639
005640
005641
005642
005643
005644
005645
005646
005647
005648
005649
005650
005651
005652
005653
005654
005655
005656
005657
005658
005659
005660
005661
005662
005663
005664
005665
005666
005667
005668
005669
005670
005671
005672
005673
005674
005675
005676
005677
005678
005679
005680
005681
005682
005683
005684
005685
005686
005687
005688
005689
005690
005691
005692
005693
005694
005695
005696
005697
005698
005699
005700
005701
005702
005703
005704
005705
005706
005707
005708
005709
005710
005711
005712
005713
005714
005715
005716
005717
005718
005719
005720
005721
005722
005723
005724
005725
005726
005727
005728
005729
005730
005731
005732
005733
005734
005735
005736
005737
005738
005739
005740
005741
005742
005743
005744
005745
005746
005747
005748
005749
005750
005751
005752
005753
005754
005755
005756
005757
005758
005759
005760
005761
005762
005763
005764
005765
005766
005767
005768
005769
005770
005771
005772
005773
005774
005775
005776
005777
005778
005779
005780
005781
005782
005783
005784
005785
005786
005787
005788
005789
005790
005791
005792
005793
005794
005795
005796
005797
005798
005799
005800
005801
005802
005803
005804
005805
005806
005807
005808
005809
005810
005811
005812
005813
005814
005815
005816
005817
005818
005819
005820
005821
005822
005823
005824
005825
005826
005827
005828
005829
005830
005831
005832
005833
005834
005835
005836
005837
005838
005839
005840
005841
005842
005843
005844
005845
005846
005847
005848
005849
005850
005851
005852
005853
005854
005855
005856
005857
005858
005859
005860
005861
005862
005863
005864
005865
005866
005867
005868
005869
005870
005871
005872
005873
005874
005875
005876
005877
005878
005879
005880
005881
005882
005883
005884
005885
005886
005887
005888
005889
005890
005891
005892
005893
005894
005895
005896
005897
005898
005899
005900
005901
005902
005903
005904
005905
005906
005907
005908
005909
005910
005911
005912
005913
005914
005915
005916
005917
005918
005919
005920
005921
005922
005923
005924
005925
005926
005927
005928
005929
005930
005931
005932
005933
005934
005935
005936
005937
005938
005939
005940
005941
005942
005943
005944
005945
005946
005947
005948
005949
005950
005951
005952
005953
005954
005955
005956
005957
005958
005959
005960
005961
005962
005963
005964
005965
005966
005967
005968
005969
005970
005971
005972
005973
005974
005975
005976
005977
005978
005979
005980
005981
005982
005983
005984
005985
005986
005987
005988
005989
005990
005991
005992
005993
005994
005995
005996
005997
005998
005999
006000
006001
006002
006003
006004
006005
006006
006007
006008
006009
006010
006011
006012
006013
006014
006015
006016
006017
006018
006019
006020
006021
006022
006023
006024
006025
006026
006027
006028
006029
006030
006031
006032
006033
006034
006035
006036
006037
006038
006039
006040
006041
006042
006043
006044
006045
006046
006047
006048
006049
006050
006051
006052
006053
006054
006055
006056
006057
006058
006059
006060
006061
006062
006063
006064
006065
006066
006067
006068
006069
006070
006071
006072
006073
006074
006075
006076
006077
006078
006079
006080
006081
006082
006083
006084
006085
006086
006087
006088
006089
006090
006091
006092
006093
006094
006095
006096
006097
006098
006099
006100
006101
006102
006103
006104
006105
006106
006107
006108
006109
006110
006111
006112
006113
006114
006115
006116
006117
006118
006119
006120
006121
006122
006123
006124
006125
006126
006127
006128
006129
006130
006131
006132
006133
006134
006135
006136
006137
006138
006139
006140
006141
006142
006143
006144
006145
006146
006147
006148
006149
006150
006151
006152
006153
006154
006155
006156
006157
006158
006159
006160
006161
006162
006163
006164
006165
006166
006167
006168
006169
006170
006171
006172
006173
006174
006175
006176
006177
006178
006179
006180
006181
006182
006183
006184
006185
006186
006187
006188
006189
006190
006191
006192
006193
006194
006195
006196
006197
006198
006199
006200
006201
006202
006203
006204
006205
006206
006207
006208
006209
006210
006211
006212
006213
006214
006215
006216
006217
006218
006219
006220
006221
006222
006223
006224
006225
006226
006227
006228
006229
006230
006231
006232
006233
006234
006235
006236
006237
006238
006239
006240
006241
006242
006243
006244
006245
006246
006247
006248
006249
006250
006251
006252
006253
006254
006255
006256
006257
006258
006259
006260
006261
006262
006263
006264
006265
006266
006267
006268
006269
006270
006271
006272
006273
006274
006275
006276
006277
006278
006279
006280
006281
006282
006283
006284
006285
006286
006287
006288
006289
006290
006291
006292
006293
006294
006295
006296
006297
006298
006299
006300
006301
006302
006303
006304
006305
006306
006307
006308
006309
006310
006311
006312
006313
006314
006315
006316
006317
006318
006319
006320
006321
006322
006323
006324
006325
006326
006327
006328
006329
006330
006331
006332
006333
006334
006335
006336
006337
006338
006339
006340
006341
006342
006343
006344
006345
006346
006347
006348
006349
006350
006351
006352
006353
006354
006355
006356
006357
006358
006359
006360
006361
006362
006363
006364
006365
006366
006367
006368
006369
006370
006371
006372
006373
006374
006375
006376
006377
006378
006379
006380
006381
006382
006383
006384
006385
006386
006387
006388
006389
006390
006391
006392
006393
006394
006395
006396
006397
006398
006399
006400
006401
006402
006403
006404
006405
006406
006407
006408
006409
006410
006411
006412
006413
006414
006415
006416
006417
006418
006419
006420
006421
006422
006423
006424
006425
006426
006427
006428
006429
006430
006431
006432
006433
006434
006435
006436
006437
006438
006439
006440
006441
006442
006443
006444
006445
006446
006447
006448
006449
006450
006451
006452
006453
006454
006455
006456
006457
006458
006459
006460
006461
006462
006463
006464
006465
006466
006467
006468
006469
006470
006471
006472
006473
006474
006475
006476
006477
006478
006479
006480
006481
006482
006483
006484
006485
006486
006487
006488
006489
006490
006491
006492
006493
006494
006495
006496
006497
006498
006499
006500
006501
006502
006503
006504
006505
006506
006507
006508
006509
006510
006511
006512
006513
006514
006515
006516
006517
006518
006519
006520
006521
006522
006523
006524
006525
006526
006527
006528
006529
006530
006531
006532
006533
006534
006535
006536
006537
006538
006539
006540
006541
006542
006543
006544
006545
006546
006547
006548
006549
006550
006551
006552
006553
006554
006555
006556
006557
006558
006559
006560
006561
006562
006563
006564
006565
006566
006567
006568
006569
006570
006571
006572
006573
006574
006575
006576
006577
006578
006579
006580
006581
006582
006583
006584
006585
006586
006587
006588
006589
006590
006591
006592
006593
006594
006595
006596
006597
006598
006599
006600
006601
006602
006603
006604
006605
006606
006607
006608
006609
006610
006611
006612
006613
006614
006615
006616
006617
006618
006619
006620
006621
006622
006623
006624
006625
006626
006627
006628
006629
006630
006631
006632
006633
006634
006635
006636
006637
006638
006639
006640
006641
006642
006643
006644
006645
006646
006647
006648
006649
006650
006651
006652
006653
006654
006655
006656
006657
006658
006659
006660
006661
006662
006663
006664
006665
006666
006667
006668
006669
006670
006671
006672
006673
006674
006675
006676
006677
006678
006679
006680
006681
006682
006683
006684
006685
006686
006687
006688
006689
006690
006691
006692
006693
006694
006695
006696
006697
006698
006699
006700
006701
006702
006703
006704
006705
006706
006707
006708
006709
006710
006711
006712
006713
006714
006715
006716
006717
006718
006719
006720
006721
006722
006723
006724
006725
006726
006727
006728
006729
006730
006731
006732
006733
006734
006735
006736
006737
006738
006739
006740
006741
006742
006743
006744
006745
006746
006747
006748
006749
006750
006751
006752
006753
006754
006755
006756
006757
006758
006759
006760
006761
006762
006763
006764
006765
006766
006767
006768
006769
006770
006771
006772
006773
006774
006775
006776
006777
006778
006779
006780
006781
006782
006783
006784
006785
006786
006787
006788
006789
006790
006791
006792
006793
006794
006795
006796
006797
006798
006799
006800
006801
006802
006803
006804
006805
006806
006807
006808
006809
006810
006811
006812
006813
006814
006815
006816
006817
006818
006819
006820
006821
006822
006823
006824
006825
006826
006827
006828
006829
006830
006831
006832
006833
006834
006835
006836
006837
006838
006839
006840
006841
006842
006843
006844
006845
006846
006847
006848
006849
006850
006851
006852
006853
006854
006855
006856
006857
006858
006859
006860
006861
006862
006863
006864
006865
006866
006867
006868
006869
006870
006871
006872
006873
006874
006875
006876
006877
006878
006879
006880
006881
006882
006883
006884
006885
006886
006887
006888
006889
006890
006891
006892
006893
006894
006895
006896
006897
006898
006899
006900
006901
006902
006903
006904
006905
006906
006907
006908
006909
006910
006911
006912
006913
006914
006915
006916
006917
006918
006919
006920
006921
006922
006923
006924
006925
006926
006927
006928
006929
006930
006931
006932
006933
006934
006935
006936
006937
006938
006939
006940
006941
006942
006943
006944
006945
006946
006947
006948
006949
006950
006951
006952
006953
006954
006955
006956
006957
006958
006959
006960
006961
006962
006963
006964
006965
006966
006967
006968
006969
006970
006971
006972
006973
006974
006975
006976
006977
006978
006979
006980
006981
006982
006983
006984
006985
006986
006987
006988
006989
006990
006991
006992
006993
006994
006995
006996
006997
006998
006999
007000
007001
007002
007003
007004
007005
007006
007007
007008
007009
007010
007011
007012
007013
007014
007015
007016
007017
007018
007019
007020
007021
007022
007023
007024
007025
007026
007027
007028
007029
007030
007031
007032
007033
007034
007035
007036
007037
007038
007039
007040
007041
007042
007043
007044
007045
007046
007047
007048
007049
007050
007051
007052
007053
007054
007055
007056
007057
007058
007059
007060
007061
007062
007063
007064
007065
007066
007067
007068
007069
007070
007071
007072
007073
007074
007075
007076
007077
007078
007079
007080
007081
007082
007083
007084
007085
007086
007087
007088
007089
007090
007091
007092
007093
007094
007095
007096
007097
007098
007099
007100
007101
007102
007103
007104
007105
007106
007107
007108
007109
007110
007111
007112
007113
007114
007115
007116
007117
007118
007119
007120
007121
007122
007123
007124
007125
007126
007127
007128
007129
007130
007131
007132
007133
007134
007135
007136
007137
007138
007139
007140
007141
007142
007143
007144
007145
007146
007147
007148
007149
007150
007151
007152
007153
007154
007155
007156
007157
007158
007159
007160
007161
007162
007163
007164
007165
007166
007167
007168
007169
007170
007171
007172
007173
007174
007175
007176
007177
007178
007179
007180
007181
007182
007183
007184
007185
007186
007187
007188
007189
007190
007191
007192
007193
007194
007195
007196
007197
007198
007199
007200
007201
007202
007203
007204
007205
007206
007207
007208
007209
007210
007211
007212
007213
007214
007215
007216
007217
007218
007219
007220
007221
007222
007223
007224
007225
007226
007227
007228
007229
007230
007231
007232
007233
007234
007235
007236
007237
007238
007239
007240
007241
007242
007243
007244
007245
007246
007247
007248
007249
007250
007251
007252
007253
007254
007255
007256
007257
007258
007259
007260
007261
007262
007263
007264
007265
007266
007267
007268
007269
007270
007271
007272
007273
007274
007275
007276
007277
007278
007279
007280
007281
007282
007283
007284
007285
007286
007287
007288
007289
007290
007291
007292
007293
007294
007295
007296
007297
007298
007299
007300
007301
007302
007303
007304
007305
007306
007307
007308
007309
007310
007311
007312
007313
007314
007315
007316
007317
007318
007319
007320
007321
007322
007323
007324
007325
007326
007327
007328
007329
007330
007331
007332
007333
007334
007335
007336
007337
007338
007339
007340
007341
007342
007343
007344
007345
007346
007347
007348
007349
007350
007351
007352
007353
007354
007355
007356
007357
007358
007359
007360
007361
007362
007363
007364
007365
007366
007367
007368
007369
007370
007371
007372
007373
007374
007375
007376
007377
007378
007379
007380
007381
007382
007383
007384
007385
007386
007387
007388
007389
007390
007391
007392
007393
007394
007395
007396
007397
007398
007399
007400
007401
007402
007403
007404
007405
007406
007407
007408
007409
007410
007411
007412
007413
007414
007415
007416
007417
007418
007419
007420
007421
007422
007423
007424
007425
007426
007427
007428
007429
007430
007431
007432
007433
007434
007435
007436
007437
007438
007439
007440
007441
007442
007443
007444
007445
007446
007447
007448
007449
007450
007451
007452
007453
007454
007455
007456
007457
007458
007459
007460
007461
007462
007463
007464
007465
007466
007467
007468
007469
007470
007471
007472
007473
007474
007475
007476
007477
007478
007479
007480
007481
007482
007483
007484
007485
007486
007487
007488
007489
007490
007491
007492
007493
007494
007495
007496
007497
007498
007499
007500
007501
007502
007503
007504
007505
007506
007507
007508
007509
007510
007511
007512
007513
007514
007515
007516
007517
================================================
FILE: data/kitti/ImageSets/train.txt
================================================
000000
000003
000007
000009
000010
000011
000012
000013
000014
000016
000017
000018
000022
000026
000029
000030
000032
000034
000036
000038
000041
000043
000044
000045
000046
000049
000051
000054
000055
000056
000057
000060
000064
000067
000068
000069
000070
000071
000072
000073
000074
000075
000079
000080
000082
000083
000084
000085
000086
000087
000088
000091
000092
000095
000096
000097
000099
000100
000101
000103
000105
000109
000110
000111
000112
000113
000114
000115
000119
000120
000121
000123
000125
000127
000129
000130
000131
000133
000136
000138
000141
000142
000144
000145
000146
000148
000149
000150
000154
000155
000157
000158
000160
000162
000163
000164
000165
000166
000171
000172
000176
000177
000178
000179
000180
000184
000185
000189
000193
000198
000200
000202
000205
000206
000208
000209
000210
000214
000215
000217
000219
000220
000221
000222
000225
000227
000228
000232
000233
000238
000240
000241
000243
000244
000245
000253
000254
000255
000256
000257
000258
000259
000261
000264
000267
000271
000274
000275
000276
000277
000280
000282
000285
000286
000287
000288
000292
000294
000295
000296
000298
000299
000300
000303
000304
000306
000310
000313
000316
000317
000318
000322
000325
000326
000330
000331
000334
000337
000338
000339
000342
000344
000348
000349
000353
000358
000363
000364
000367
000368
000371
000374
000375
000380
000384
000387
000389
000390
000400
000405
000406
000410
000411
000412
000416
000417
000418
000421
000423
000424
000425
000426
000431
000432
000433
000434
000435
000438
000439
000441
000442
000444
000445
000447
000449
000456
000458
000460
000461
000462
000464
000465
000466
000467
000470
000471
000474
000482
000483
000484
000487
000488
000490
000497
000500
000501
000502
000505
000507
000511
000513
000514
000516
000518
000520
000522
000523
000525
000526
000529
000531
000532
000534
000535
000537
000538
000539
000540
000544
000547
000549
000550
000552
000553
000556
000557
000562
000563
000565
000570
000573
000574
000575
000576
000577
000578
000579
000580
000582
000584
000585
000586
000587
000592
000593
000594
000596
000597
000598
000599
000602
000603
000605
000606
000607
000608
000609
000616
000617
000621
000622
000623
000627
000629
000631
000632
000633
000637
000638
000640
000641
000643
000646
000649
000651
000652
000653
000654
000656
000661
000662
000663
000664
000665
000666
000668
000671
000672
000673
000675
000676
000678
000680
000681
000685
000686
000687
000688
000689
000690
000693
000695
000697
000701
000703
000705
000707
000709
000710
000711
000712
000713
000714
000715
000719
000720
000723
000724
000726
000730
000732
000733
000735
000738
000739
000742
000743
000744
000747
000749
000753
000755
000757
000758
000759
000760
000762
000763
000764
000770
000775
000776
000777
000780
000781
000783
000784
000785
000786
000787
000788
000789
000791
000793
000794
000796
000797
000799
000808
000813
000814
000815
000817
000818
000820
000821
000822
000824
000825
000827
000828
000829
000830
000832
000833
000834
000835
000836
000839
000842
000845
000846
000851
000853
000855
000856
000857
000858
000860
000861
000864
000865
000866
000867
000868
000870
000871
000872
000880
000882
000883
000886
000887
000888
000890
000891
000892
000895
000896
000898
000900
000901
000902
000903
000905
000906
000908
000910
000913
000914
000918
000919
000921
000924
000925
000927
000929
000933
000934
000935
000936
000937
000941
000945
000946
000947
000950
000951
000954
000955
000957
000959
000960
000962
000965
000968
000972
000975
000977
000978
000980
000982
000987
000989
000990
000992
000993
000994
000995
000996
000997
000998
001000
001001
001003
001004
001005
001009
001016
001017
001020
001023
001024
001028
001029
001030
001031
001032
001033
001034
001036
001038
001040
001041
001044
001045
001047
001048
001049
001052
001056
001057
001059
001060
001061
001062
001064
001072
001073
001074
001079
001080
001081
001082
001085
001087
001090
001091
001092
001093
001098
001100
001103
001105
001109
001110
001112
001117
001119
001121
001122
001124
001126
001128
001130
001137
001142
001146
001151
001156
001157
001159
001160
001161
001164
001165
001166
001168
001169
001170
001171
001174
001175
001181
001184
001185
001186
001190
001196
001197
001200
001201
001202
001204
001205
001208
001209
001210
001211
001212
001215
001219
001220
001223
001227
001229
001231
001233
001238
001240
001247
001248
001250
001256
001258
001262
001264
001276
001277
001278
001279
001280
001282
001283
001285
001288
001290
001293
001297
001298
001299
001300
001301
001302
001309
001310
001311
001312
001313
001315
001316
001319
001320
001321
001322
001323
001324
001325
001326
001327
001328
001335
001338
001340
001341
001343
001348
001349
001351
001354
001357
001358
001360
001361
001362
001364
001366
001367
001368
001369
001370
001371
001373
001378
001379
001383
001385
001390
001392
001393
001394
001396
001399
001400
001401
001402
001403
001404
001405
001406
001408
001409
001413
001414
001417
001418
001420
001422
001423
001425
001426
001428
001429
001430
001433
001434
001436
001440
001444
001447
001449
001452
001453
001454
001455
001456
001457
001459
001460
001462
001464
001465
001467
001468
001470
001472
001473
001474
001475
001476
001479
001482
001483
001484
001486
001490
001491
001492
001493
001494
001496
001498
001499
001500
001503
001504
001505
001506
001509
001510
001512
001515
001518
001519
001520
001523
001529
001530
001531
001532
001534
001539
001540
001541
001543
001544
001548
001550
001551
001553
001554
001556
001558
001559
001561
001563
001566
001568
001570
001571
001572
001575
001578
001580
001581
001584
001593
001595
001598
001599
001601
001604
001607
001608
001609
001611
001612
001614
001618
001620
001622
001623
001624
001626
001628
001630
001632
001636
001637
001638
001639
001641
001642
001644
001646
001648
001649
001651
001652
001653
001655
001657
001659
001661
001663
001668
001669
001671
001672
001673
001674
001676
001677
001678
001679
001681
001685
001686
001687
001688
001690
001691
001692
001695
001696
001698
001700
001703
001708
001715
001716
001720
001723
001724
001725
001728
001730
001731
001734
001735
001736
001737
001738
001739
001743
001744
001747
001748
001753
001754
001756
001757
001759
001760
001761
001763
001766
001767
001769
001770
001773
001775
001777
001779
001784
001785
001788
001789
001790
001791
001792
001793
001796
001798
001799
001803
001805
001806
001809
001810
001811
001812
001815
001816
001819
001821
001826
001827
001829
001830
001832
001833
001834
001836
001837
001838
001839
001841
001842
001843
001845
001847
001849
001850
001857
001860
001864
001865
001866
001870
001871
001873
001874
001876
001879
001882
001883
001889
001891
001894
001895
001896
001899
001901
001902
001903
001906
001907
001908
001910
001911
001912
001913
001914
001915
001916
001917
001918
001921
001922
001930
001935
001938
001939
001944
001947
001948
001949
001950
001951
001953
001955
001956
001957
001958
001961
001962
001963
001964
001965
001968
001970
001971
001973
001974
001975
001976
001981
001987
001988
001990
001992
001993
001994
001998
002003
002005
002006
002007
002009
002015
002016
002018
002020
002023
002024
002026
002030
002031
002032
002033
002039
002040
002041
002047
002051
002053
002055
002059
002060
002061
002063
002064
002065
002066
002067
002069
002070
002072
002077
002080
002083
002084
002088
002090
002092
002095
002096
002097
002098
002099
002104
002105
002106
002109
002110
002114
002116
002117
002119
002122
002125
002126
002129
002132
002133
002134
002141
002143
002144
002145
002146
002147
002148
002149
002150
002154
002155
002156
002157
002162
002164
002167
002171
002172
002174
002175
002176
002178
002180
002181
002184
002186
002189
002190
002191
002192
002194
002195
002197
002198
002199
002203
002204
002205
002208
002210
002211
002212
002213
002214
002217
002221
002222
002223
002226
002227
002230
002231
002235
002236
002237
002238
002240
002241
002242
002244
002247
002249
002252
002253
002256
002259
002261
002263
002264
002265
002267
002268
002269
002270
002271
002273
002274
002275
002278
002281
002285
002288
002289
002296
002297
002301
002302
002305
002309
002311
002312
002313
002316
002317
002318
002321
002322
002323
002324
002326
002328
002331
002333
002335
002339
002342
002343
002349
002350
002351
002352
002354
002355
002358
002360
002361
002363
002364
002368
002371
002373
002374
002375
002377
002379
002381
002388
002389
002390
002394
002395
002396
002400
002401
002402
002403
002406
002407
002408
002409
002410
002412
002413
002416
002417
002421
002426
002427
002430
002431
002435
002436
002437
002438
002441
002443
002444
002445
002447
002448
002449
002451
002452
002453
002456
002459
002464
002465
002466
002467
002468
002469
002470
002471
002472
002475
002480
002481
002482
002484
002485
002487
002489
002491
002493
002494
002496
002498
002501
002507
002508
002510
002512
002513
002514
002515
002517
002518
002522
002523
002524
002527
002533
002535
002536
002537
002542
002544
002545
002547
002549
002550
002551
002553
002554
002555
002559
002560
002561
002566
002567
002571
002573
002576
002578
002579
002582
002587
002588
002589
002591
002592
002593
002595
002596
002597
002605
002607
002608
002609
002610
002611
002614
002616
002617
002618
002620
002622
002623
002624
002627
002629
002632
002634
002637
002639
002642
002643
002647
002648
002649
002650
002652
002654
002655
002658
002659
002660
002662
002664
002665
002667
002668
002670
002671
002672
002676
002678
002679
002682
002683
002684
002687
002688
002689
002691
002697
002698
002700
002701
002703
002704
002705
002708
002714
002716
002718
002719
002723
002731
002732
002733
002734
002736
002738
002739
002741
002743
002750
002751
002754
002756
002759
002762
002766
002768
002769
002770
002771
002774
002776
002777
002778
002779
002780
002781
002782
002784
002785
002788
002790
002791
002792
002795
002798
002799
002802
002803
002807
002808
002813
002816
002817
002819
002821
002822
002823
002824
002825
002829
002832
002834
002835
002837
002838
002842
002843
002849
002850
002851
002852
002854
002855
002857
002859
002860
002862
002864
002865
002868
002869
002870
002871
002872
002873
002874
002882
002884
002886
002887
002888
002897
002898
002899
002904
002906
002907
002909
002910
002912
002913
002915
002918
002920
002921
002922
002923
002926
002927
002929
002931
002932
002933
002936
002938
002939
002940
002941
002943
002946
002949
002950
002952
002954
002956
002965
002967
002968
002969
002970
002972
002973
002975
002980
002981
002983
002986
002987
002989
002990
002992
002996
002998
003002
003008
003009
003012
003013
003014
003015
003016
003017
003018
003020
003021
003023
003026
003028
003036
003037
003039
003040
003041
003044
003045
003049
003051
003057
003059
003060
003063
003064
003068
003069
003070
003072
003075
003077
003078
003079
003081
003083
003084
003085
003086
003089
003091
003092
003093
003095
003097
003098
003100
003104
003105
003108
003111
003113
003115
003117
003119
003120
003121
003122
003123
003125
003128
003130
003132
003138
003139
003140
003143
003147
003149
003151
003152
003154
003155
003157
003158
003160
003163
003164
003166
003168
003169
003171
003173
003176
003178
003184
003185
003186
003188
003189
003191
003193
003195
003196
003198
003200
003201
003205
003206
003208
003209
003212
003213
003215
003218
003220
003223
003227
003230
003234
003235
003237
003238
003241
003243
003244
003245
003246
003248
003249
003253
003256
003258
003260
003261
003262
003263
003264
003267
003268
003270
003271
003273
003274
003277
003278
003279
003282
003284
003285
003286
003287
003289
003290
003291
003293
003294
003297
003299
003303
003307
003309
003311
003314
003317
003320
003321
003326
003327
003328
003329
003332
003333
003334
003335
003336
003339
003340
003342
003344
003345
003348
003349
003354
003356
003359
003360
003361
003362
003363
003369
003371
003372
003374
003376
003377
003378
003380
003381
003382
003383
003384
003387
003388
003389
003390
003391
003392
003398
003400
003413
003414
003415
003416
003418
003420
003423
003424
003427
003431
003433
003436
003437
003438
003439
003440
003441
003442
003444
003445
003446
003451
003452
003454
003455
003457
003458
003459
003460
003462
003463
003468
003472
003473
003475
003476
003477
003479
003485
003486
003493
003494
003498
003499
003500
003501
003505
003507
003508
003509
003510
003512
003513
003514
003516
003518
003522
003523
003525
003526
003532
003533
003534
003536
003537
003538
003540
003541
003542
003545
003546
003548
003549
003551
003555
003556
003560
003561
003564
003565
003566
003567
003569
003570
003572
003575
003576
003577
003578
003579
003581
003585
003586
003587
003589
003590
003591
003592
003593
003594
003595
003596
003597
003598
003599
003602
003603
003606
003610
003612
003613
003615
003617
003619
003625
003626
003628
003636
003637
003638
003639
003640
003641
003642
003644
003646
003648
003650
003651
003654
003656
003657
003660
003663
003664
003665
003666
003670
003672
003673
003674
003675
003680
003681
003685
003686
003687
003693
003694
003695
003696
003697
003698
003699
003700
003701
003704
003706
003709
003710
003713
003714
003717
003720
003721
003722
003724
003725
003727
003729
003730
003731
003732
003733
003734
003740
003741
003742
003743
003744
003745
003749
003752
003754
003757
003758
003759
003760
003761
003765
003766
003767
003768
003770
003772
003773
003774
003776
003780
003783
003784
003785
003786
003789
003790
003791
003792
003795
003796
003797
003799
003801
003803
003806
003810
003813
003815
003816
003817
003818
003819
003821
003823
003824
003825
003829
003831
003832
003833
003836
003838
003839
003840
003842
003843
003844
003845
003846
003848
003849
003850
003851
003853
003855
003857
003858
003861
003862
003863
003865
003867
003868
003871
003875
003876
003877
003882
003884
003887
003888
003889
003893
003895
003896
003900
003903
003904
003906
003908
003910
003911
003912
003913
003917
003918
003919
003921
003922
003925
003927
003928
003929
003930
003933
003935
003936
003939
003940
003941
003942
003944
003947
003949
003951
003952
003953
003954
003955
003957
003959
003960
003963
003966
003967
003968
003971
003973
003974
003976
003978
003979
003983
003985
003987
003988
003989
003990
003991
003993
003994
003995
003997
003999
004005
004006
004012
004013
004014
004015
004017
004018
004019
004020
004022
004023
004024
004025
004029
004030
004031
004035
004037
004039
004043
004044
004046
004047
004050
004052
004053
004054
004056
004057
004058
004060
004062
004066
004067
004069
004070
004071
004073
004075
004076
004078
004080
004084
004086
004088
004090
004093
004094
004097
004099
004102
004103
004106
004112
004114
004115
004123
004127
004133
004134
004135
004139
004141
004144
004145
004146
004147
004151
004159
004165
004166
004167
004169
004170
004176
004177
004178
004179
004180
004181
004182
004183
004184
004186
004192
004193
004194
004197
004198
004199
004200
004201
004203
004204
004208
004211
004212
004216
004217
004218
004219
004225
004227
004229
004230
004231
004233
004234
004235
004236
004238
004240
004244
004245
004247
004252
004253
004257
004258
004261
004262
004264
004265
004266
004267
004268
004269
004272
004273
004274
004276
004279
004283
004286
004287
004292
004296
004297
004302
004304
004308
004310
004313
004315
004316
004317
004320
004322
004325
004328
004331
004332
004333
004334
004339
004341
004344
004346
004347
004351
004354
004355
004356
004357
004358
004359
004361
004365
004366
004371
004372
004375
004376
004378
004379
004380
004381
004382
004386
004387
004389
004390
004394
004395
004399
004400
004405
004408
004409
004410
004411
004412
004413
004416
004417
004427
004428
004431
004432
004436
004441
004442
004445
004446
004448
004449
004451
004453
004455
004457
004459
004461
004463
004464
004466
004467
004468
004471
004473
004476
004477
004478
004479
004484
004488
004492
004495
004497
004498
004499
004500
004503
004504
004505
004506
004507
004509
004510
004512
004514
004515
004518
004522
004523
004524
004525
004533
004535
004536
004537
004538
004539
004543
004544
004545
004546
004550
004552
004554
004555
004558
004559
004560
004561
004563
004564
004565
004571
004572
004575
004577
004579
004580
004583
004584
004586
004590
004592
004593
004594
004595
004597
004600
004601
004602
004604
004605
004606
004607
004613
004614
004616
004617
004619
004621
004623
004625
004627
004628
004631
004635
004637
004639
004641
004642
004643
004645
004646
004653
004654
004656
004659
004661
004662
004663
004664
004670
004671
004674
004675
004676
004677
004678
004681
004684
004690
004696
004701
004702
004703
004704
004707
004712
004719
004723
004727
004728
004729
004731
004733
004736
004741
004747
004749
004750
004751
004754
004755
004757
004758
004760
004761
004765
004767
004771
004772
004774
004775
004778
004779
004780
004781
004784
004785
004786
004789
004793
004794
004795
004796
004798
004801
004802
004803
004805
004808
004809
004812
004818
004819
004820
004823
004824
004826
004827
004828
004833
004834
004836
004837
004838
004840
004841
004842
004844
004845
004847
004853
004854
004855
004856
004857
004865
004866
004869
004870
004872
004876
004877
004878
004879
004880
004882
004883
004884
004886
004889
004890
004894
004897
004899
004900
004901
004906
004908
004910
004911
004912
004913
004915
004916
004919
004922
004923
004925
004930
004933
004936
004937
004939
004940
004945
004950
004951
004952
004955
004957
004961
004964
004965
004967
004968
004969
004970
004971
004972
004973
004975
004977
004978
004980
004982
004984
004987
004991
004992
004997
005000
005003
005005
005006
005007
005009
005011
005012
005016
005018
005020
005022
005023
005025
005027
005029
005030
005031
005033
005035
005039
005042
005043
005044
005046
005047
005048
005051
005059
005060
005061
005066
005069
005071
005076
005083
005084
005085
005087
005088
005089
005091
005092
005096
005097
005098
005099
005100
005102
005104
005106
005107
005111
005114
005115
005116
005117
005118
005119
005123
005126
005129
005130
005131
005132
005134
005137
005142
005146
005148
005150
005151
005152
005154
005159
005160
005165
005169
005171
005173
005177
005178
005183
005186
005187
005192
005193
005195
005196
005200
005202
005203
005204
005205
005207
005208
005209
005210
005211
005212
005215
005216
005220
005223
005224
005225
005228
005231
005232
005235
005238
005239
005243
005245
005247
005248
005250
005252
005253
005254
005257
005258
005259
005261
005263
005264
005265
005266
005269
005270
005272
005277
005278
005281
005283
005285
005286
005288
005290
005291
005293
005294
005295
005300
005301
005302
005303
005305
005306
005310
005314
005317
005320
005324
005326
005327
005331
005332
005339
005340
005344
005346
005348
005351
005352
005353
005354
005355
005356
005357
005358
005361
005362
005364
005367
005370
005373
005374
005376
005380
005382
005383
005384
005387
005388
005392
005393
005394
005395
005396
005397
005398
005399
005400
005401
005402
005403
005406
005407
005408
005409
005410
005411
005412
005414
005416
005417
005418
005419
005420
005421
005424
005425
005428
005432
005433
005435
005436
005438
005439
005440
005442
005446
005451
005454
005455
005456
005457
005462
005463
005464
005468
005469
005470
005475
005478
005480
005483
005485
005488
005490
005491
005492
005493
005496
005497
005499
005500
005501
005502
005503
005504
005506
005507
005508
005509
005512
005513
005516
005517
005518
005519
005520
005521
005522
005524
005526
005527
005529
005530
005533
005535
005537
005539
005541
005543
005547
005548
005549
005550
005553
005554
005561
005562
005563
005564
005567
005568
005569
005574
005575
005578
005579
005583
005585
005591
005592
005593
005594
005597
005598
005599
005604
005605
005606
005607
005608
005609
005611
005612
005614
005615
005620
005621
005622
005624
005626
005627
005628
005629
005632
005636
005637
005641
005644
005645
005646
005647
005648
005651
005654
005655
005657
005661
005663
005665
005666
005667
005670
005671
005674
005675
005678
005679
005681
005682
005684
005686
005688
005690
005691
005692
005693
005694
005696
005697
005701
005702
005705
005710
005711
005715
005716
005718
005719
005720
005721
005722
005723
005726
005730
005732
005733
005734
005737
005738
005742
005748
005749
005750
005752
005753
005755
005756
005758
005759
005761
005764
005766
005767
005768
005769
005770
005771
005772
005773
005774
005775
005776
005778
005779
005780
005781
005788
005789
005791
005792
005795
005797
005798
005799
005802
005804
005808
005809
005810
005813
005814
005815
005816
005817
005823
005824
005825
005828
005830
005831
005832
005833
005835
005836
005837
005838
005842
005844
005845
005846
005847
005848
005849
005850
005851
005853
005858
005860
005861
005862
005863
005865
005866
005867
005868
005870
005871
005872
005874
005875
005877
005880
005884
005886
005888
005890
005891
005895
005896
005897
005898
005902
005904
005908
005915
005920
005924
005928
005929
005930
005932
005934
005936
005937
005940
005941
005942
005943
005945
005946
005950
005951
005953
005954
005956
005957
005959
005960
005964
005966
005967
005968
005971
005973
005974
005976
005977
005979
005980
005983
005987
005989
005990
005991
005992
005993
005995
005998
006000
006004
006006
006007
006011
006015
006017
006018
006019
006020
006021
006022
006025
006032
006035
006037
006040
006049
006051
006053
006055
006056
006059
006064
006065
006069
006072
006073
006076
006079
006080
006081
006082
006084
006089
006090
006091
006092
006094
006099
006101
006104
006105
006108
006109
006111
006112
006113
006119
006120
006124
006128
006129
006131
006132
006134
006135
006137
006138
006140
006141
006142
006143
006145
006147
006149
006150
006153
006155
006157
006158
006159
006160
006162
006164
006166
006170
006171
006172
006174
006175
006178
006179
006180
006181
006183
006184
006188
006189
006191
006192
006193
006197
006199
006200
006201
006203
006205
006206
006207
006209
006211
006212
006214
006216
006217
006218
006220
006221
006223
006224
006225
006226
006230
006231
006234
006235
006236
006237
006239
006241
006242
006243
006245
006248
006251
006252
006253
006254
006255
006256
006257
006259
006260
006261
006262
006264
006268
006271
006277
006279
006281
006283
006284
006285
006289
006290
006291
006292
006293
006294
006295
006296
006298
006299
006303
006304
006307
006308
006309
006310
006311
006313
006318
006319
006320
006323
006325
006326
006327
006328
006329
006330
006335
006336
006337
006341
006346
006347
006350
006352
006358
006359
006361
006362
006363
006365
006367
006373
006374
006375
006376
006378
006382
006383
006384
006387
006389
006390
006392
006397
006398
006399
006400
006401
006402
006404
006408
006412
006413
006414
006418
006419
006421
006422
006428
006429
006430
006431
006432
006438
006443
006447
006448
006449
006450
006455
006456
006457
006458
006459
006460
006461
006463
006466
006467
006471
006476
006479
006480
006485
006487
006489
006490
006492
006494
006495
006499
006500
006501
006502
006504
006509
006510
006511
006513
006518
006522
006523
006526
006527
006528
006536
006538
006539
006541
006543
006544
006545
006546
006547
006550
006552
006554
006557
006559
006562
006564
006566
006567
006571
006572
006573
006575
006579
006580
006584
006585
006587
006589
006591
006594
006598
006599
006600
006601
006605
006606
006607
006608
006609
006610
006615
006616
006617
006619
006620
006621
006622
006627
006630
006631
006635
006639
006640
006642
006644
006645
006646
006648
006652
006653
006654
006657
006661
006662
006663
006665
006668
006671
006672
006673
006675
006680
006681
006683
006684
006687
006688
006689
006690
006691
006697
006699
006700
006702
006704
006705
006706
006707
006708
006716
006717
006718
006721
006722
006724
006727
006728
006730
006735
006736
006739
006740
006742
006743
006746
006748
006749
006750
006757
006763
006766
006769
006774
006775
006776
006779
006784
006787
006788
006790
006793
006795
006799
006801
006802
006805
006809
006810
006814
006817
006820
006821
006823
006824
006825
006826
006827
006830
006831
006834
006835
006838
006839
006840
006842
006845
006846
006848
006851
006857
006859
006861
006864
006865
006867
006869
006871
006875
006877
006878
006880
006883
006886
006888
006890
006892
006893
006894
006896
006902
006904
006905
006909
006911
006912
006915
006916
006918
006919
006920
006921
006923
006924
006926
006927
006929
006931
006932
006933
006934
006935
006939
006940
006941
006946
006947
006949
006951
006952
006957
006958
006961
006963
006965
006966
006967
006969
006970
006972
006974
006975
006976
006979
006983
006984
006985
006986
006988
006991
006993
006995
006996
006998
007001
007002
007004
007007
007009
007013
007017
007018
007020
007021
007024
007025
007035
007036
007039
007040
007041
007044
007045
007046
007050
007051
007054
007057
007058
007060
007062
007064
007066
007070
007073
007075
007077
007086
007090
007092
007093
007094
007096
007097
007099
007101
007102
007104
007105
007106
007107
007108
007111
007113
007114
007116
007118
007121
007123
007124
007126
007127
007128
007129
007134
007137
007140
007141
007142
007143
007147
007148
007150
007151
007152
007153
007155
007156
007159
007160
007167
007170
007171
007173
007175
007179
007181
007184
007185
007186
007188
007189
007190
007191
007192
007193
007195
007196
007197
007203
007206
007209
007211
007213
007216
007218
007220
007222
007223
007224
007226
007228
007231
007234
007236
007237
007239
007241
007243
007245
007248
007249
007250
007251
007254
007257
007259
007263
007264
007268
007269
007270
007276
007281
007282
007285
007286
007293
007295
007296
007297
007298
007301
007305
007306
007307
007308
007312
007313
007314
007316
007317
007320
007321
007324
007328
007332
007333
007334
007335
007338
007340
007341
007346
007348
007354
007355
007356
007357
007358
007361
007362
007363
007365
007366
007367
007368
007370
007372
007373
007378
007379
007386
007387
007388
007390
007392
007393
007394
007399
007400
007404
007406
007408
007414
007417
007418
007425
007427
007428
007429
007431
007432
007438
007441
007443
007444
007446
007451
007452
007454
007455
007457
007459
007460
007461
007465
007471
007472
007474
007476
007479
================================================
FILE: data/kitti/ImageSets/val.txt
================================================
000001
000002
000004
000005
000006
000008
000015
000019
000020
000021
000023
000024
000025
000027
000028
000031
000033
000035
000037
000039
000040
000042
000047
000048
000050
000052
000053
000058
000059
000061
000062
000063
000065
000066
000076
000077
000078
000081
000089
000090
000093
000094
000098
000102
000104
000106
000107
000108
000116
000117
000118
000122
000124
000126
000128
000132
000134
000135
000137
000139
000140
000143
000147
000151
000152
000153
000156
000159
000161
000167
000168
000169
000170
000173
000174
000175
000181
000182
000183
000186
000187
000188
000190
000191
000192
000194
000195
000196
000197
000199
000201
000203
000204
000207
000211
000212
000213
000216
000218
000223
000224
000226
000229
000230
000231
000234
000235
000236
000237
000239
000242
000246
000247
000248
000249
000250
000251
000252
000260
000262
000263
000265
000266
000268
000269
000270
000272
000273
000278
000279
000281
000283
000284
000289
000290
000291
000293
000297
000301
000302
000305
000307
000308
000309
000311
000312
000314
000315
000319
000320
000321
000323
000324
000327
000328
000329
000332
000333
000335
000336
000340
000341
000343
000345
000346
000347
000350
000351
000352
000354
000355
000356
000357
000359
000360
000361
000362
000365
000366
000369
000370
000372
000373
000376
000377
000378
000379
000381
000382
000383
000385
000386
000388
000391
000392
000393
000394
000395
000396
000397
000398
000399
000401
000402
000403
000404
000407
000408
000409
000413
000414
000415
000419
000420
000422
000427
000428
000429
000430
000436
000437
000440
000443
000446
000448
000450
000451
000452
000453
000454
000455
000457
000459
000463
000468
000469
000472
000473
000475
000476
000477
000478
000479
000480
000481
000485
000486
000489
000491
000492
000493
000494
000495
000496
000498
000499
000503
000504
000506
000508
000509
000510
000512
000515
000517
000519
000521
000524
000527
000528
000530
000533
000536
000541
000542
000543
000545
000546
000548
000551
000554
000555
000558
000559
000560
000561
000564
000566
000567
000568
000569
000571
000572
000581
000583
000588
000589
000590
000591
000595
000600
000601
000604
000610
000611
000612
000613
000614
000615
000618
000619
000620
000624
000625
000626
000628
000630
000634
000635
000636
000639
000642
000644
000645
000647
000648
000650
000655
000657
000658
000659
000660
000667
000669
000670
000674
000677
000679
000682
000683
000684
000691
000692
000694
000696
000698
000699
000700
000702
000704
000706
000708
000716
000717
000718
000721
000722
000725
000727
000728
000729
000731
000734
000736
000737
000740
000741
000745
000746
000748
000750
000751
000752
000754
000756
000761
000765
000766
000767
000768
000769
000771
000772
000773
000774
000778
000779
000782
000790
000792
000795
000798
000800
000801
000802
000803
000804
000805
000806
000807
000809
000810
000811
000812
000816
000819
000823
000826
000831
000837
000838
000840
000841
000843
000844
000847
000848
000849
000850
000852
000854
000859
000862
000863
000869
000873
000874
000875
000876
000877
000878
000879
000881
000884
000885
000889
000893
000894
000897
000899
000904
000907
000909
000911
000912
000915
000916
000917
000920
000922
000923
000926
000928
000930
000931
000932
000938
000939
000940
000942
000943
000944
000948
000949
000952
000953
000956
000958
000961
000963
000964
000966
000967
000969
000970
000971
000973
000974
000976
000979
000981
000983
000984
000985
000986
000988
000991
000999
001002
001006
001007
001008
001010
001011
001012
001013
001014
001015
001018
001019
001021
001022
001025
001026
001027
001035
001037
001039
001042
001043
001046
001050
001051
001053
001054
001055
001058
001063
001065
001066
001067
001068
001069
001070
001071
001075
001076
001077
001078
001083
001084
001086
001088
001089
001094
001095
001096
001097
001099
001101
001102
001104
001106
001107
001108
001111
001113
001114
001115
001116
001118
001120
001123
001125
001127
001129
001131
001132
001133
001134
001135
001136
001138
001139
001140
001141
001143
001144
001145
001147
001148
001149
001150
001152
001153
001154
001155
001158
001162
001163
001167
001172
001173
001176
001177
001178
001179
001180
001182
001183
001187
001188
001189
001191
001192
001193
001194
001195
001198
001199
001203
001206
001207
001213
001214
001216
001217
001218
001221
001222
001224
001225
001226
001228
001230
001232
001234
001235
001236
001237
001239
001241
001242
001243
001244
001245
001246
001249
001251
001252
001253
001254
001255
001257
001259
001260
001261
001263
001265
001266
001267
001268
001269
001270
001271
001272
001273
001274
001275
001281
001284
001286
001287
001289
001291
001292
001294
001295
001296
001303
001304
001305
001306
001307
001308
001314
001317
001318
001329
001330
001331
001332
001333
001334
001336
001337
001339
001342
001344
001345
001346
001347
001350
001352
001353
001355
001356
001359
001363
001365
001372
001374
001375
001376
001377
001380
001381
001382
001384
001386
001387
001388
001389
001391
001395
001397
001398
001407
001410
001411
001412
001415
001416
001419
001421
001424
001427
001431
001432
001435
001437
001438
001439
001441
001442
001443
001445
001446
001448
001450
001451
001458
001461
001463
001466
001469
001471
001477
001478
001480
001481
001485
001487
001488
001489
001495
001497
001501
001502
001507
001508
001511
001513
001514
001516
001517
001521
001522
001524
001525
001526
001527
001528
001533
001535
001536
001537
001538
001542
001545
001546
001547
001549
001552
001555
001557
001560
001562
001564
001565
001567
001569
001573
001574
001576
001577
001579
001582
001583
001585
001586
001587
001588
001589
001590
001591
001592
001594
001596
001597
001600
001602
001603
001605
001606
001610
001613
001615
001616
001617
001619
001621
001625
001627
001629
001631
001633
001634
001635
001640
001643
001645
001647
001650
001654
001656
001658
001660
001662
001664
001665
001666
001667
001670
001675
001680
001682
001683
001684
001689
001693
001694
001697
001699
001701
001702
001704
001705
001706
001707
001709
001710
001711
001712
001713
001714
001717
001718
001719
001721
001722
001726
001727
001729
001732
001733
001740
001741
001742
001745
001746
001749
001750
001751
001752
001755
001758
001762
001764
001765
001768
001771
001772
001774
001776
001778
001780
001781
001782
001783
001786
001787
001794
001795
001797
001800
001801
001802
001804
001807
001808
001813
001814
001817
001818
001820
001822
001823
001824
001825
001828
001831
001835
001840
001844
001846
001848
001851
001852
001853
001854
001855
001856
001858
001859
001861
001862
001863
001867
001868
001869
001872
001875
001877
001878
001880
001881
001884
001885
001886
001887
001888
001890
001892
001893
001897
001898
001900
001904
001905
001909
001919
001920
001923
001924
001925
001926
001927
001928
001929
001931
001932
001933
001934
001936
001937
001940
001941
001942
001943
001945
001946
001952
001954
001959
001960
001966
001967
001969
001972
001977
001978
001979
001980
001982
001983
001984
001985
001986
001989
001991
001995
001996
001997
001999
002000
002001
002002
002004
002008
002010
002011
002012
002013
002014
002017
002019
002021
002022
002025
002027
002028
002029
002034
002035
002036
002037
002038
002042
002043
002044
002045
002046
002048
002049
002050
002052
002054
002056
002057
002058
002062
002068
002071
002073
002074
002075
002076
002078
002079
002081
002082
002085
002086
002087
002089
002091
002093
002094
002100
002101
002102
002103
002107
002108
002111
002112
002113
002115
002118
002120
002121
002123
002124
002127
002128
002130
002131
002135
002136
002137
002138
002139
002140
002142
002151
002152
002153
002158
002159
002160
002161
002163
002165
002166
002168
002169
002170
002173
002177
002179
002182
002183
002185
002187
002188
002193
002196
002200
002201
002202
002206
002207
002209
002215
002216
002218
002219
002220
002224
002225
002228
002229
002232
002233
002234
002239
002243
002245
002246
002248
002250
002251
002254
002255
002257
002258
002260
002262
002266
002272
002276
002277
002279
002280
002282
002283
002284
002286
002287
002290
002291
002292
002293
002294
002295
002298
002299
002300
002303
002304
002306
002307
002308
002310
002314
002315
002319
002320
002325
002327
002329
002330
002332
002334
002336
002337
002338
002340
002341
002344
002345
002346
002347
002348
002353
002356
002357
002359
002362
002365
002366
002367
002369
002370
002372
002376
002378
002380
002382
002383
002384
002385
002386
002387
002391
002392
002393
002397
002398
002399
002404
002405
002411
002414
002415
002418
002419
002420
002422
002423
002424
002425
002428
002429
002432
002433
002434
002439
002440
002442
002446
002450
002454
002455
002457
002458
002460
002461
002462
002463
002473
002474
002476
002477
002478
002479
002483
002486
002488
002490
002492
002495
002497
002499
002500
002502
002503
002504
002505
002506
002509
002511
002516
002519
002520
002521
002525
002526
002528
002529
002530
002531
002532
002534
002538
002539
002540
002541
002543
002546
002548
002552
002556
002557
002558
002562
002563
002564
002565
002568
002569
002570
002572
002574
002575
002577
002580
002581
002583
002584
002585
002586
002590
002594
002598
002599
002600
002601
002602
002603
002604
002606
002612
002613
002615
002619
002621
002625
002626
002628
002630
002631
002633
002635
002636
002638
002640
002641
002644
002645
002646
002651
002653
002656
002657
002661
002663
002666
002669
002673
002674
002675
002677
002680
002681
002685
002686
002690
002692
002693
002694
002695
002696
002699
002702
002706
002707
002709
002710
002711
002712
002713
002715
002717
002720
002721
002722
002724
002725
002726
002727
002728
002729
002730
002735
002737
002740
002742
002744
002745
002746
002747
002748
002749
002752
002753
002755
002757
002758
002760
002761
002763
002764
002765
002767
002772
002773
002775
002783
002786
002787
002789
002793
002794
002796
002797
002800
002801
002804
002805
002806
002809
002810
002811
002812
002814
002815
002818
002820
002826
002827
002828
002830
002831
002833
002836
002839
002840
002841
002844
002845
002846
002847
002848
002853
002856
002858
002861
002863
002866
002867
002875
002876
002877
002878
002879
002880
002881
002883
002885
002889
002890
002891
002892
002893
002894
002895
002896
002900
002901
002902
002903
002905
002908
002911
002914
002916
002917
002919
002924
002925
002928
002930
002934
002935
002937
002942
002944
002945
002947
002948
002951
002953
002955
002957
002958
002959
002960
002961
002962
002963
002964
002966
002971
002974
002976
002977
002978
002979
002982
002984
002985
002988
002991
002993
002994
002995
002997
002999
003000
003001
003003
003004
003005
003006
003007
003010
003011
003019
003022
003024
003025
003027
003029
003030
003031
003032
003033
003034
003035
003038
003042
003043
003046
003047
003048
003050
003052
003053
003054
003055
003056
003058
003061
003062
003065
003066
003067
003071
003073
003074
003076
003080
003082
003087
003088
003090
003094
003096
003099
003101
003102
003103
003106
003107
003109
003110
003112
003114
003116
003118
003124
003126
003127
003129
003131
003133
003134
003135
003136
003137
003141
003142
003144
003145
003146
003148
003150
003153
003156
003159
003161
003162
003165
003167
003170
003172
003174
003175
003177
003179
003180
003181
003182
003183
003187
003190
003192
003194
003197
003199
003202
003203
003204
003207
003210
003211
003214
003216
003217
003219
003221
003222
003224
003225
003226
003228
003229
003231
003232
003233
003236
003239
003240
003242
003247
003250
003251
003252
003254
003255
003257
003259
003265
003266
003269
003272
003275
003276
003280
003281
003283
003288
003292
003295
003296
003298
003300
003301
003302
003304
003305
003306
003308
003310
003312
003313
003315
003316
003318
003319
003322
003323
003324
003325
003330
003331
003337
003338
003341
003343
003346
003347
003350
003351
003352
003353
003355
003357
003358
003364
003365
003366
003367
003368
003370
003373
003375
003379
003385
003386
003393
003394
003395
003396
003397
003399
003401
003402
003403
003404
003405
003406
003407
003408
003409
003410
003411
003412
003417
003419
003421
003422
003425
003426
003428
003429
003430
003432
003434
003435
003443
003447
003448
003449
003450
003453
003456
003461
003464
003465
003466
003467
003469
003470
003471
003474
003478
003480
003481
003482
003483
003484
003487
003488
003489
003490
003491
003492
003495
003496
003497
003502
003503
003504
003506
003511
003515
003517
003519
003520
003521
003524
003527
003528
003529
003530
003531
003535
003539
003543
003544
003547
003550
003552
003553
003554
003557
003558
003559
003562
003563
003568
003571
003573
003574
003580
003582
003583
003584
003588
003600
003601
003604
003605
003607
003608
003609
003611
003614
003616
003618
003620
003621
003622
003623
003624
003627
003629
003630
003631
003632
003633
003634
003635
003643
003645
003647
003649
003652
003653
003655
003658
003659
003661
003662
003667
003668
003669
003671
003676
003677
003678
003679
003682
003683
003684
003688
003689
003690
003691
003692
003702
003703
003705
003707
003708
003711
003712
003715
003716
003718
003719
003723
003726
003728
003735
003736
003737
003738
003739
003746
003747
003748
003750
003751
003753
003755
003756
003762
003763
003764
003769
003771
003775
003777
003778
003779
003781
003782
003787
003788
003793
003794
003798
003800
003802
003804
003805
003807
003808
003809
003811
003812
003814
003820
003822
003826
003827
003828
003830
003834
003835
003837
003841
003847
003852
003854
003856
003859
003860
003864
003866
003869
003870
003872
003873
003874
003878
003879
003880
003881
003883
003885
003886
003890
003891
003892
003894
003897
003898
003899
003901
003902
003905
003907
003909
003914
003915
003916
003920
003923
003924
003926
003931
003932
003934
003937
003938
003943
003945
003946
003948
003950
003956
003958
003961
003962
003964
003965
003969
003970
003972
003975
003977
003980
003981
003982
003984
003986
003992
003996
003998
004000
004001
004002
004003
004004
004007
004008
004009
004010
004011
004016
004021
004026
004027
004028
004032
004033
004034
004036
004038
004040
004041
004042
004045
004048
004049
004051
004055
004059
004061
004063
004064
004065
004068
004072
004074
004077
004079
004081
004082
004083
004085
004087
004089
004091
004092
004095
004096
004098
004100
004101
004104
004105
004107
004108
004109
004110
004111
004113
004116
004117
004118
004119
004120
004121
004122
004124
004125
004126
004128
004129
004130
004131
004132
004136
004137
004138
004140
004142
004143
004148
004149
004150
004152
004153
004154
004155
004156
004157
004158
004160
004161
004162
004163
004164
004168
004171
004172
004173
004174
004175
004185
004187
004188
004189
004190
004191
004195
004196
004202
004205
004206
004207
004209
004210
004213
004214
004215
004220
004221
004222
004223
004224
004226
004228
004232
004237
004239
004241
004242
004243
004246
004248
004249
004250
004251
004254
004255
004256
004259
004260
004263
004270
004271
004275
004277
004278
004280
004281
004282
004284
004285
004288
004289
004290
004291
004293
004294
004295
004298
004299
004300
004301
004303
004305
004306
004307
004309
004311
004312
004314
004318
004319
004321
004323
004324
004326
004327
004329
004330
004335
004336
004337
004338
004340
004342
004343
004345
004348
004349
004350
004352
004353
004360
004362
004363
004364
004367
004368
004369
004370
004373
004374
004377
004383
004384
004385
004388
004391
004392
004393
004396
004397
004398
004401
004402
004403
004404
004406
004407
004414
004415
004418
004419
004420
004421
004422
004423
004424
004425
004426
004429
004430
004433
004434
004435
004437
004438
004439
004440
004443
004444
004447
004450
004452
004454
004456
004458
004460
004462
004465
004469
004470
004472
004474
004475
004480
004481
004482
004483
004485
004486
004487
004489
004490
004491
004493
004494
004496
004501
004502
004508
004511
004513
004516
004517
004519
004520
004521
004526
004527
004528
004529
004530
004531
004532
004534
004540
004541
004542
004547
004548
004549
004551
004553
004556
004557
004562
004566
004567
004568
004569
004570
004573
004574
004576
004578
004581
004582
004585
004587
004588
004589
004591
004596
004598
004599
004603
004608
004609
004610
004611
004612
004615
004618
004620
004622
004624
004626
004629
004630
004632
004633
004634
004636
004638
004640
004644
004647
004648
004649
004650
004651
004652
004655
004657
004658
004660
004665
004666
004667
004668
004669
004672
004673
004679
004680
004682
004683
004685
004686
004687
004688
004689
004691
004692
004693
004694
004695
004697
004698
004699
004700
004705
004706
004708
004709
004710
004711
004713
004714
004715
004716
004717
004718
004720
004721
004722
004724
004725
004726
004730
004732
004734
004735
004737
004738
004739
004740
004742
004743
004744
004745
004746
004748
004752
004753
004756
004759
004762
004763
004764
004766
004768
004769
004770
004773
004776
004777
004782
004783
004787
004788
004790
004791
004792
004797
004799
004800
004804
004806
004807
004810
004811
004813
004814
004815
004816
004817
004821
004822
004825
004829
004830
004831
004832
004835
004839
004843
004846
004848
004849
004850
004851
004852
004858
004859
004860
004861
004862
004863
004864
004867
004868
004871
004873
004874
004875
004881
004885
004887
004888
004891
004892
004893
004895
004896
004898
004902
004903
004904
004905
004907
004909
004914
004917
004918
004920
004921
004924
004926
004927
004928
004929
004931
004932
004934
004935
004938
004941
004942
004943
004944
004946
004947
004948
004949
004953
004954
004956
004958
004959
004960
004962
004963
004966
004974
004976
004979
004981
004983
004985
004986
004988
004989
004990
004993
004994
004995
004996
004998
004999
005001
005002
005004
005008
005010
005013
005014
005015
005017
005019
005021
005024
005026
005028
005032
005034
005036
005037
005038
005040
005041
005045
005049
005050
005052
005053
005054
005055
005056
005057
005058
005062
005063
005064
005065
005067
005068
005070
005072
005073
005074
005075
005077
005078
005079
005080
005081
005082
005086
005090
005093
005094
005095
005101
005103
005105
005108
005109
005110
005112
005113
005120
005121
005122
005124
005125
005127
005128
005133
005135
005136
005138
005139
005140
005141
005143
005144
005145
005147
005149
005153
005155
005156
005157
005158
005161
005162
005163
005164
005166
005167
005168
005170
005172
005174
005175
005176
005179
005180
005181
005182
005184
005185
005188
005189
005190
005191
005194
005197
005198
005199
005201
005206
005213
005214
005217
005218
005219
005221
005222
005226
005227
005229
005230
005233
005234
005236
005237
005240
005241
005242
005244
005246
005249
005251
005255
005256
005260
005262
005267
005268
005271
005273
005274
005275
005276
005279
005280
005282
005284
005287
005289
005292
005296
005297
005298
005299
005304
005307
005308
005309
005311
005312
005313
005315
005316
005318
005319
005321
005322
005323
005325
005328
005329
005330
005333
005334
005335
005336
005337
005338
005341
005342
005343
005345
005347
005349
005350
005359
005360
005363
005365
005366
005368
005369
005371
005372
005375
005377
005378
005379
005381
005385
005386
005389
005390
005391
005404
005405
005413
005415
005422
005423
005426
005427
005429
005430
005431
005434
005437
005441
005443
005444
005445
005447
005448
005449
005450
005452
005453
005458
005459
005460
005461
005465
005466
005467
005471
005472
005473
005474
005476
005477
005479
005481
005482
005484
005486
005487
005489
005494
005495
005498
005505
005510
005511
005514
005515
005523
005525
005528
005531
005532
005534
005536
005538
005540
005542
005544
005545
005546
005551
005552
005555
005556
005557
005558
005559
005560
005565
005566
005570
005571
005572
005573
005576
005577
005580
005581
005582
005584
005586
005587
005588
005589
005590
005595
005596
005600
005601
005602
005603
005610
005613
005616
005617
005618
005619
005623
005625
005630
005631
005633
005634
005635
005638
005639
005640
005642
005643
005649
005650
005652
005653
005656
005658
005659
005660
005662
005664
005668
005669
005672
005673
005676
005677
005680
005683
005685
005687
005689
005695
005698
005699
005700
005703
005704
005706
005707
005708
005709
005712
005713
005714
005717
005724
005725
005727
005728
005729
005731
005735
005736
005739
005740
005741
005743
005744
005745
005746
005747
005751
005754
005757
005760
005762
005763
005765
005777
005782
005783
005784
005785
005786
005787
005790
005793
005794
005796
005800
005801
005803
005805
005806
005807
005811
005812
005818
005819
005820
005821
005822
005826
005827
005829
005834
005839
005840
005841
005843
005852
005854
005855
005856
005857
005859
005864
005869
005873
005876
005878
005879
005881
005882
005883
005885
005887
005889
005892
005893
005894
005899
005900
005901
005903
005905
005906
005907
005909
005910
005911
005912
005913
005914
005916
005917
005918
005919
005921
005922
005923
005925
005926
005927
005931
005933
005935
005938
005939
005944
005947
005948
005949
005952
005955
005958
005961
005962
005963
005965
005969
005970
005972
005975
005978
005981
005982
005984
005985
005986
005988
005994
005996
005997
005999
006001
006002
006003
006005
006008
006009
006010
006012
006013
006014
006016
006023
006024
006026
006027
006028
006029
006030
006031
006033
006034
006036
006038
006039
006041
006042
006043
006044
006045
006046
006047
006048
006050
006052
006054
006057
006058
006060
006061
006062
006063
006066
006067
006068
006070
006071
006074
006075
006077
006078
006083
006085
006086
006087
006088
006093
006095
006096
006097
006098
006100
006102
006103
006106
006107
006110
006114
006115
006116
006117
006118
006121
006122
006123
006125
006126
006127
006130
006133
006136
006139
006144
006146
006148
006151
006152
006154
006156
006161
006163
006165
006167
006168
006169
006173
006176
006177
006182
006185
006186
006187
006190
006194
006195
006196
006198
006202
006204
006208
006210
006213
006215
006219
006222
006227
006228
006229
006232
006233
006238
006240
006244
006246
006247
006249
006250
006258
006263
006265
006266
006267
006269
006270
006272
006273
006274
006275
006276
006278
006280
006282
006286
006287
006288
006297
006300
006301
006302
006305
006306
006312
006314
006315
006316
006317
006321
006322
006324
006331
006332
006333
006334
006338
006339
006340
006342
006343
006344
006345
006348
006349
006351
006353
006354
006355
006356
006357
006360
006364
006366
006368
006369
006370
006371
006372
006377
006379
006380
006381
006385
006386
006388
006391
006393
006394
006395
006396
006403
006405
006406
006407
006409
006410
006411
006415
006416
006417
006420
006423
006424
006425
006426
006427
006433
006434
006435
006436
006437
006439
006440
006441
006442
006444
006445
006446
006451
006452
006453
006454
006462
006464
006465
006468
006469
006470
006472
006473
006474
006475
006477
006478
006481
006482
006483
006484
006486
006488
006491
006493
006496
006497
006498
006503
006505
006506
006507
006508
006512
006514
006515
006516
006517
006519
006520
006521
006524
006525
006529
006530
006531
006532
006533
006534
006535
006537
006540
006542
006548
006549
006551
006553
006555
006556
006558
006560
006561
006563
006565
006568
006569
006570
006574
006576
006577
006578
006581
006582
006583
006586
006588
006590
006592
006593
006595
006596
006597
006602
006603
006604
006611
006612
006613
006614
006618
006623
006624
006625
006626
006628
006629
006632
006633
006634
006636
006637
006638
006641
006643
006647
006649
006650
006651
006655
006656
006658
006659
006660
006664
006666
006667
006669
006670
006674
006676
006677
006678
006679
006682
006685
006686
006692
006693
006694
006695
006696
006698
006701
006703
006709
006710
006711
006712
006713
006714
006715
006719
006720
006723
006725
006726
006729
006731
006732
006733
006734
006737
006738
006741
006744
006745
006747
006751
006752
006753
006754
006755
006756
006758
006759
006760
006761
006762
006764
006765
006767
006768
006770
006771
006772
006773
006777
006778
006780
006781
006782
006783
006785
006786
006789
006791
006792
006794
006796
006797
006798
006800
006803
006804
006806
006807
006808
006811
006812
006813
006815
006816
006818
006819
006822
006828
006829
006832
006833
006836
006837
006841
006843
006844
006847
006849
006850
006852
006853
006854
006855
006856
006858
006860
006862
006863
006866
006868
006870
006872
006873
006874
006876
006879
006881
006882
006884
006885
006887
006889
006891
006895
006897
006898
006899
006900
006901
006903
006906
006907
006908
006910
006913
006914
006917
006922
006925
006928
006930
006936
006937
006938
006942
006943
006944
006945
006948
006950
006953
006954
006955
006956
006959
006960
006962
006964
006968
006971
006973
006977
006978
006980
006981
006982
006987
006989
006990
006992
006994
006997
006999
007000
007003
007005
007006
007008
007010
007011
007012
007014
007015
007016
007019
007022
007023
007026
007027
007028
007029
007030
007031
007032
007033
007034
007037
007038
007042
007043
007047
007048
007049
007052
007053
007055
007056
007059
007061
007063
007065
007067
007068
007069
007071
007072
007074
007076
007078
007079
007080
007081
007082
007083
007084
007085
007087
007088
007089
007091
007095
007098
007100
007103
007109
007110
007112
007115
007117
007119
007120
007122
007125
007130
007131
007132
007133
007135
007136
007138
007139
007144
007145
007146
007149
007154
007157
007158
007161
007162
007163
007164
007165
007166
007168
007169
007172
007174
007176
007177
007178
007180
007182
007183
007187
007194
007198
007199
007200
007201
007202
007204
007205
007207
007208
007210
007212
007214
007215
007217
007219
007221
007225
007227
007229
007230
007232
007233
007235
007238
007240
007242
007244
007246
007247
007252
007253
007255
007256
007258
007260
007261
007262
007265
007266
007267
007271
007272
007273
007274
007275
007277
007278
007279
007280
007283
007284
007287
007288
007289
007290
007291
007292
007294
007299
007300
007302
007303
007304
007309
007310
007311
007315
007318
007319
007322
007323
007325
007326
007327
007329
007330
007331
007336
007337
007339
007342
007343
007344
007345
007347
007349
007350
007351
007352
007353
007359
007360
007364
007369
007371
007374
007375
007376
007377
007380
007381
007382
007383
007384
007385
007389
007391
007395
007396
007397
007398
007401
007402
007403
007405
007407
007409
007410
007411
007412
007413
007415
007416
007419
007420
007421
007422
007423
007424
007426
007430
007433
007434
007435
007436
007437
007439
007440
007442
007445
007447
007448
007449
007450
007453
007456
007458
007462
007463
007464
007466
007467
007468
007469
007470
007473
007475
007477
007478
007480
================================================
FILE: pcdet/__init__.py
================================================
import subprocess
from pathlib import Path
from .version import __version__
__all__ = [
'__version__'
]
def get_git_commit_number():
if not (Path(__file__).parent / '../.git').exists():
return '0000000'
cmd_out = subprocess.run(['git', 'rev-parse', 'HEAD'], stdout=subprocess.PIPE)
git_commit_number = cmd_out.stdout.decode('utf-8')[:7]
return git_commit_number
script_version = get_git_commit_number()
if script_version not in __version__:
__version__ = __version__ + '+py%s' % script_version
================================================
FILE: pcdet/config.py
================================================
from pathlib import Path
import yaml
from easydict import EasyDict
def log_config_to_file(cfg, pre='cfg', logger=None):
for key, val in cfg.items():
if isinstance(cfg[key], EasyDict):
logger.info('\n%s.%s = edict()' % (pre, key))
log_config_to_file(cfg[key], pre=pre + '.' + key, logger=logger)
continue
logger.info('%s.%s: %s' % (pre, key, val))
def cfg_from_list(cfg_list, config):
"""Set config keys via list (e.g., from command line)."""
from ast import literal_eval
assert len(cfg_list) % 2 == 0
for k, v in zip(cfg_list[0::2], cfg_list[1::2]):
key_list = k.split('.')
d = config
for subkey in key_list[:-1]:
assert subkey in d, 'NotFoundKey: %s' % subkey
d = d[subkey]
subkey = key_list[-1]
assert subkey in d, 'NotFoundKey: %s' % subkey
try:
value = literal_eval(v)
except:
value = v
if type(value) != type(d[subkey]) and isinstance(d[subkey], EasyDict):
key_val_list = value.split(',')
for src in key_val_list:
cur_key, cur_val = src.split(':')
val_type = type(d[subkey][cur_key])
cur_val = val_type(cur_val)
d[subkey][cur_key] = cur_val
elif type(value) != type(d[subkey]) and isinstance(d[subkey], list):
val_list = value.split(',')
for k, x in enumerate(val_list):
val_list[k] = type(d[subkey][0])(x)
d[subkey] = val_list
else:
assert type(value) == type(d[subkey]), \
'type {} does not match original type {}'.format(type(value), type(d[subkey]))
d[subkey] = value
def merge_new_config(config, new_config):
if '_BASE_CONFIG_' in new_config:
with open(new_config['_BASE_CONFIG_'], 'r') as f:
try:
yaml_config = yaml.load(f, Loader=yaml.FullLoader)
except:
yaml_config = yaml.load(f)
config.update(EasyDict(yaml_config))
for key, val in new_config.items():
if not isinstance(val, dict):
config[key] = val
continue
if key not in config:
config[key] = EasyDict()
merge_new_config(config[key], val)
return config
def cfg_from_yaml_file(cfg_file, config):
with open(cfg_file, 'r') as f:
try:
new_config = yaml.load(f, Loader=yaml.FullLoader)
except:
new_config = yaml.load(f)
merge_new_config(config=config, new_config=new_config)
return config
cfg = EasyDict()
cfg.ROOT_DIR = (Path(__file__).resolve().parent / '../').resolve()
cfg.LOCAL_RANK = 0
================================================
FILE: pcdet/datasets/__init__.py
================================================
import torch
from torch.utils.data import DataLoader
from torch.utils.data import DistributedSampler as _DistributedSampler
from pcdet.utils import common_utils
from .dataset import DatasetTemplate
from .kitti.kitti_dataset import KittiDataset
from .kitti.kitti_dataset_mm import KittiDatasetMM
from prefetch_generator import BackgroundGenerator
__all__ = {
'DatasetTemplate': DatasetTemplate,
'KittiDataset': KittiDataset,
'KittiDatasetMM': KittiDatasetMM
}
class DataLoaderX(DataLoader):
def __iter__(self):
return BackgroundGenerator(super().__iter__())
class DistributedSampler(_DistributedSampler):
def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True):
super().__init__(dataset, num_replicas=num_replicas, rank=rank)
self.shuffle = shuffle
def __iter__(self):
if self.shuffle:
g = torch.Generator()
g.manual_seed(self.epoch)
indices = torch.randperm(len(self.dataset), generator=g).tolist()
else:
indices = torch.arange(len(self.dataset)).tolist()
indices += indices[:(self.total_size - len(indices))]
assert len(indices) == self.total_size
indices = indices[self.rank:self.total_size:self.num_replicas]
assert len(indices) == self.num_samples
return iter(indices)
def build_dataloader(dataset_cfg, class_names, batch_size, dist, root_path=None, workers=4,
logger=None, training=True, merge_all_iters_to_one_epoch=False, total_epochs=0):
dataset = __all__[dataset_cfg.DATASET](
dataset_cfg=dataset_cfg,
class_names=class_names,
root_path=root_path,
training=training,
logger=logger,
)
if merge_all_iters_to_one_epoch:
assert hasattr(dataset, 'merge_all_iters_to_one_epoch')
dataset.merge_all_iters_to_one_epoch(merge=True, epochs=total_epochs)
if dist:
if training:
sampler = torch.utils.data.distributed.DistributedSampler(dataset)
else:
rank, world_size = common_utils.get_dist_info()
sampler = DistributedSampler(dataset, world_size, rank, shuffle=False)
else:
sampler = None
dataloader = DataLoaderX(
dataset, batch_size=batch_size, pin_memory=True, num_workers=workers,
shuffle=(sampler is None) and training, collate_fn=dataset.collate_batch,
drop_last=False, sampler=sampler, timeout=0
)
return dataset, dataloader, sampler
================================================
FILE: pcdet/datasets/augmentor/X_transform.py
================================================
from functools import partial
import numpy as np
from ...utils import common_utils
from . import augmentor_utils
import copy
class X_TRANS(object):
def __init__(self, augmentor_configs=None, rot_num=1):
self.rot_num = rot_num
self.data_augmentor_queue = []
self.test_back_queue = []
if augmentor_configs is None:
augmentor_configs=[{'NAME': 'world_rotation',
'WORLD_ROT_ANGLE': [-0.78539816, 0.78539816]},
{'NAME': 'world_flip',
'ALONG_AXIS_LIST': [0, 1]},
{'NAME': 'world_scaling',
'WORLD_SCALE_RANGE': [0.95, 1.05]}]
self.augmentor_configs = augmentor_configs
else:
self.augmentor_configs = augmentor_configs
self.aug_config_list = augmentor_configs if isinstance(augmentor_configs, list) \
else augmentor_configs.AUG_CONFIG_LIST
for i, cur_cfg in enumerate(self.aug_config_list):
cur_augmentor = getattr(self, cur_cfg['NAME'])(config=cur_cfg)
self.data_augmentor_queue.append(cur_augmentor)
back_config = self.aug_config_list[-(i+1)]
cur_augmentor = getattr(self, back_config['NAME'])(config=back_config)
self.test_back_queue.append(cur_augmentor)
self.backward_flag = False
def get_params(self):
transform_param = np.zeros(shape=(self.rot_num, len(self.aug_config_list)))
for s in range(self.rot_num):
for i, config in enumerate(self.aug_config_list):
if config.NAME == 'world_rotation':
transform_param[s][i] = config.WORLD_ROT_ANGLE[s]
if config.NAME == 'world_flip':
transform_param[s][i] = config.ALONG_AXIS_LIST[s]
if config.NAME == 'world_scaling':
transform_param[s][i] = config.WORLD_SCALE_RANGE[s]
return transform_param
def world_rotation(self, data_dict=None, config=None):
if data_dict is None:
return partial(self.world_rotation, config=config)
rot_factor = data_dict['transform_param'][0]
if isinstance(rot_factor, np.float64):
rot_factor = np.array([rot_factor])
else:
rot_factor = rot_factor.unsqueeze(0)
if 'points' in data_dict:
points = data_dict['points']
if self.backward_flag:
points[:,0:3] = common_utils.rotate_points_along_z(points[np.newaxis, :, 0:3], -rot_factor)[0]
else:
points[:, 0:3] = common_utils.rotate_points_along_z(points[np.newaxis, :, 0:3], rot_factor)[0]
data_dict['points'] = points
if 'boxes' in data_dict:
boxes_lidar = data_dict['boxes']
if self.backward_flag:
boxes_lidar[:, 0:3] = common_utils.rotate_points_along_z(boxes_lidar[np.newaxis, :, 0:3], -rot_factor)[0]
boxes_lidar[:, 6] += -rot_factor
else:
boxes_lidar[:, 0:3] = common_utils.rotate_points_along_z(boxes_lidar[np.newaxis, :, 0:3], rot_factor)[0]
boxes_lidar[:, 6] += rot_factor
data_dict['boxes'] = boxes_lidar
return data_dict
def world_flip(self, data_dict=None, config=None):
if data_dict is None:
return partial(self.world_flip, config=config)
if 'points' in data_dict:
points = getattr(augmentor_utils, 'random_flip_with_param')(
data_dict['points'], data_dict['transform_param'][1], ax=1)
data_dict['points'] = points
if 'boxes' in data_dict:
boxes = getattr(augmentor_utils, 'random_flip_with_param')(
data_dict['boxes'], data_dict['transform_param'][1], ax=1)
boxes = getattr(augmentor_utils, 'random_flip_with_param')(
boxes, data_dict['transform_param'][1], ax=6)
data_dict['boxes'] = boxes
return data_dict
def world_scaling(self, data_dict=None, config=None):
if data_dict is None:
return partial(self.world_scaling, config=config)
scale_factor = data_dict['transform_param'][2]
if 'points' in data_dict:
points = data_dict['points']
if self.backward_flag:
points[:, 0:3] /= scale_factor
else:
points[:, 0:3] *= scale_factor
data_dict['points'] = points
if 'boxes' in data_dict:
boxes_lidar = data_dict['boxes']
if self.backward_flag:
boxes_lidar[:, 0:6] /= scale_factor
else:
boxes_lidar[:, 0:6] *= scale_factor
data_dict['boxes'] = boxes_lidar
return data_dict
def forward_with_param(self, data_dict):
"""
Args:
data_dict:
points: (N, 3 + C_in)
gt_boxes: optional, (N, 7) [x, y, z, dx, dy, dz, heading]
gt_names: optional, (N), string
...
Returns:
"""
for cur_augmentor in self.data_augmentor_queue:
data_dict = cur_augmentor(data_dict=data_dict)
return data_dict
def backward_with_param(self, data_dict):
"""
Args:
data_dict:
points: (N, 3 + C_in)
gt_boxes: optional, (N, 7) [x, y, z, dx, dy, dz, heading]
gt_names: optional, (N), string
...
Returns:
"""
self.backward_flag = True
for cur_augmentor in self.test_back_queue:
data_dict = cur_augmentor(data_dict=data_dict)
self.backward_flag = False
return data_dict
def input_transform(self, data_dict, trans_boxes=False):
"""
Args:
data_dict:
points: (N, 3 + C_in)
gt_boxes: optional, (N, 7) [x, y, z, dx, dy, dz, heading]
gt_names: optional, (N), string
...
Returns:
"""
params = self.get_params()
src_points = copy.deepcopy(data_dict['points'])
if trans_boxes:
src_gt_boxes = copy.deepcopy(data_dict['gt_boxes'])
for i in range(self.rot_num):
if i == 0:
rot_num_id = ''
else:
rot_num_id = str(i)
ini_data_dict = {}
ini_data_dict['points'] = copy.deepcopy(src_points)
if trans_boxes:
ini_data_dict['boxes'] = copy.deepcopy(src_gt_boxes)
ini_data_dict['transform_param'] = copy.deepcopy(params[i])
transformed_data = self.forward_with_param(ini_data_dict)
data_dict['points'+rot_num_id] = transformed_data['points']
if trans_boxes:
data_dict['gt_boxes'+rot_num_id] = transformed_data['boxes']
data_dict['transform_param'] = params
return data_dict
================================================
FILE: pcdet/datasets/augmentor/augmentor_utils.py
================================================
import numpy as np
import math
import copy
from ...utils import common_utils,box_np_ops
from ...utils import box_utils
import numba
def random_flip_along_x(gt_boxes, points):
"""
Args:
gt_boxes: (N, 7 + C), [x, y, z, dx, dy, dz, heading, [vx], [vy]]
points: (M, 3 + C)
Returns:
"""
enable = np.random.choice([False, True], replace=False, p=[0.5, 0.5])
if enable:
gt_boxes[:, 1] = -gt_boxes[:, 1]
gt_boxes[:, 6] = -gt_boxes[:, 6]
points[:, 1] = -points[:, 1]
if gt_boxes.shape[1] > 7:
gt_boxes[:, 8] = -gt_boxes[:, 8]
return gt_boxes, points,enable
def random_flip_with_param(points, enable, ax=1,offset = 0):
if enable and points is not None:
points[:, ax] = -(points[:, ax]+offset)
return points
def random_flip_along_y(gt_boxes, points):
"""
Args:
gt_boxes: (N, 7 + C), [x, y, z, dx, dy, dz, heading, [vx], [vy]]
points: (M, 3 + C)
Returns:
"""
enable = np.random.choice([False, True], replace=False, p=[0.5, 0.5])
if enable:
gt_boxes[:, 0] = -gt_boxes[:, 0]
gt_boxes[:, 6] = -(gt_boxes[:, 6] + np.pi)
points[:, 0] = -points[:, 0]
if gt_boxes.shape[1] > 7:
gt_boxes[:, 7] = -gt_boxes[:, 7]
return gt_boxes, points, enable
def global_rotation(gt_boxes, points, rot_range):
"""
Args:
gt_boxes: (N, 7 + C), [x, y, z, dx, dy, dz, heading, [vx], [vy]]
points: (M, 3 + C),
rot_range: [min, max]
Returns:
"""
noise_rotation = np.random.uniform(rot_range[0], rot_range[1])
points = common_utils.rotate_points_along_z(points[np.newaxis, :, :], np.array([noise_rotation]))[0]
gt_boxes[:, 0:3] = common_utils.rotate_points_along_z(gt_boxes[np.newaxis, :, 0:3], np.array([noise_rotation]))[0]
gt_boxes[:, 6] += noise_rotation
if gt_boxes.shape[1] > 7:
gt_boxes[:, 7:9] = common_utils.rotate_points_along_z(
np.hstack((gt_boxes[:, 7:9], np.zeros((gt_boxes.shape[0], 1))))[np.newaxis, :, :],
np.array([noise_rotation])
)[0][:, 0:2]
return gt_boxes, points, noise_rotation
def global_rotation_with_param(batch_dict, noise_rotation=None,num_frames=2):
for i in range(num_frames):
if i == 0:
batch_dict['points'] = common_utils.rotate_points_along_z(batch_dict['points'][np.newaxis, :, :], np.array([noise_rotation]))[0]
batch_dict['gt_boxes'][:,0:3] = common_utils.rotate_points_along_z(batch_dict['gt_boxes'][np.newaxis, :, 0:3], np.array([noise_rotation]))[0]
batch_dict['gt_boxes'][:, 6]+=noise_rotation
batch_dict['gt_tracklets'][:, 0:3] = common_utils.rotate_points_along_z(batch_dict['gt_tracklets'][np.newaxis, :, 0:3], np.array([noise_rotation]))[0]
batch_dict['gt_tracklets'][:, 6] += noise_rotation
if 'points'+str(-i) in batch_dict:
batch_dict['points'+str(-i)] = common_utils.rotate_points_along_z(batch_dict['points'+str(-i)][np.newaxis, :, :], np.array([noise_rotation]))[0]
begin_id = 7+(i-1)*4
batch_dict['gt_tracklets'][:, begin_id:begin_id+3] = common_utils.rotate_points_along_z(batch_dict['gt_tracklets'][np.newaxis, :, begin_id:begin_id+3],np.array([noise_rotation]))[0]
batch_dict['gt_tracklets'][:, begin_id + 3]+=noise_rotation
if 'gt_boxes'+str(-i) in batch_dict:
batch_dict['gt_boxes'+str(-i)][:, :3] = \
common_utils.rotate_points_along_z(batch_dict['gt_boxes'+str(-i)][np.newaxis, :, :3],
np.array([noise_rotation]))[0]
batch_dict['gt_boxes' + str(-i)][:, 6] +=noise_rotation
return batch_dict
def boxes_rotation_with_param(boxes, noise_rotation=None):
boxes[:,0:3] = common_utils.rotate_points_along_z(boxes[np.newaxis, :, 0:3], np.array([noise_rotation]))[0]
boxes[:, 6]+=noise_rotation
return boxes
def global_scaling(gt_boxes, points, scale_range):
"""
Args:
gt_boxes: (N, 7), [x, y, z, dx, dy, dz, heading]
points: (M, 3 + C),
scale_range: [min, max]
Returns:
"""
if scale_range[1] - scale_range[0] < 1e-3:
return gt_boxes, points
noise_scale = np.random.uniform(scale_range[0], scale_range[1])
points[:, :3] *= noise_scale
gt_boxes[:, :6] *= noise_scale
return gt_boxes, points, noise_scale
def global_scaling_with_param(batch_dict, noise_scale=None,num_frames=2):
for i in range(num_frames):
if i==0:
batch_dict['points'][:,0:3]*=noise_scale
batch_dict['gt_boxes'][:, 0:6] *= noise_scale
batch_dict['gt_tracklets'][:, 0:6]*=noise_scale
if 'points'+str(-i) in batch_dict:
begin_id = 7 + (i - 1) * 4
batch_dict['points'+str(-i)][:, 0:3] *= noise_scale
batch_dict['gt_tracklets'][:, begin_id:begin_id+3] *= noise_scale
if 'gt_boxes' + str(-i) in batch_dict:
batch_dict['gt_boxes' + str(-i)][:, 0:6] *= noise_scale
return batch_dict
def get_points_in_box(points, gt_box):
x, y, z = points[:, 0], points[:, 1], points[:, 2]
cx, cy, cz = gt_box[0], gt_box[1], gt_box[2]
dx, dy, dz, rz = gt_box[3], gt_box[4], gt_box[5], gt_box[6]
shift_x, shift_y, shift_z = x - cx, y - cy, z - cz
MARGIN = 1e-1
cosa, sina = math.cos(-rz), math.sin(-rz)
local_x = shift_x * cosa + shift_y * (-sina)
local_y = shift_x * sina + shift_y * cosa
mask = np.logical_and(abs(shift_z) <= dz / 2.0,
np.logical_and(abs(local_x) <= dx / 2.0 + MARGIN,
abs(local_y) <= dy / 2.0 + MARGIN))
points = points[mask]
return points, mask
def get_pyramids(boxes):
pyramid_orders = np.array([
[0, 1, 5, 4],
[4, 5, 6, 7],
[7, 6, 2, 3],
[3, 2, 1, 0],
[1, 2, 6, 5],
[0, 4, 7, 3]
])
boxes_corners = box_utils.boxes_to_corners_3d(boxes).reshape(-1, 24)
pyramid_list = []
for order in pyramid_orders:
# frustum polygon: 5 corners, 5 surfaces
pyramid = np.concatenate((
boxes[:, 0:3],
boxes_corners[:, 3 * order[0]: 3 * order[0] + 3],
boxes_corners[:, 3 * order[1]: 3 * order[1] + 3],
boxes_corners[:, 3 * order[2]: 3 * order[2] + 3],
boxes_corners[:, 3 * order[3]: 3 * order[3] + 3]), axis=1)
pyramid_list.append(pyramid[:, None, :])
pyramids = np.concatenate(pyramid_list, axis=1) # [N, 6, 15], 15=5*3
return pyramids
def one_hot(x, num_class=1):
if num_class is None:
num_class = 1
ohx = np.zeros((len(x), num_class))
ohx[range(len(x)), x] = 1
return ohx
def points_in_pyramids_mask(points, pyramids):
pyramids = pyramids.reshape(-1, 5, 3)
flags = np.zeros((points.shape[0], pyramids.shape[0]), dtype=np.bool)
for i, pyramid in enumerate(pyramids):
flags[:, i] = np.logical_or(flags[:, i], box_utils.in_hull(points[:, 0:3], pyramid))
return flags
def local_pyramid_dropout(gt_boxes, points, dropout_prob, pyramids=None):
if pyramids is None:
pyramids = get_pyramids(gt_boxes).reshape([-1, 6, 5, 3]) # each six surface of boxes: [num_boxes, 6, 15=3*5]
drop_pyramid_indices = np.random.randint(0, 6, (pyramids.shape[0]))
drop_pyramid_one_hot = one_hot(drop_pyramid_indices, num_class=6)
drop_box_mask = np.random.uniform(0, 1, (pyramids.shape[0])) <= dropout_prob
if np.sum(drop_box_mask) != 0:
drop_pyramid_mask = (np.tile(drop_box_mask[:, None], [1, 6]) * drop_pyramid_one_hot) > 0
drop_pyramids = pyramids[drop_pyramid_mask]
point_masks = points_in_pyramids_mask(points, drop_pyramids)
points = points[np.logical_not(point_masks.any(-1))]
# print(drop_box_mask)
pyramids = pyramids[np.logical_not(drop_box_mask)]
return gt_boxes, points, pyramids
def local_pyramid_sparsify(gt_boxes, points, prob, max_num_pts, pyramids=None):
if pyramids is None:
pyramids = get_pyramids(gt_boxes).reshape([-1, 6, 5, 3]) # each six surface of boxes: [num_boxes, 6, 15=3*5]
if pyramids.shape[0] > 0:
sparsity_prob, sparsity_num = prob, max_num_pts
sparsify_pyramid_indices = np.random.randint(0, 6, (pyramids.shape[0]))
sparsify_pyramid_one_hot = one_hot(sparsify_pyramid_indices, num_class=6)
sparsify_box_mask = np.random.uniform(0, 1, (pyramids.shape[0])) <= sparsity_prob
sparsify_pyramid_mask = (np.tile(sparsify_box_mask[:, None], [1, 6]) * sparsify_pyramid_one_hot) > 0
# print(sparsify_box_mask)
pyramid_sampled = pyramids[sparsify_pyramid_mask] # (-1,6,5,3)[(num_sample,6)]
# print(pyramid_sampled.shape)
pyramid_sampled_point_masks = points_in_pyramids_mask(points, pyramid_sampled)
pyramid_sampled_points_num = pyramid_sampled_point_masks.sum(0) # the number of points in each surface pyramid
valid_pyramid_sampled_mask = pyramid_sampled_points_num > sparsity_num # only much than sparsity_num should be sparse
sparsify_pyramids = pyramid_sampled[valid_pyramid_sampled_mask]
if sparsify_pyramids.shape[0] > 0:
point_masks = pyramid_sampled_point_masks[:, valid_pyramid_sampled_mask]
remain_points = points[
np.logical_not(point_masks.any(-1))] # points which outside the down sampling pyramid
to_sparsify_points = [points[point_masks[:, i]] for i in range(point_masks.shape[1])]
sparsified_points = []
for sample in to_sparsify_points:
sampled_indices = np.random.choice(sample.shape[0], size=sparsity_num, replace=False)
sparsified_points.append(sample[sampled_indices])
sparsified_points = np.concatenate(sparsified_points, axis=0)
points = np.concatenate([remain_points, sparsified_points], axis=0)
pyramids = pyramids[np.logical_not(sparsify_box_mask)]
return gt_boxes, points, pyramids
def local_pyramid_swap(gt_boxes, points, prob, max_num_pts, pyramids=None):
def get_points_ratio(points, pyramid):
surface_center = (pyramid[3:6] + pyramid[6:9] + pyramid[9:12] + pyramid[12:]) / 4.0
vector_0, vector_1, vector_2 = pyramid[6:9] - pyramid[3:6], pyramid[12:] - pyramid[3:6], pyramid[
0:3] - surface_center
alphas = ((points[:, 0:3] - pyramid[3:6]) * vector_0).sum(-1) / np.power(vector_0, 2).sum()
betas = ((points[:, 0:3] - pyramid[3:6]) * vector_1).sum(-1) / np.power(vector_1, 2).sum()
gammas = ((points[:, 0:3] - surface_center) * vector_2).sum(-1) / np.power(vector_2, 2).sum()
return [alphas, betas, gammas]
def recover_points_by_ratio(points_ratio, pyramid):
alphas, betas, gammas = points_ratio
surface_center = (pyramid[3:6] + pyramid[6:9] + pyramid[9:12] + pyramid[12:]) / 4.0
vector_0, vector_1, vector_2 = pyramid[6:9] - pyramid[3:6], pyramid[12:] - pyramid[3:6], pyramid[
0:3] - surface_center
points = (alphas[:, None] * vector_0 + betas[:, None] * vector_1) + pyramid[3:6] + gammas[:, None] * vector_2
return points
def recover_points_intensity_by_ratio(points_intensity_ratio, max_intensity, min_intensity):
return points_intensity_ratio * (max_intensity - min_intensity) + min_intensity
# swap partition
if pyramids is None:
pyramids = get_pyramids(gt_boxes).reshape([-1, 6, 5, 3]) # each six surface of boxes: [num_boxes, 6, 15=3*5]
swap_prob, num_thres = prob, max_num_pts
swap_pyramid_mask = np.random.uniform(0, 1, (pyramids.shape[0])) <= swap_prob
if swap_pyramid_mask.sum() > 0:
point_masks = points_in_pyramids_mask(points, pyramids)
point_nums = point_masks.sum(0).reshape(pyramids.shape[0], -1) # [N, 6]
non_zero_pyramids_mask = point_nums > num_thres # ingore dropout pyramids or highly occluded pyramids
selected_pyramids = non_zero_pyramids_mask * swap_pyramid_mask[:,
None] # selected boxes and all their valid pyramids
# print(selected_pyramids)
if selected_pyramids.sum() > 0:
# get to_swap pyramids
index_i, index_j = np.nonzero(selected_pyramids)
selected_pyramid_indices = [np.random.choice(index_j[index_i == i]) \
if e and (index_i == i).any() else 0 for i, e in
enumerate(swap_pyramid_mask)]
selected_pyramids_mask = selected_pyramids * one_hot(selected_pyramid_indices, num_class=6) == 1
to_swap_pyramids = pyramids[selected_pyramids_mask]
# get swapped pyramids
index_i, index_j = np.nonzero(selected_pyramids_mask)
non_zero_pyramids_mask[selected_pyramids_mask] = False
swapped_index_i = np.array([np.random.choice(np.where(non_zero_pyramids_mask[:, j])[0]) if \
np.where(non_zero_pyramids_mask[:, j])[0].shape[0] > 0 else
index_i[i] for i, j in enumerate(index_j.tolist())])
swapped_indicies = np.concatenate([swapped_index_i[:, None], index_j[:, None]], axis=1)
swapped_pyramids = pyramids[
swapped_indicies[:, 0].astype(np.int32), swapped_indicies[:, 1].astype(np.int32)]
# concat to_swap&swapped pyramids
swap_pyramids = np.concatenate([to_swap_pyramids, swapped_pyramids], axis=0)
swap_point_masks = points_in_pyramids_mask(points, swap_pyramids)
remain_points = points[np.logical_not(swap_point_masks.any(-1))]
# swap pyramids
points_res = []
num_swapped_pyramids = swapped_pyramids.shape[0]
for i in range(num_swapped_pyramids):
to_swap_pyramid = to_swap_pyramids[i]
swapped_pyramid = swapped_pyramids[i]
to_swap_points = points[swap_point_masks[:, i]]
swapped_points = points[swap_point_masks[:, i + num_swapped_pyramids]]
# for intensity transform
to_swap_points_intensity_ratio = (to_swap_points[:, 3:] - to_swap_points[:, 3:].min()) / \
np.clip(
(to_swap_points[:, 3:].max() - to_swap_points[:, 3:].min()),
1e-6, 1)
swapped_points_intensity_ratio = (swapped_points[:, 3:] - swapped_points[:, 3:].min()) / \
np.clip(
(swapped_points[:, 3:].max() - swapped_points[:, 3:].min()),
1e-6, 1)
to_swap_points_ratio = get_points_ratio(to_swap_points, to_swap_pyramid.reshape(15))
swapped_points_ratio = get_points_ratio(swapped_points, swapped_pyramid.reshape(15))
new_to_swap_points = recover_points_by_ratio(swapped_points_ratio, to_swap_pyramid.reshape(15))
new_swapped_points = recover_points_by_ratio(to_swap_points_ratio, swapped_pyramid.reshape(15))
# for intensity transform
new_to_swap_points_intensity = recover_points_intensity_by_ratio(
swapped_points_intensity_ratio, to_swap_points[:, 3:].max(),
to_swap_points[:, 3:].min())
new_swapped_points_intensity = recover_points_intensity_by_ratio(
to_swap_points_intensity_ratio, swapped_points[:, 3:].max(),
swapped_points[:, 3:].min())
# new_to_swap_points = np.concatenate([new_to_swap_points, swapped_points[:, -1:]], axis=1)
# new_swapped_points = np.concatenate([new_swapped_points, to_swap_points[:, -1:]], axis=1)
new_to_swap_points = np.concatenate([new_to_swap_points, new_to_swap_points_intensity], axis=1)
new_swapped_points = np.concatenate([new_swapped_points, new_swapped_points_intensity], axis=1)
points_res.append(new_to_swap_points)
points_res.append(new_swapped_points)
points_res = np.concatenate(points_res, axis=0)
points = np.concatenate([remain_points, points_res], axis=0)
return gt_boxes, points
def noise_per_object_v3_(gt_boxes,
points=None,
points_pseudo=None,
valid_mask=None,
rotation_perturb=np.pi / 4,
center_noise_std=1.0,
global_random_rot_range=np.pi / 4,
data_aug_with_context=-1.0,
num_try=100):
"""Random rotate or remove each groundtruth independently. use kitti viewer
to test this function points_transform_
Args:
gt_boxes (np.ndarray): Ground truth boxes with shape (N, 7).
points (np.ndarray | None): Input point cloud with shape (M, 4).
Default: None.
valid_mask (np.ndarray | None): Mask to indicate which boxes are valid.
Default: None.
rotation_perturb (float): Rotation perturbation. Default: pi / 4.
center_noise_std (float): Center noise standard deviation.
Default: 1.0.
global_random_rot_range (float): Global random rotation range.
Default: pi/4.
num_try (int): Number of try. Default: 100.
"""
num_boxes = gt_boxes.shape[0]
if not isinstance(rotation_perturb, (list, tuple, np.ndarray)):
rotation_perturb = [-rotation_perturb, rotation_perturb]
if not isinstance(global_random_rot_range, (list, tuple, np.ndarray)):
global_random_rot_range = [
-global_random_rot_range, global_random_rot_range
]
enable_grot = np.abs(global_random_rot_range[0] -
global_random_rot_range[1]) >= 1e-3
if not isinstance(center_noise_std, (list, tuple, np.ndarray)):
center_noise_std = [
center_noise_std, center_noise_std, center_noise_std
]
if valid_mask is None:
valid_mask = np.ones((num_boxes, ), dtype=np.bool_)
center_noise_std = np.array(center_noise_std, dtype=gt_boxes.dtype)
loc_noises = np.random.normal(
scale=center_noise_std, size=[num_boxes, num_try, 3])
rot_noises = np.random.uniform(
rotation_perturb[0], rotation_perturb[1], size=[num_boxes, num_try])
global_rot_noises = np.random.uniform(
global_random_rot_range[0],
global_random_rot_range[1],
size=[num_boxes, num_try])
origin = (0.5, 0.5, 0.5)
offset = np.array([0.0, 0.0, 0.0, data_aug_with_context[0], data_aug_with_context[1], data_aug_with_context[2], 0.0])
gt_box_corners = box_np_ops.center_to_corner_box3d(
gt_boxes[:, :3],
gt_boxes[:, 3:6] + offset[3:6],
gt_boxes[:, 6],
origin=origin,
axis=2)
if not enable_grot:
selected_noise = noise_per_box(gt_boxes[:, [0, 1, 3, 4, 6]] + offset[[0, 1, 3, 4, 6]],
valid_mask, loc_noises, rot_noises)
else:
selected_noise = noise_per_box_v2_(gt_boxes[:, [0, 1, 3, 4, 6]] + offset[[0, 1, 3, 4, 6]],
valid_mask, loc_noises, rot_noises,
global_rot_noises)
loc_transforms = _select_transform(loc_noises, selected_noise)
rot_transforms = _select_transform(rot_noises, selected_noise)
surfaces = box_np_ops.corner_to_surfaces_3d_jit(gt_box_corners)
if points is not None:
point_masks = box_np_ops.points_in_convex_polygon_3d_jit(
points[:, :3], surfaces)
points_transform_(points, gt_boxes[:, :3], point_masks, loc_transforms,
rot_transforms, valid_mask)
if points_pseudo is not None:
point_pseudo_masks = box_np_ops.points_in_convex_polygon_3d_jit(
points_pseudo[:, :3], surfaces)
points_transform_(points_pseudo, gt_boxes[:, :3], point_pseudo_masks, loc_transforms,
rot_transforms, valid_mask)
box3d_transform_(gt_boxes, loc_transforms, rot_transforms, valid_mask)
@numba.njit
def _rotation_box2d_jit_(corners, angle, rot_mat_T):
"""Rotate 2D boxes.
Args:
corners (np.ndarray): Corners of boxes.
angle (float): Rotation angle.
rot_mat_T (np.ndarray): Transposed rotation matrix.
"""
rot_sin = np.sin(angle)
rot_cos = np.cos(angle)
rot_mat_T[0, 0] = rot_cos
rot_mat_T[0, 1] = -rot_sin
rot_mat_T[1, 0] = rot_sin
rot_mat_T[1, 1] = rot_cos
corners[:] = corners @ rot_mat_T
@numba.jit(nopython=True)
def box_collision_test(boxes, qboxes, clockwise=True):
"""Box collision test.
Args:
boxes (np.ndarray): Corners of current boxes.
qboxes (np.ndarray): Boxes to be avoid colliding.
clockwise (bool): Whether the corners are in clockwise order.
Default: True.
"""
N = boxes.shape[0]
K = qboxes.shape[0]
ret = np.zeros((N, K), dtype=np.bool_)
slices = np.array([1, 2, 3, 0])
lines_boxes = np.stack((boxes, boxes[:, slices, :]),
axis=2) # [N, 4, 2(line), 2(xy)]
lines_qboxes = np.stack((qboxes, qboxes[:, slices, :]), axis=2)
# vec = np.zeros((2,), dtype=boxes.dtype)
boxes_standup = box_np_ops.corner_to_standup_nd_jit(boxes)
qboxes_standup = box_np_ops.corner_to_standup_nd_jit(qboxes)
for i in range(N):
for j in range(K):
# calculate standup first
iw = (
min(boxes_standup[i, 2], qboxes_standup[j, 2]) -
max(boxes_standup[i, 0], qboxes_standup[j, 0]))
if iw > 0:
ih = (
min(boxes_standup[i, 3], qboxes_standup[j, 3]) -
max(boxes_standup[i, 1], qboxes_standup[j, 1]))
if ih > 0:
for k in range(4):
for box_l in range(4):
A = lines_boxes[i, k, 0]
B = lines_boxes[i, k, 1]
C = lines_qboxes[j, box_l, 0]
D = lines_qboxes[j, box_l, 1]
acd = (D[1] - A[1]) * (C[0] -
A[0]) > (C[1] - A[1]) * (
D[0] - A[0])
bcd = (D[1] - B[1]) * (C[0] -
B[0]) > (C[1] - B[1]) * (
D[0] - B[0])
if acd != bcd:
abc = (C[1] - A[1]) * (B[0] - A[0]) > (
B[1] - A[1]) * (
C[0] - A[0])
abd = (D[1] - A[1]) * (B[0] - A[0]) > (
B[1] - A[1]) * (
D[0] - A[0])
if abc != abd:
ret[i, j] = True # collision.
break
if ret[i, j] is True:
break
if ret[i, j] is False:
# now check complete overlap.
# box overlap qbox:
box_overlap_qbox = True
for box_l in range(4): # point l in qboxes
for k in range(4): # corner k in boxes
vec = boxes[i, k] - boxes[i, (k + 1) % 4]
if clockwise:
vec = -vec
cross = vec[1] * (
boxes[i, k, 0] - qboxes[j, box_l, 0])
cross -= vec[0] * (
boxes[i, k, 1] - qboxes[j, box_l, 1])
if cross >= 0:
box_overlap_qbox = False
break
if box_overlap_qbox is False:
break
if box_overlap_qbox is False:
qbox_overlap_box = True
for box_l in range(4): # point box_l in boxes
for k in range(4): # corner k in qboxes
vec = qboxes[j, k] - qboxes[j, (k + 1) % 4]
if clockwise:
vec = -vec
cross = vec[1] * (
qboxes[j, k, 0] - boxes[i, box_l, 0])
cross -= vec[0] * (
qboxes[j, k, 1] - boxes[i, box_l, 1])
if cross >= 0: #
qbox_overlap_box = False
break
if qbox_overlap_box is False:
break
if qbox_overlap_box:
ret[i, j] = True # collision.
else:
ret[i, j] = True # collision.
return ret
@numba.njit
def noise_per_box(boxes, valid_mask, loc_noises, rot_noises):
"""Add noise to every box (only on the horizontal plane).
Args:
boxes (np.ndarray): Input boxes with shape (N, 5).
valid_mask (np.ndarray): Mask to indicate which boxes are valid
with shape (N).
loc_noises (np.ndarray): Location noises with shape (N, M, 3).
rot_noises (np.ndarray): Rotation noises with shape (N, M).
Returns:
np.ndarray: Mask to indicate whether the noise is
added successfully (pass the collision test).
"""
num_boxes = boxes.shape[0]
num_tests = loc_noises.shape[1]
box_corners = box_np_ops.box2d_to_corner_jit(boxes)
current_corners = np.zeros((4, 2), dtype=boxes.dtype)
rot_mat_T = np.zeros((2, 2), dtype=boxes.dtype)
success_mask = -np.ones((num_boxes, ), dtype=np.int64)
for i in range(num_boxes):
if valid_mask[i]:
for j in range(num_tests):
current_corners[:] = box_corners[i]
current_corners -= boxes[i, :2]
_rotation_box2d_jit_(current_corners, rot_noises[i, j],
rot_mat_T)
current_corners += boxes[i, :2] + loc_noises[i, j, :2]
coll_mat = box_collision_test(
current_corners.reshape(1, 4, 2), box_corners)
coll_mat[0, i] = False
# print(coll_mat)
if not coll_mat.any():
success_mask[i] = j
box_corners[i] = current_corners
break
return success_mask
@numba.njit
def noise_per_box_v2_(boxes, valid_mask, loc_noises, rot_noises,
global_rot_noises):
"""Add noise to every box (only on the horizontal plane). Version 2 used
when enable global rotations.
Args:
boxes (np.ndarray): Input boxes with shape (N, 5).
valid_mask (np.ndarray): Mask to indicate which boxes are valid
with shape (N).
loc_noises (np.ndarray): Location noises with shape (N, M, 3).
rot_noises (np.ndarray): Rotation noises with shape (N, M).
Returns:
np.ndarray: Mask to indicate whether the noise is
added successfully (pass the collision test).
"""
num_boxes = boxes.shape[0]
num_tests = loc_noises.shape[1]
box_corners = box_np_ops.box2d_to_corner_jit(boxes)
current_corners = np.zeros((4, 2), dtype=boxes.dtype)
current_box = np.zeros((1, 5), dtype=boxes.dtype)
rot_mat_T = np.zeros((2, 2), dtype=boxes.dtype)
dst_pos = np.zeros((2, ), dtype=boxes.dtype)
success_mask = -np.ones((num_boxes, ), dtype=np.int64)
corners_norm = np.zeros((4, 2), dtype=boxes.dtype)
corners_norm[1, 1] = 1.0
corners_norm[2] = 1.0
corners_norm[3, 0] = 1.0
corners_norm -= np.array([0.5, 0.5], dtype=boxes.dtype)
corners_norm = corners_norm.reshape(4, 2)
for i in range(num_boxes):
if valid_mask[i]:
for j in range(num_tests):
current_box[0, :] = boxes[i]
# current_radius = np.sqrt(boxes[i, 0]**2 + boxes[i, 1]**2)
# current_grot = np.arctan2(boxes[i, 0], boxes[i, 1])
# dst_grot = current_grot + global_rot_noises[i, j]
# dst_pos[0] = current_radius * np.sin(dst_grot)
# dst_pos[1] = current_radius * np.cos(dst_grot)
dst_pos[0] = boxes[i, 0] * np.cos(global_rot_noises[i, j]) + boxes[i, 1] * np.sin(global_rot_noises[i, j])
dst_pos[1] = -boxes[i, 0] * np.sin(global_rot_noises[i, j]) + boxes[i, 1] * np.cos(global_rot_noises[i, j])
current_box[0, :2] = dst_pos
# current_box[0, -1] += (dst_grot - current_grot)
current_box[0, -1] += global_rot_noises[i, j]
rot_sin = np.sin(current_box[0, -1])
rot_cos = np.cos(current_box[0, -1])
rot_mat_T[0, 0] = rot_cos
rot_mat_T[0, 1] = -rot_sin
rot_mat_T[1, 0] = rot_sin
rot_mat_T[1, 1] = rot_cos
current_corners[:] = current_box[
0, 2:4] * corners_norm @ rot_mat_T + current_box[0, :2]
current_corners -= current_box[0, :2]
_rotation_box2d_jit_(current_corners, rot_noises[i, j],
rot_mat_T)
current_corners += current_box[0, :2] + loc_noises[i, j, :2]
coll_mat = box_collision_test(
current_corners.reshape(1, 4, 2), box_corners)
coll_mat[0, i] = False
if not coll_mat.any():
success_mask[i] = j
box_corners[i] = current_corners
loc_noises[i, j, :2] += (dst_pos - boxes[i, :2])
# rot_noises[i, j] += (dst_grot - current_grot)
rot_noises[i, j] += global_rot_noises[i, j]
break
return success_mask
def _select_transform(transform, indices):
"""Select transform.
Args:
transform (np.ndarray): Transforms to select from.
indices (np.ndarray): Mask to indicate which transform to select.
Returns:
np.ndarray: Selected transforms.
"""
result = np.zeros((transform.shape[0], *transform.shape[2:]),
dtype=transform.dtype)
for i in range(transform.shape[0]):
if indices[i] != -1:
result[i] = transform[i, indices[i]]
return result
@numba.njit
def _rotation_matrix_3d_(rot_mat_T, angle, axis):
"""Get the 3D rotation matrix.
Args:
rot_mat_T (np.ndarray): Transposed rotation matrix.
angle (float): Rotation angle.
axis (int): Rotation axis.
"""
rot_sin = np.sin(angle)
rot_cos = np.cos(angle)
rot_mat_T[:] = np.eye(3)
if axis == 1:
rot_mat_T[0, 0] = rot_cos
rot_mat_T[0, 2] = -rot_sin
rot_mat_T[2, 0] = rot_sin
rot_mat_T[2, 2] = rot_cos
elif axis == 2 or axis == -1:
rot_mat_T[0, 0] = rot_cos
rot_mat_T[0, 1] = -rot_sin
rot_mat_T[1, 0] = rot_sin
rot_mat_T[1, 1] = rot_cos
elif axis == 0:
rot_mat_T[1, 1] = rot_cos
rot_mat_T[1, 2] = -rot_sin
rot_mat_T[2, 1] = rot_sin
rot_mat_T[2, 2] = rot_cos
@numba.njit
def points_transform_(points, centers, point_masks, loc_transform,
rot_transform, valid_mask):
"""Apply transforms to points and box centers.
Args:
points (np.ndarray): Input points.
centers (np.ndarray): Input box centers.
point_masks (np.ndarray): Mask to indicate which points need
to be transformed.
loc_transform (np.ndarray): Location transform to be applied.
rot_transform (np.ndarray): Rotation transform to be applied.
valid_mask (np.ndarray): Mask to indicate which boxes are valid.
"""
num_box = centers.shape[0]
num_points = points.shape[0]
rot_mat_T = np.zeros((num_box, 3, 3), dtype=points.dtype)
for i in range(num_box):
_rotation_matrix_3d_(rot_mat_T[i], rot_transform[i], 2)
for i in range(num_points):
for j in range(num_box):
if valid_mask[j]:
if point_masks[i, j] == 1:
points[i, :3] -= centers[j, :3]
points[i:i + 1, :3] = points[i:i + 1, :3] @ rot_mat_T[j]
points[i, :3] += centers[j, :3]
points[i, :3] += loc_transform[j]
break # only apply first box's transform
@numba.njit
def box3d_transform_(boxes, loc_transform, rot_transform, valid_mask):
"""Transform 3D boxes.
Args:
boxes (np.ndarray): 3D boxes to be transformed.
loc_transform (np.ndarray): Location transform to be applied.
rot_transform (np.ndarray): Rotation transform to be applied.
valid_mask (np.ndarray | None): Mask to indicate which boxes are valid.
"""
num_box = boxes.shape[0]
for i in range(num_box):
if valid_mask[i]:
boxes[i, :3] += loc_transform[i]
boxes[i, 6] += rot_transform[i]
================================================
FILE: pcdet/datasets/augmentor/data_augmentor.py
================================================
from functools import partial
import numpy as np
from ...utils import common_utils
from . import augmentor_utils, database_sampler
class DataAugmentor(object):
def __init__(self, root_path, augmentor_configs, class_names, logger=None):
self.root_path = root_path
self.class_names = class_names
self.logger = logger
self.data_augmentor_queue = []
aug_config_list = augmentor_configs if isinstance(augmentor_configs, list) \
else augmentor_configs.AUG_CONFIG_LIST
for cur_cfg in aug_config_list:
if not isinstance(augmentor_configs, list):
if cur_cfg.NAME in augmentor_configs.DISABLE_AUG_LIST:
continue
cur_augmentor = getattr(self, cur_cfg.NAME)(config=cur_cfg)
self.data_augmentor_queue.append(cur_augmentor)
def gt_sampling(self, config=None):
db_sampler = database_sampler.DataBaseSampler(
root_path=self.root_path,
sampler_cfg=config,
class_names=self.class_names,
logger=self.logger,
)
return db_sampler
def da_sampling(self, config=None):
db_sampler = database_sampler.DADataBaseSampler(
root_path=self.root_path,
sampler_cfg=config,
class_names=self.class_names,
logger=self.logger,
)
return db_sampler
def __getstate__(self):
d = dict(self.__dict__)
del d['logger']
return d
def __setstate__(self, d):
self.__dict__.update(d)
def random_world_rotation(self, data_dict=None, config=None):
if data_dict is None:
return partial(self.random_world_rotation, config=config)
rot_range = config['WORLD_ROT_ANGLE']
if not isinstance(rot_range, list):
rot_range = [-rot_range, rot_range]
gt_boxes, points, param = augmentor_utils.global_rotation(
data_dict['gt_boxes'], data_dict['points'], rot_range=rot_range
)
data_dict['gt_boxes'] = gt_boxes
data_dict['points'] = points
aug_param=[param]
data_dict['aug_param'] = aug_param
return data_dict
def random_world_flip(self, data_dict=None, config=None):
if data_dict is None:
return partial(self.random_world_flip, config=config)
gt_boxes, points = data_dict['gt_boxes'], data_dict['points']
for cur_axis in config['ALONG_AXIS_LIST']:
assert cur_axis in ['x', 'y']
gt_boxes, points, param = getattr(augmentor_utils, 'random_flip_along_%s' % cur_axis)(
gt_boxes, points,
)
data_dict['gt_boxes'] = gt_boxes
data_dict['points'] = points
if 'aug_param' in data_dict:
data_dict['aug_param'].append(int(param))
else:
data_dict['aug_param'] = [param]
return data_dict
def random_world_scaling(self, data_dict=None, config=None):
if data_dict is None:
return partial(self.random_world_scaling, config=config)
gt_boxes, points, param = augmentor_utils.global_scaling(
data_dict['gt_boxes'], data_dict['points'], config['WORLD_SCALE_RANGE']
)
data_dict['gt_boxes'] = gt_boxes
data_dict['points'] = points
if 'aug_param' in data_dict:
data_dict['aug_param'].append(param)
else:
data_dict['aug_param'] = [param]
return data_dict
def random_local_noise(self, data_dict=None, config=None):
if data_dict is None:
return partial(self.random_local_noise, config=config)
data_dict['gt_boxes'][:, 6] = -data_dict['gt_boxes'][:, 6]
augmentor_utils.noise_per_object_v3_(data_dict['gt_boxes'], data_dict['points'], None,
data_dict.get('valid_noise', None),
config['LOCAL_ROT_RANGE'], config['TRANSLATION_STD'],
config['GLOBAL_ROT_RANGE'], config['EXTRA_WIDTH'])
data_dict['gt_boxes'][:, 6] = -data_dict['gt_boxes'][:, 6]
if 'valid_noise' in data_dict:
data_dict.pop('valid_noise')
return data_dict
def random_local_pyramid_aug(self, data_dict=None, config=None):
"""
Refer to the paper:
SE-SSD: Self-Ensembling Single-Stage Object Detector From Point Cloud
"""
if data_dict is None:
return partial(self.random_local_pyramid_aug, config=config)
gt_boxes, points = data_dict['gt_boxes'], data_dict['points']
gt_boxes, points, pyramids = augmentor_utils.local_pyramid_dropout(gt_boxes, points, config['DROP_PROB'])
gt_boxes, points, pyramids = augmentor_utils.local_pyramid_sparsify(gt_boxes, points,
config['SPARSIFY_PROB'],
config['SPARSIFY_MAX_NUM'],
pyramids)
gt_boxes, points = augmentor_utils.local_pyramid_swap(gt_boxes, points,
config['SWAP_PROB'],
config['SWAP_MAX_NUM'],
pyramids)
data_dict['gt_boxes'] = gt_boxes
data_dict['points'] = points
return data_dict
def forward(self, data_dict):
"""
Args:
data_dict:
points: (N, 3 + C_in)
gt_boxes: optional, (N, 7) [x, y, z, dx, dy, dz, heading]
gt_names: optional, (N), string
...
Returns:
"""
for cur_augmentor in self.data_augmentor_queue:
data_dict = cur_augmentor(data_dict=data_dict)
data_dict['gt_boxes'][:, 6] = common_utils.limit_period(
data_dict['gt_boxes'][:, 6], offset=0.5, period=2 * np.pi
)
if 'aug_param' in data_dict:
data_dict['aug_param'] = np.array(data_dict['aug_param'])
if 'calib' in data_dict:
data_dict.pop('calib')
if 'road_plane' in data_dict:
data_dict.pop('road_plane')
return data_dict
================================================
FILE: pcdet/datasets/augmentor/database_sampler.py
================================================
import pathlib
import pickle
import numpy as np
from ...ops.iou3d_nms import iou3d_nms_utils
from ...utils import box_utils
import time
import copy
import random
class DataBaseSampler(object):
def __init__(self, root_path, sampler_cfg, class_names, logger=None):
self.root_path = root_path
self.class_names = class_names
self.sampler_cfg = sampler_cfg
#self.gt_path = pathlib.Path(sampler_cfg.GT_PATH)
self.use_van = self.sampler_cfg.get('USE_VAN', None)
self.logger = logger
self.db_infos = {}
for class_name in class_names:
self.db_infos[class_name] = []
if self.use_van:
self.db_infos['Van'] = []
for db_info_path in sampler_cfg.DB_INFO_PATH:
db_info_path = self.root_path.resolve() / db_info_path
with open(str(db_info_path), 'rb') as f:
infos = pickle.load(f)
for cls in class_names:
if cls in infos.keys():
self.db_infos[cls].extend(infos[cls])
if self.use_van:
if 'Van' in infos.keys():
self.db_infos['Van'].extend(infos['Van'])
for func_name, val in sampler_cfg.PREPARE.items():
self.db_infos = getattr(self, func_name)(self.db_infos, val)
self.sample_groups = {}
self.sample_class_num = {}
self.limit_whole_scene = sampler_cfg.get('LIMIT_WHOLE_SCENE', False)
for x in sampler_cfg.SAMPLE_GROUPS:
class_name, sample_num = x.split(':')
if class_name not in class_names:
if not (self.use_van and class_name == 'Van'):
continue
self.sample_class_num[class_name] = sample_num
self.sample_groups[class_name] = {
'sample_num': sample_num,
'pointer': len(self.db_infos[class_name]),
'indices': np.arange(len(self.db_infos[class_name]))
}
def __getstate__(self):
d = dict(self.__dict__)
del d['logger']
return d
def __setstate__(self, d):
self.__dict__.update(d)
def filter_by_difficulty(self, db_infos, removed_difficulty):
new_db_infos = {}
for key, dinfos in db_infos.items():
pre_len = len(dinfos)
this_infos = []
for info in dinfos:
if 'difficulty' in info:
if info['difficulty'] not in removed_difficulty:
this_infos.append(info)
else:
this_infos.append(info)
new_db_infos[key] = this_infos
if self.logger is not None:
self.logger.info('Database filter by difficulty %s: %d => %d' % (key, pre_len, len(new_db_infos[key])))
return new_db_infos
def filter_by_min_points(self, db_infos, min_gt_points_list):
for name_num in min_gt_points_list:
name, min_num = name_num.split(':')
min_num = int(min_num)
if min_num > 0 and name in db_infos.keys():
filtered_infos = []
for info in db_infos[name]:
if info['num_points_in_gt'] >= min_num:
filtered_infos.append(info)
if self.logger is not None:
self.logger.info('Database filter by min points %s: %d => %d' %
(name, len(db_infos[name]), len(filtered_infos)))
db_infos[name] = filtered_infos
return db_infos
def sample_with_fixed_number(self, class_name, sample_group):
"""
Args:
class_name:
sample_group:
Returns:
"""
sample_num, pointer, indices = int(sample_group['sample_num']), sample_group['pointer'], sample_group['indices']
if pointer >= len(self.db_infos[class_name]):
indices = np.random.permutation(len(self.db_infos[class_name]))
pointer = 0
sampled_dict = [self.db_infos[class_name][idx] for idx in indices[pointer: pointer + sample_num]]
pointer += sample_num
sample_group['pointer'] = pointer
sample_group['indices'] = indices
return sampled_dict
@staticmethod
def put_boxes_on_road_planes(gt_boxes, road_planes, calib):
"""
Only validate in KITTIDataset
Args:
gt_boxes: (N, 7 + C) [x, y, z, dx, dy, dz, heading, ...]
road_planes: [a, b, c, d]
calib:
Returns:
"""
a, b, c, d = road_planes
center_cam = calib.lidar_to_rect(gt_boxes[:, 0:3])
cur_height_cam = (-d - a * center_cam[:, 0] - c * center_cam[:, 2]) / b
center_cam[:, 1] = cur_height_cam
cur_lidar_height = calib.rect_to_lidar(center_cam)[:, 2]
mv_height = gt_boxes[:, 2] - gt_boxes[:, 5] / 2 - cur_lidar_height
gt_boxes[:, 2] -= mv_height # lidar view
return gt_boxes, mv_height
def points_rigid_transform(self,cloud,pose):
if cloud.shape[0]==0:
return cloud
mat=np.ones(shape=(cloud.shape[0],4),dtype=np.float32)
pose_mat=np.mat(pose)
mat[:,0:3]=cloud[:,0:3]
mat=np.mat(mat)
transformed_mat=pose_mat*mat.T
T=np.array(transformed_mat.T,dtype=np.float32)
return T[:,0:3]
def get_registration_angle(self,mat):
cos_theta=mat[0,0]
sin_theta=mat[1,0]
if cos_theta < -1:
cos_theta = -1
if cos_theta > 1:
cos_theta = 1
theta_cos = np.arccos(cos_theta)
if sin_theta >= 0:
return theta_cos
else:
return 2 * np.pi - theta_cos
def registration(self,pose, pre_pose, pre_obj_points, pre_box3d_lidar):
inv_pose_of_last_frame = np.linalg.inv(pose)
registration_mat = np.matmul(inv_pose_of_last_frame, pre_pose)
if len(pre_obj_points)!=0:
pre_obj_points[:, 0:3] = self.points_rigid_transform(pre_obj_points, registration_mat)[:,0:3]
angle = self.get_registration_angle(registration_mat)
pre_box3d_lidar[0:3] = self.points_rigid_transform(np.array([pre_box3d_lidar]), registration_mat)[0, 0:3]
pre_box3d_lidar[6]+=angle
return pre_obj_points, pre_box3d_lidar
def add_sampled_boxes_to_scene(self, data_dict, sampled_gt_boxes, total_valid_sampled_dict):
gt_boxes_mask = np.array([n in self.class_names for n in data_dict['gt_names']], dtype=np.bool_)
gt_boxes = data_dict['gt_boxes'][gt_boxes_mask]
gt_names = data_dict['gt_names'][gt_boxes_mask]
if 'gt_tracklets' in data_dict:
data_dict['gt_tracklets']=data_dict['gt_tracklets'][gt_boxes_mask]
points = data_dict['points']
if 'road_plane' in data_dict:
sampled_gt_boxes, mv_height = self.put_boxes_on_road_planes(
sampled_gt_boxes, data_dict['road_plane'], data_dict['calib']
)
obj_points_list = []
for idx, info in enumerate(total_valid_sampled_dict):
file_path = self.root_path / info['path']
#path = pathlib.Path(self.root_path)
#file_path = path / info['path']
obj_points = np.fromfile(str(file_path), dtype=np.float32).reshape(
[-1, self.sampler_cfg.NUM_POINT_FEATURES])
obj_points[:, :3] += info['box3d_lidar'][:3]
if 'road_plane' in data_dict:
# mv height
obj_points[:, 2] -= mv_height[idx]
obj_points_list.append(obj_points)
obj_points = np.concatenate(obj_points_list, axis=0)
sampled_gt_names = np.array([x['name'] for x in total_valid_sampled_dict])
if self.use_van:
sampled_gt_names = np.array(['Car' if sampled_gt_names[i]=='Van' else sampled_gt_names[i] for i in range(len(sampled_gt_names))])
large_sampled_gt_boxes = box_utils.enlarge_box3d(
sampled_gt_boxes[:, 0:7], extra_width=self.sampler_cfg.REMOVE_EXTRA_WIDTH
)
points = box_utils.remove_points_in_boxes3d(points, large_sampled_gt_boxes)
points = np.concatenate([obj_points[:, 0:points.shape[1]], points], axis=0)
gt_names = np.concatenate([gt_names, sampled_gt_names], axis=0)
gt_boxes = np.concatenate([gt_boxes, sampled_gt_boxes], axis=0)
valid_mask = np.ones((len(gt_names),), dtype=np.bool_)
valid_mask[:len(gt_names) - len(sampled_gt_names)] = 0
data_dict['valid_noise'] = valid_mask
data_dict['gt_boxes'] = gt_boxes
data_dict['gt_names'] = gt_names
data_dict['points'] = points
if 'road_plane' in data_dict:
data_dict.pop('road_plane')
return data_dict
def __call__(self, data_dict):
"""
Args:
data_dict:
gt_boxes: (N, 7 + C) [x, y, z, dx, dy, dz, heading, ...]
Returns:
"""
gt_boxes = data_dict['gt_boxes']
gt_names = data_dict['gt_names'].astype(str)
existed_boxes = gt_boxes
total_valid_sampled_dict = []
for class_name, sample_group in self.sample_groups.items():
if self.limit_whole_scene:
num_gt = np.sum(class_name == gt_names)
sample_group['sample_num'] = str(int(self.sample_class_num[class_name]) - num_gt)
if int(sample_group['sample_num']) > 0:
sampled_dict = self.sample_with_fixed_number(class_name, sample_group)
sampled_boxes1 = np.stack([x['box3d_lidar'] for x in sampled_dict], axis=0).astype(np.float32)
if self.sampler_cfg.get('DATABASE_WITH_FAKELIDAR', False):
sampled_boxes1 = box_utils.boxes3d_kitti_fakelidar_to_lidar(sampled_boxes)
sampled_boxes = copy.deepcopy(sampled_boxes1)
iou1 = iou3d_nms_utils.boxes_bev_iou_cpu(sampled_boxes[:, 0:7], existed_boxes[:, 0:7])
iou2 = iou3d_nms_utils.boxes_bev_iou_cpu(sampled_boxes[:, 0:7], sampled_boxes[:, 0:7])
iou2[range(sampled_boxes.shape[0]), range(sampled_boxes.shape[0])] = 0
iou1 = iou1 if iou1.shape[1] > 0 else iou2
valid_mask = ((iou1.max(axis=1) + iou2.max(axis=1)) == 0).nonzero()[0]
valid_sampled_dict = [sampled_dict[x] for x in valid_mask]
valid_sampled_boxes = sampled_boxes[valid_mask]
existed_boxes = np.concatenate((existed_boxes, valid_sampled_boxes), axis=0)
total_valid_sampled_dict.extend(valid_sampled_dict)
sampled_gt_boxes = existed_boxes[gt_boxes.shape[0]:, :]
if total_valid_sampled_dict.__len__() > 0:
data_dict = self.add_sampled_boxes_to_scene(data_dict, sampled_gt_boxes, total_valid_sampled_dict)
return data_dict
class DADataBaseSampler(object):
def __init__(self, root_path, sampler_cfg, class_names, logger=None):
self.root_path = root_path
self.class_names = class_names
self.sampler_cfg = sampler_cfg
# self.gt_path = pathlib.Path(sampler_cfg.GT_PATH)
self.use_van = self.sampler_cfg.get('USE_VAN', None)
self.min_sampling_dis = sampler_cfg.MIN_SAMPLING_DIS
self.max_sampling_dis = sampler_cfg.MIN_SAMPLING_DIS
self.occlusion_noise = sampler_cfg.OCCLUSION_NOISE
self.occlusion_offset = sampler_cfg.OCCLUSION_OFFSET
self.sampling_method = sampler_cfg.SAMPLING_METHOD
self.vert_res = sampler_cfg.VERT_RES
self.hor_res = sampler_cfg.HOR_RES
self.logger = logger
self.db_infos = {}
for class_name in class_names:
self.db_infos[class_name] = []
if self.use_van:
self.db_infos['Van'] = []
for db_info_path in sampler_cfg.DB_INFO_PATH:
db_info_path = self.root_path.resolve() / db_info_path
with open(str(db_info_path), 'rb') as f:
infos = pickle.load(f)
for cls in class_names:
if cls in infos.keys():
self.db_infos[cls].extend(infos[cls])
# [self.db_infos[cur_class].extend(infos[cur_class]) for cur_class in class_names]
if self.use_van:
if 'Van' in infos.keys():
self.db_infos['Van'].extend(infos['Van'])
for func_name, val in sampler_cfg.PREPARE.items():
self.db_infos = getattr(self, func_name)(self.db_infos, val)
self.sample_groups = {}
self.sample_class_num = {}
self.limit_whole_scene = sampler_cfg.get('LIMIT_WHOLE_SCENE', False)
for x in sampler_cfg.SAMPLE_GROUPS:
class_name, sample_num = x.split(':')
if class_name not in class_names:
if not (self.use_van and class_name == 'Van'):
continue
self.sample_class_num[class_name] = sample_num
self.sample_groups[class_name] = {
'sample_num': sample_num,
'pointer': len(self.db_infos[class_name]),
'indices': np.arange(len(self.db_infos[class_name]))
}
def __getstate__(self):
d = dict(self.__dict__)
del d['logger']
return d
def __setstate__(self, d):
self.__dict__.update(d)
def to_sphere_coords(self, points):
r = np.linalg.norm(points[:, 0:3], ord=2, axis=-1)
theta = np.arccos(points[:, 2] / r)
fan = np.arctan(points[:, 1] / points[:, 0])
new_points = copy.deepcopy(points)
new_points[:, 0] = r
new_points[:, 1] = theta
new_points[:, 2] = fan
return new_points
def la_sampling(self, points, vert_res=0.006, hor_res=0.003):
new_points = copy.deepcopy(points)
sp_coords = self.to_sphere_coords(new_points)
voxel_dict = {}
for i, point in enumerate(sp_coords):
vert_coord = point[1] // vert_res
hor_coord = point[2] // hor_res
voxel_key = str(vert_coord) + '_' + str(hor_coord)
if voxel_key in voxel_dict:
voxel_dict[voxel_key]['sp'].append(point)
voxel_dict[voxel_key]['pts'].append(new_points[i])
else:
voxel_dict[voxel_key] = {'sp': [point], 'pts': [new_points[i]]}
sampled_list = []
for voxel_key in voxel_dict:
sp = voxel_dict[voxel_key]['sp']
arg_min = np.argmin(np.array(sp)[:, 1])
min_point = voxel_dict[voxel_key]['pts'][arg_min]
sampled_list.append(min_point)
new_points = np.array(sampled_list)
if len(new_points) < 5:
return points
else:
return new_points
def random_sampling(self, points, box, dis):
new_points = copy.deepcopy(points)
new_box = copy.deepcopy(box)
x_off = dis
y_off = 0 # np.random.randn()*10
new_points[:, 0] -= new_box[0]
new_points[:, 1] -= new_box[1]
new_box[0] = x_off
new_box[1] = y_off
new_points[:, 0] += new_box[0]
new_points[:, 1] += new_box[1]
nn = random.choices(new_points.tolist(), k=int((1 - dis / 100) ** 3 * 300))
return np.array(nn), new_box
def random_drop_out(self, points, rand_noise=0.2, offset=0.3):
rand = np.random.choice([0, 1, 2, 3])
new_points = []
for i, p in enumerate(points):
if rand == 0 and p[1] + np.random.randn() * rand_noise < offset:
new_points.append(points[i])
if rand == 1 and p[1] + np.random.randn() * rand_noise >= -offset:
new_points.append(points[i])
if rand == 2 and p[2] + np.random.randn() * rand_noise < offset:
new_points.append(points[i])
if rand == 3 and p[2] + np.random.randn() * rand_noise >= -offset:
new_points.append(points[i])
new_points = np.array(new_points)
if len(new_points) < 5:
return self.random_drop_out(points, rand_noise, offset)
return new_points
def filter_by_difficulty(self, db_infos, removed_difficulty):
new_db_infos = {}
for key, dinfos in db_infos.items():
pre_len = len(dinfos)
this_infos = []
for info in dinfos:
if 'difficulty' in info:
if info['difficulty'] not in removed_difficulty:
this_infos.append(info)
else:
this_infos.append(info)
new_db_infos[key] = this_infos
if self.logger is not None:
self.logger.info('Database filter by difficulty %s: %d => %d' % (key, pre_len, len(new_db_infos[key])))
return new_db_infos
def filter_by_min_points(self, db_infos, min_gt_points_list):
for name_num in min_gt_points_list:
name, min_num = name_num.split(':')
min_num = int(min_num)
if min_num > 0 and name in db_infos.keys():
filtered_infos = []
for info in db_infos[name]:
if info['num_points_in_gt'] >= min_num:
filtered_infos.append(info)
if self.logger is not None:
self.logger.info('Database filter by min points %s: %d => %d' %
(name, len(db_infos[name]), len(filtered_infos)))
db_infos[name] = filtered_infos
return db_infos
def sample_with_fixed_number(self, class_name, sample_group):
"""
Args:
class_name:
sample_group:
Returns:
"""
sample_num, pointer, indices = int(sample_group['sample_num']), sample_group['pointer'], sample_group['indices']
if pointer >= len(self.db_infos[class_name]):
indices = np.random.permutation(len(self.db_infos[class_name]))
pointer = 0
sampled_dict = [self.db_infos[class_name][idx] for idx in indices[pointer: pointer + sample_num]]
pointer += sample_num
sample_group['pointer'] = pointer
sample_group['indices'] = indices
return sampled_dict
@staticmethod
def put_boxes_on_road_planes(gt_boxes, road_planes, calib):
"""
Only validate in KITTIDataset
Args:
gt_boxes: (N, 7 + C) [x, y, z, dx, dy, dz, heading, ...]
road_planes: [a, b, c, d]
calib:
Returns:
"""
a, b, c, d = road_planes
center_cam = calib.lidar_to_rect(gt_boxes[:, 0:3])
cur_height_cam = (-d - a * center_cam[:, 0] - c * center_cam[:, 2]) / b
center_cam[:, 1] = cur_height_cam
cur_lidar_height = calib.rect_to_lidar(center_cam)[:, 2]
mv_height = gt_boxes[:, 2] - gt_boxes[:, 5] / 2 - cur_lidar_height
gt_boxes[:, 2] -= mv_height # lidar view
return gt_boxes, mv_height
def points_rigid_transform(self, cloud, pose):
if cloud.shape[0] == 0:
return cloud
mat = np.ones(shape=(cloud.shape[0], 4), dtype=np.float32)
pose_mat = np.mat(pose)
mat[:, 0:3] = cloud[:, 0:3]
mat = np.mat(mat)
transformed_mat = pose_mat * mat.T
T = np.array(transformed_mat.T, dtype=np.float32)
return T[:, 0:3]
def get_registration_angle(self, mat):
cos_theta = mat[0, 0]
sin_theta = mat[1, 0]
if cos_theta < -1:
cos_theta = -1
if cos_theta > 1:
cos_theta = 1
theta_cos = np.arccos(cos_theta)
if sin_theta >= 0:
return theta_cos
else:
return 2 * np.pi - theta_cos
def registration(self, pose, pre_pose, pre_obj_points, pre_box3d_lidar):
inv_pose_of_last_frame = np.linalg.inv(pose)
registration_mat = np.matmul(inv_pose_of_last_frame, pre_pose)
if len(pre_obj_points) != 0:
pre_obj_points[:, 0:3] = self.points_rigid_transform(pre_obj_points, registration_mat)[:, 0:3]
angle = self.get_registration_angle(registration_mat)
pre_box3d_lidar[0:3] = self.points_rigid_transform(np.array([pre_box3d_lidar]), registration_mat)[0, 0:3]
pre_box3d_lidar[6] += angle
return pre_obj_points, pre_box3d_lidar
def add_sampled_boxes_to_scene(self, data_dict, sampled_gt_boxes, total_valid_sampled_dict):
gt_boxes_mask = np.array([n in self.class_names for n in data_dict['gt_names']], dtype=np.bool_)
gt_boxes = data_dict['gt_boxes'][gt_boxes_mask]
gt_names = data_dict['gt_names'][gt_boxes_mask]
if 'gt_tracklets' in data_dict:
data_dict['gt_tracklets'] = data_dict['gt_tracklets'][gt_boxes_mask]
points = data_dict['points']
if 'road_plane' in data_dict:
sampled_gt_boxes, mv_height = self.put_boxes_on_road_planes(
sampled_gt_boxes, data_dict['road_plane'], data_dict['calib']
)
obj_points_list = []
for idx, info in enumerate(total_valid_sampled_dict):
file_path = self.root_path / info['path']
# path = pathlib.Path(self.root_path)
# file_path = path / info['path']
obj_points = np.fromfile(str(file_path), dtype=np.float32).reshape(
[-1, self.sampler_cfg.NUM_POINT_FEATURES])
obj_points[:, :3] += sampled_gt_boxes[idx][:3]
'''
gitextract_kkhpxbxf/
├── LICENSE
├── README.md
├── data/
│ └── kitti/
│ └── ImageSets/
│ ├── test.txt
│ ├── train.txt
│ └── val.txt
├── pcdet/
│ ├── __init__.py
│ ├── config.py
│ ├── datasets/
│ │ ├── __init__.py
│ │ ├── augmentor/
│ │ │ ├── X_transform.py
│ │ │ ├── augmentor_utils.py
│ │ │ ├── data_augmentor.py
│ │ │ └── database_sampler.py
│ │ ├── dataset.py
│ │ ├── kitti/
│ │ │ ├── kitti_dataset.py
│ │ │ ├── kitti_dataset_mm.py
│ │ │ └── kitti_object_eval_python/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── eval.py
│ │ │ ├── evaluate.py
│ │ │ ├── kitti_common.py
│ │ │ └── rotate_iou.py
│ │ └── processor/
│ │ ├── data_processor.py
│ │ └── point_feature_encoder.py
│ ├── models/
│ │ ├── __init__.py
│ │ ├── backbones_2d/
│ │ │ ├── __init__.py
│ │ │ ├── base_bev_backbone.py
│ │ │ └── map_to_bev/
│ │ │ ├── __init__.py
│ │ │ ├── height_compression.py
│ │ │ └── pointpillar_scatter.py
│ │ ├── backbones_3d/
│ │ │ ├── __init__.py
│ │ │ ├── pfe/
│ │ │ │ ├── __init__.py
│ │ │ │ ├── bev_features_interpolation.py
│ │ │ │ └── voxel_set_abstraction.py
│ │ │ ├── pointnet2_backbone.py
│ │ │ ├── spconv_backbone.py
│ │ │ ├── spconv_unet.py
│ │ │ └── vfe/
│ │ │ ├── __init__.py
│ │ │ ├── mean_vfe.py
│ │ │ ├── pillar_vfe.py
│ │ │ └── vfe_template.py
│ │ ├── dense_heads/
│ │ │ ├── __init__.py
│ │ │ ├── anchor_head_multi.py
│ │ │ ├── anchor_head_single.py
│ │ │ ├── anchor_head_template.py
│ │ │ ├── center_head.py
│ │ │ ├── point_head_box.py
│ │ │ ├── point_head_simple.py
│ │ │ ├── point_head_template.py
│ │ │ ├── point_intra_part_head.py
│ │ │ └── target_assigner/
│ │ │ ├── anchor_generator.py
│ │ │ ├── atss_target_assigner.py
│ │ │ └── axis_aligned_target_assigner.py
│ │ ├── detectors/
│ │ │ ├── __init__.py
│ │ │ ├── detector3d_template.py
│ │ │ └── voxel_rcnn.py
│ │ ├── model_utils/
│ │ │ ├── centernet_utils.py
│ │ │ ├── ctrans.py
│ │ │ └── model_nms_utils.py
│ │ └── roi_heads/
│ │ ├── __init__.py
│ │ ├── roi_head_template.py
│ │ ├── target_assigner/
│ │ │ ├── proposal_target_layer.py
│ │ │ └── proposal_target_layer3.py
│ │ └── ted_head.py
│ ├── ops/
│ │ ├── dcn/
│ │ │ ├── __init__.py
│ │ │ ├── deform_conv.py
│ │ │ ├── setup.py
│ │ │ └── src/
│ │ │ ├── deform_conv_cuda.cpp
│ │ │ ├── deform_conv_cuda_kernel.cu
│ │ │ ├── deform_pool_cuda.cpp
│ │ │ └── deform_pool_cuda_kernel.cu
│ │ ├── iou3d_nms/
│ │ │ ├── iou3d_nms_utils.py
│ │ │ └── src/
│ │ │ ├── iou3d_cpu.cpp
│ │ │ ├── iou3d_cpu.h
│ │ │ ├── iou3d_nms.cpp
│ │ │ ├── iou3d_nms.h
│ │ │ ├── iou3d_nms_api.cpp
│ │ │ └── iou3d_nms_kernel.cu
│ │ ├── pointnet2/
│ │ │ ├── pointnet2_batch/
│ │ │ │ ├── pointnet2_modules.py
│ │ │ │ ├── pointnet2_utils.py
│ │ │ │ └── src/
│ │ │ │ ├── ball_query.cpp
│ │ │ │ ├── ball_query_gpu.cu
│ │ │ │ ├── ball_query_gpu.h
│ │ │ │ ├── cuda_utils.h
│ │ │ │ ├── group_points.cpp
│ │ │ │ ├── group_points_gpu.cu
│ │ │ │ ├── group_points_gpu.h
│ │ │ │ ├── interpolate.cpp
│ │ │ │ ├── interpolate_gpu.cu
│ │ │ │ ├── interpolate_gpu.h
│ │ │ │ ├── pointnet2_api.cpp
│ │ │ │ ├── sampling.cpp
│ │ │ │ ├── sampling_gpu.cu
│ │ │ │ └── sampling_gpu.h
│ │ │ └── pointnet2_stack/
│ │ │ ├── pointnet2_modules.py
│ │ │ ├── pointnet2_utils.py
│ │ │ ├── src/
│ │ │ │ ├── ball_query.cpp
│ │ │ │ ├── ball_query_deform.cpp
│ │ │ │ ├── ball_query_deform_gpu.cu
│ │ │ │ ├── ball_query_deform_gpu.h
│ │ │ │ ├── ball_query_gpu.cu
│ │ │ │ ├── ball_query_gpu.h
│ │ │ │ ├── cuda_utils.h
│ │ │ │ ├── group_points.cpp
│ │ │ │ ├── group_points_gpu.cu
│ │ │ │ ├── group_points_gpu.h
│ │ │ │ ├── interpolate.cpp
│ │ │ │ ├── interpolate_gpu.cu
│ │ │ │ ├── interpolate_gpu.h
│ │ │ │ ├── pointnet2_api.cpp
│ │ │ │ ├── sampling.cpp
│ │ │ │ ├── sampling_gpu.cu
│ │ │ │ ├── sampling_gpu.h
│ │ │ │ ├── vector_pool.cpp
│ │ │ │ ├── vector_pool_gpu.cu
│ │ │ │ ├── vector_pool_gpu.h
│ │ │ │ ├── voxel_query.cpp
│ │ │ │ ├── voxel_query_gpu.cu
│ │ │ │ └── voxel_query_gpu.h
│ │ │ ├── voxel_pool_modules.py
│ │ │ └── voxel_query_utils.py
│ │ ├── roiaware_pool3d/
│ │ │ ├── roiaware_pool3d_utils.py
│ │ │ └── src/
│ │ │ ├── roiaware_pool3d.cpp
│ │ │ └── roiaware_pool3d_kernel.cu
│ │ ├── roipoint_pool3d/
│ │ │ ├── roipoint_pool3d_utils.py
│ │ │ └── src/
│ │ │ ├── roipoint_pool3d.cpp
│ │ │ └── roipoint_pool3d_kernel.cu
│ │ └── votr_ops/
│ │ ├── src/
│ │ │ ├── build_attention_indices.cpp
│ │ │ ├── build_attention_indices_gpu.cu
│ │ │ ├── build_attention_indices_gpu.h
│ │ │ ├── build_mapping.cpp
│ │ │ ├── build_mapping_gpu.cu
│ │ │ ├── build_mapping_gpu.h
│ │ │ ├── group_features.cpp
│ │ │ ├── group_features_gpu.cu
│ │ │ ├── group_features_gpu.h
│ │ │ ├── votr_api.cpp
│ │ │ └── votr_cuda_utils.h
│ │ └── votr_utils.py
│ ├── utils/
│ │ ├── __init__.py
│ │ ├── bbloss.py
│ │ ├── box_coder_utils.py
│ │ ├── box_np_ops.py
│ │ ├── box_utils.py
│ │ ├── calibration_kitti.py
│ │ ├── common_utils.py
│ │ ├── commu_utils.py
│ │ ├── loss_utils.py
│ │ ├── object3d_kitti.py
│ │ ├── odiou_loss.py
│ │ ├── spconv_utils.py
│ │ └── transform_utils.py
│ └── version.py
├── requirements.txt
├── setup.py
└── tools/
├── PENet/
│ ├── CoordConv.py
│ ├── LICENSE
│ ├── basic.py
│ ├── criteria.py
│ ├── dataloaders/
│ │ ├── calib_cam_to_cam.txt
│ │ ├── calibration_kitti.py
│ │ ├── kitti_loader.py
│ │ ├── my_loader.py
│ │ ├── spconv_utils.py
│ │ └── transforms.py
│ ├── helper.py
│ ├── main.py
│ ├── metrics.py
│ ├── model.py
│ └── vis_utils.py
├── cfgs/
│ ├── dataset_configs/
│ │ └── kitti_dataset.yaml
│ └── models/
│ └── kitti/
│ ├── TED-M.yaml
│ └── TED-S.yaml
├── dist_test.sh
├── dist_train.sh
├── eval_utils/
│ └── eval_utils.py
├── test.py
├── train.py
├── train_utils/
│ ├── optimization/
│ │ ├── __init__.py
│ │ ├── fastai_optim.py
│ │ └── learning_schedules_fastai.py
│ └── train_utils.py
└── visual_utils/
└── visualize_utils.py
SYMBOL INDEX (1247 symbols across 119 files)
FILE: pcdet/__init__.py
function get_git_commit_number (line 11) | def get_git_commit_number():
FILE: pcdet/config.py
function log_config_to_file (line 7) | def log_config_to_file(cfg, pre='cfg', logger=None):
function cfg_from_list (line 16) | def cfg_from_list(cfg_list, config):
function merge_new_config (line 51) | def merge_new_config(config, new_config):
function cfg_from_yaml_file (line 71) | def cfg_from_yaml_file(cfg_file, config):
FILE: pcdet/datasets/__init__.py
class DataLoaderX (line 21) | class DataLoaderX(DataLoader):
method __iter__ (line 23) | def __iter__(self):
class DistributedSampler (line 26) | class DistributedSampler(_DistributedSampler):
method __init__ (line 28) | def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True):
method __iter__ (line 32) | def __iter__(self):
function build_dataloader (line 49) | def build_dataloader(dataset_cfg, class_names, batch_size, dist, root_pa...
FILE: pcdet/datasets/augmentor/X_transform.py
class X_TRANS (line 10) | class X_TRANS(object):
method __init__ (line 11) | def __init__(self, augmentor_configs=None, rot_num=1):
method get_params (line 37) | def get_params(self):
method world_rotation (line 49) | def world_rotation(self, data_dict=None, config=None):
method world_flip (line 79) | def world_flip(self, data_dict=None, config=None):
method world_scaling (line 98) | def world_scaling(self, data_dict=None, config=None):
method forward_with_param (line 122) | def forward_with_param(self, data_dict):
method backward_with_param (line 139) | def backward_with_param(self, data_dict):
method input_transform (line 156) | def input_transform(self, data_dict, trans_boxes=False):
FILE: pcdet/datasets/augmentor/augmentor_utils.py
function random_flip_along_x (line 8) | def random_flip_along_x(gt_boxes, points):
function random_flip_with_param (line 26) | def random_flip_with_param(points, enable, ax=1,offset = 0):
function random_flip_along_y (line 34) | def random_flip_along_y(gt_boxes, points):
function global_rotation (line 53) | def global_rotation(gt_boxes, points, rot_range):
function global_rotation_with_param (line 73) | def global_rotation_with_param(batch_dict, noise_rotation=None,num_frame...
function boxes_rotation_with_param (line 96) | def boxes_rotation_with_param(boxes, noise_rotation=None):
function global_scaling (line 102) | def global_scaling(gt_boxes, points, scale_range):
function global_scaling_with_param (line 117) | def global_scaling_with_param(batch_dict, noise_scale=None,num_frames=2):
function get_points_in_box (line 137) | def get_points_in_box(points, gt_box):
function get_pyramids (line 157) | def get_pyramids(boxes):
function one_hot (line 182) | def one_hot(x, num_class=1):
function points_in_pyramids_mask (line 190) | def points_in_pyramids_mask(points, pyramids):
function local_pyramid_dropout (line 198) | def local_pyramid_dropout(gt_boxes, points, dropout_prob, pyramids=None):
function local_pyramid_sparsify (line 214) | def local_pyramid_sparsify(gt_boxes, points, prob, max_num_pts, pyramids...
function local_pyramid_swap (line 248) | def local_pyramid_swap(gt_boxes, points, prob, max_num_pts, pyramids=None):
function noise_per_object_v3_ (line 351) | def noise_per_object_v3_(gt_boxes,
function _rotation_box2d_jit_ (line 441) | def _rotation_box2d_jit_(corners, angle, rot_mat_T):
function box_collision_test (line 459) | def box_collision_test(boxes, qboxes, clockwise=True):
function noise_per_box (line 556) | def noise_per_box(boxes, valid_mask, loc_noises, rot_noises):
function noise_per_box_v2_ (line 596) | def noise_per_box_v2_(boxes, valid_mask, loc_noises, rot_noises,
function _select_transform (line 666) | def _select_transform(transform, indices):
function _rotation_matrix_3d_ (line 685) | def _rotation_matrix_3d_(rot_mat_T, angle, axis):
function points_transform_ (line 714) | def points_transform_(points, centers, point_masks, loc_transform,
function box3d_transform_ (line 744) | def box3d_transform_(boxes, loc_transform, rot_transform, valid_mask):
FILE: pcdet/datasets/augmentor/data_augmentor.py
class DataAugmentor (line 9) | class DataAugmentor(object):
method __init__ (line 10) | def __init__(self, root_path, augmentor_configs, class_names, logger=N...
method gt_sampling (line 26) | def gt_sampling(self, config=None):
method da_sampling (line 35) | def da_sampling(self, config=None):
method __getstate__ (line 44) | def __getstate__(self):
method __setstate__ (line 49) | def __setstate__(self, d):
method random_world_rotation (line 54) | def random_world_rotation(self, data_dict=None, config=None):
method random_world_flip (line 73) | def random_world_flip(self, data_dict=None, config=None):
method random_world_scaling (line 93) | def random_world_scaling(self, data_dict=None, config=None):
method random_local_noise (line 110) | def random_local_noise(self, data_dict=None, config=None):
method random_local_pyramid_aug (line 123) | def random_local_pyramid_aug(self, data_dict=None, config=None):
method forward (line 146) | def forward(self, data_dict):
FILE: pcdet/datasets/augmentor/database_sampler.py
class DataBaseSampler (line 12) | class DataBaseSampler(object):
method __init__ (line 13) | def __init__(self, root_path, sampler_cfg, class_names, logger=None):
method __getstate__ (line 57) | def __getstate__(self):
method __setstate__ (line 62) | def __setstate__(self, d):
method filter_by_difficulty (line 65) | def filter_by_difficulty(self, db_infos, removed_difficulty):
method filter_by_min_points (line 81) | def filter_by_min_points(self, db_infos, min_gt_points_list):
method sample_with_fixed_number (line 98) | def sample_with_fixed_number(self, class_name, sample_group):
method put_boxes_on_road_planes (line 118) | def put_boxes_on_road_planes(gt_boxes, road_planes, calib):
method points_rigid_transform (line 137) | def points_rigid_transform(self,cloud,pose):
method get_registration_angle (line 148) | def get_registration_angle(self,mat):
method registration (line 165) | def registration(self,pose, pre_pose, pre_obj_points, pre_box3d_lidar):
method add_sampled_boxes_to_scene (line 178) | def add_sampled_boxes_to_scene(self, data_dict, sampled_gt_boxes, tota...
method __call__ (line 236) | def __call__(self, data_dict):
class DADataBaseSampler (line 284) | class DADataBaseSampler(object):
method __init__ (line 285) | def __init__(self, root_path, sampler_cfg, class_names, logger=None):
method __getstate__ (line 338) | def __getstate__(self):
method __setstate__ (line 343) | def __setstate__(self, d):
method to_sphere_coords (line 346) | def to_sphere_coords(self, points):
method la_sampling (line 358) | def la_sampling(self, points, vert_res=0.006, hor_res=0.003):
method random_sampling (line 392) | def random_sampling(self, points, box, dis):
method random_drop_out (line 409) | def random_drop_out(self, points, rand_noise=0.2, offset=0.3):
method filter_by_difficulty (line 429) | def filter_by_difficulty(self, db_infos, removed_difficulty):
method filter_by_min_points (line 445) | def filter_by_min_points(self, db_infos, min_gt_points_list):
method sample_with_fixed_number (line 462) | def sample_with_fixed_number(self, class_name, sample_group):
method put_boxes_on_road_planes (line 482) | def put_boxes_on_road_planes(gt_boxes, road_planes, calib):
method points_rigid_transform (line 501) | def points_rigid_transform(self, cloud, pose):
method get_registration_angle (line 512) | def get_registration_angle(self, mat):
method registration (line 529) | def registration(self, pose, pre_pose, pre_obj_points, pre_box3d_lidar):
method add_sampled_boxes_to_scene (line 543) | def add_sampled_boxes_to_scene(self, data_dict, sampled_gt_boxes, tota...
method __call__ (line 618) | def __call__(self, data_dict):
FILE: pcdet/datasets/dataset.py
class DatasetTemplate (line 15) | class DatasetTemplate(torch_data.Dataset):
method __init__ (line 16) | def __init__(self, dataset_cfg=None, class_names=None, training=True, ...
method mode (line 65) | def mode(self):
method __getstate__ (line 68) | def __getstate__(self):
method __setstate__ (line 73) | def __setstate__(self, d):
method generate_prediction_dicts (line 77) | def generate_prediction_dicts(batch_dict, pred_dicts, class_names, out...
method merge_all_iters_to_one_epoch (line 94) | def merge_all_iters_to_one_epoch(self, merge=True, epochs=None):
method __len__ (line 101) | def __len__(self):
method __getitem__ (line 104) | def __getitem__(self, index):
method prepare_data (line 118) | def prepare_data(self, data_dict):
method collate_batch (line 203) | def collate_batch(self, batch_list, _unused=False):
FILE: pcdet/datasets/kitti/kitti_dataset.py
class KittiDataset (line 12) | class KittiDataset(DatasetTemplate):
method __init__ (line 13) | def __init__(self, dataset_cfg, class_names, training=True, root_path=...
method include_kitti_data (line 34) | def include_kitti_data(self, mode):
method set_split (line 52) | def set_split(self, split):
method get_lidar (line 62) | def get_lidar(self, idx):
method get_image_shape (line 67) | def get_image_shape(self, idx):
method get_label (line 72) | def get_label(self, idx):
method get_calib (line 77) | def get_calib(self, idx):
method get_road_plane (line 82) | def get_road_plane(self, idx):
method get_fov_flag (line 101) | def get_fov_flag(pts_rect, img_shape, calib):
method get_infos (line 119) | def get_infos(self, num_workers=4, has_label=True, count_inside_pts=Tr...
method create_groundtruth_database (line 193) | def create_groundtruth_database(self, info_path=None, used_classes=Non...
method generate_prediction_dicts (line 248) | def generate_prediction_dicts(self,batch_dict, pred_dicts, class_names...
method evaluation (line 332) | def evaluation(self, det_annos, class_names, **kwargs):
method __len__ (line 344) | def __len__(self):
method __getitem__ (line 350) | def __getitem__(self, index):
function create_kitti_infos (line 396) | def create_kitti_infos(dataset_cfg, class_names, data_path, save_path, w...
FILE: pcdet/datasets/kitti/kitti_dataset_mm.py
class KittiDatasetMM (line 13) | class KittiDatasetMM(DatasetTemplate):
method __init__ (line 14) | def __init__(self, dataset_cfg, class_names, training=True, root_path=...
method include_kitti_data (line 35) | def include_kitti_data(self, mode):
method set_split (line 53) | def set_split(self, split):
method get_lidar (line 63) | def get_lidar(self, idx):
method get_lidar_mm (line 70) | def get_lidar_mm(self, idx):
method get_image_shape (line 75) | def get_image_shape(self, idx):
method get_image (line 80) | def get_image(self, idx):
method get_label (line 85) | def get_label(self, idx):
method get_calib (line 90) | def get_calib(self, idx):
method get_road_plane (line 95) | def get_road_plane(self, idx):
method get_fov_flag (line 114) | def get_fov_flag(pts_rect, img_shape, calib):
method get_infos (line 132) | def get_infos(self, num_workers=4, has_label=True, count_inside_pts=Tr...
method create_groundtruth_database (line 206) | def create_groundtruth_database(self, info_path=None, used_classes=Non...
method generate_prediction_dicts (line 264) | def generate_prediction_dicts(self,batch_dict, pred_dicts, class_names...
method evaluation (line 351) | def evaluation(self, det_annos, class_names, **kwargs):
method __len__ (line 363) | def __len__(self):
method __getitem__ (line 369) | def __getitem__(self, index):
function create_kitti_infos (line 430) | def create_kitti_infos(dataset_cfg, class_names, data_path, save_path, w...
FILE: pcdet/datasets/kitti/kitti_object_eval_python/eval.py
function get_thresholds (line 9) | def get_thresholds(scores: np.ndarray, num_gt, num_sample_pts=41):
function clean_data (line 29) | def clean_data(gt_anno, dt_anno, current_class, difficulty):
function image_box_overlap (line 86) | def image_box_overlap(boxes, query_boxes, criterion=-1):
function bev_box_overlap (line 115) | def bev_box_overlap(boxes, qboxes, criterion=-1):
function d3_box_overlap_kernel (line 121) | def d3_box_overlap_kernel(boxes, qboxes, rinc, criterion=-1):
function d3_box_overlap (line 149) | def d3_box_overlap(boxes, qboxes, criterion=-1):
function compute_statistics_jit (line 157) | def compute_statistics_jit(overlaps,
function get_split_parts (line 277) | def get_split_parts(num, num_part):
function fused_compute_statistics (line 290) | def fused_compute_statistics(overlaps,
function calculate_iou_partly (line 339) | def calculate_iou_partly(gt_annos, dt_annos, metric, num_parts=50):
function _prepare_data (line 416) | def _prepare_data(gt_annos, dt_annos, current_class, difficulty):
function eval_class (line 447) | def eval_class(gt_annos,
function get_mAP (line 560) | def get_mAP(prec):
function get_mAP_R40 (line 567) | def get_mAP_R40(prec):
function print_str (line 574) | def print_str(value, *arg, sstream=None):
function do_eval (line 583) | def do_eval(gt_annos,
function do_coco_style_eval (line 627) | def do_coco_style_eval(gt_annos, dt_annos, current_classes, overlap_ranges,
function get_official_eval_result (line 645) | def get_official_eval_result(gt_annos, dt_annos, current_classes, PR_det...
function get_coco_eval_result (line 755) | def get_coco_eval_result(gt_annos, dt_annos, current_classes):
FILE: pcdet/datasets/kitti/kitti_object_eval_python/evaluate.py
function _read_imageset_file (line 9) | def _read_imageset_file(path):
function evaluate (line 15) | def evaluate(label_path,
function evaluate_dis (line 31) | def evaluate_dis(label_path,
FILE: pcdet/datasets/kitti/kitti_object_eval_python/kitti_common.py
function get_image_index_str (line 11) | def get_image_index_str(img_idx):
function get_kitti_info_path (line 15) | def get_kitti_info_path(idx,
function get_image_path (line 36) | def get_image_path(idx, prefix, training=True, relative_path=True):
function get_label_path (line 41) | def get_label_path(idx, prefix, training=True, relative_path=True):
function get_velodyne_path (line 46) | def get_velodyne_path(idx, prefix, training=True, relative_path=True):
function get_calib_path (line 51) | def get_calib_path(idx, prefix, training=True, relative_path=True):
function _extend_matrix (line 56) | def _extend_matrix(mat):
function get_kitti_image_info (line 61) | def get_kitti_image_info(path,
function filter_kitti_anno (line 152) | def filter_kitti_anno(image_anno,
function filter_annos_low_score (line 191) | def filter_annos_low_score(image_annos, thresh):
function filter_gt_annos_dis (line 204) | def filter_gt_annos_dis(image_annos, dis_min=0, dis_max=100):
function filter_det_annos_dis (line 217) | def filter_det_annos_dis(image_annos, dis_min=0, dis_max=100):
function kitti_result_line (line 232) | def kitti_result_line(result_dict, precision=4):
function add_difficulty_to_annos (line 277) | def add_difficulty_to_annos(info):
function get_label_anno (line 322) | def get_label_anno(label_path):
function get_label_annos (line 360) | def get_label_annos(label_folder, image_ids=None):
function area (line 377) | def area(boxes, add1=False):
function intersection (line 393) | def intersection(boxes1, boxes2, add1=False):
function iou (line 424) | def iou(boxes1, boxes2, add1=False):
FILE: pcdet/datasets/kitti/kitti_object_eval_python/rotate_iou.py
function div_up (line 14) | def div_up(m, n):
function trangle_area (line 18) | def trangle_area(a, b, c):
function area (line 24) | def area(int_pts, num_of_inter):
function sort_vertex_in_convex_polygon (line 34) | def sort_vertex_in_convex_polygon(int_pts, num_of_inter):
function line_segment_intersection (line 77) | def line_segment_intersection(pts1, pts2, i, j, temp_pts):
function line_segment_intersection_v1 (line 123) | def line_segment_intersection_v1(pts1, pts2, i, j, temp_pts):
function point_in_quadrilateral (line 162) | def point_in_quadrilateral(pt_x, pt_y, corners):
function quadrilateral_intersection (line 181) | def quadrilateral_intersection(pts1, pts2, int_pts):
function rbbox_to_corners (line 205) | def rbbox_to_corners(corners, rbbox):
function inter (line 232) | def inter(rbbox1, rbbox2):
function devRotateIoUEval (line 249) | def devRotateIoUEval(rbox1, rbox2, criterion=-1):
function rotate_iou_kernel_eval (line 263) | def rotate_iou_kernel_eval(N, K, dev_boxes, dev_query_boxes, dev_iou, cr...
function rotate_iou_gpu_eval (line 295) | def rotate_iou_gpu_eval(boxes, query_boxes, criterion=-1, device_id=0):
FILE: pcdet/datasets/processor/data_processor.py
class VoxelGeneratorWrapper (line 14) | class VoxelGeneratorWrapper():
method __init__ (line 15) | def __init__(self, vsize_xyz, coors_range_xyz, num_point_features, max...
method generate (line 43) | def generate(self, points):
class DataProcessor (line 61) | class DataProcessor(object):
method __init__ (line 62) | def __init__(self, processor_configs, point_cloud_range, training, rot...
method mask_points_and_boxes_outside_range (line 77) | def mask_points_and_boxes_outside_range(self, data_dict=None, config=N...
method shuffle_points (line 105) | def shuffle_points(self, data_dict=None, config=None):
method transform_points_to_voxels (line 128) | def transform_points_to_voxels(self, data_dict=None, config=None):
method sample_points (line 185) | def sample_points(self, data_dict=None, config=None):
method forward (line 217) | def forward(self, data_dict):
FILE: pcdet/datasets/processor/point_feature_encoder.py
class PointFeatureEncoder (line 4) | class PointFeatureEncoder(object):
method __init__ (line 5) | def __init__(self, config, point_cloud_range=None, rot_num=1):
method num_point_features (line 15) | def num_point_features(self):
method forward (line 18) | def forward(self, data_dict):
method absolute_coordinates_encoding (line 49) | def absolute_coordinates_encoding(self, points=None):
method absolute_coordinates_encoding_mm (line 63) | def absolute_coordinates_encoding_mm(self, points=None):
FILE: pcdet/models/__init__.py
function build_network (line 9) | def build_network(model_cfg, num_class, dataset):
function load_data_to_gpu (line 16) | def load_data_to_gpu(batch_dict):
function model_fn_decorator (line 27) | def model_fn_decorator():
FILE: pcdet/models/backbones_2d/base_bev_backbone.py
class BaseBEVBackbone (line 6) | class BaseBEVBackbone(nn.Module):
method __init__ (line 7) | def __init__(self, model_cfg, input_channels):
method forward (line 84) | def forward(self, data_dict):
FILE: pcdet/models/backbones_2d/map_to_bev/height_compression.py
function bilinear_interpolate_torch (line 6) | def bilinear_interpolate_torch(im, x, y):
class BEVPool (line 39) | class BEVPool(nn.Module):
method __init__ (line 40) | def __init__(self, model_cfg, voxel_size=None, point_cloud_range=None):
method get_pseudo_points (line 49) | def get_pseudo_points(self, pts_range=[0, -40, -3, 70.4, 40, 1], voxel...
method interpolate_from_bev_features (line 68) | def interpolate_from_bev_features(self, points, bev_features, bev_stri...
method bev_align (line 82) | def bev_align(self, bev_feat, transform_param, stride, stage_i):
method forward (line 108) | def forward(self, batch_dict):
FILE: pcdet/models/backbones_2d/map_to_bev/pointpillar_scatter.py
class PointPillarScatter (line 5) | class PointPillarScatter(nn.Module):
method __init__ (line 6) | def __init__(self, model_cfg, grid_size, **kwargs):
method forward (line 14) | def forward(self, batch_dict, **kwargs):
FILE: pcdet/models/backbones_3d/pfe/bev_features_interpolation.py
function bilinear_interpolate_torch (line 9) | def bilinear_interpolate_torch(im, x, y):
class BEVFeaturesInterpolation (line 43) | class BEVFeaturesInterpolation(nn.Module):
method __init__ (line 44) | def __init__(self, model_cfg, voxel_size, point_cloud_range, num_frame...
method interpolate_from_bev_features (line 73) | def interpolate_from_bev_features(self, points, bev_features, batch_si...
method forward (line 96) | def forward(self, batch_dict):
FILE: pcdet/models/backbones_3d/pfe/voxel_set_abstraction.py
function bilinear_interpolate_torch (line 11) | def bilinear_interpolate_torch(im, x, y):
function sample_points_with_roi (line 45) | def sample_points_with_roi(rois, points, sample_radius_with_roi, num_max...
function sector_fps (line 78) | def sector_fps(points, num_sampled_points, num_sectors):
class VoxelSetAbstraction (line 124) | class VoxelSetAbstraction(nn.Module):
method __init__ (line 125) | def __init__(self, model_cfg, voxel_size, point_cloud_range, num_bev_f...
method interpolate_from_bev_features (line 178) | def interpolate_from_bev_features(self, keypoints, bev_features, batch...
method sectorized_proposal_centric_sampling (line 208) | def sectorized_proposal_centric_sampling(self, roi_boxes, points):
method get_sampled_points (line 229) | def get_sampled_points(self, batch_dict):
method aggregate_keypoint_features_from_one_source (line 286) | def aggregate_keypoint_features_from_one_source(
method forward (line 336) | def forward(self, batch_dict):
FILE: pcdet/models/backbones_3d/pointnet2_backbone.py
class PointNet2MSG (line 9) | class PointNet2MSG(nn.Module):
method __init__ (line 10) | def __init__(self, model_cfg, input_channels, **kwargs):
method break_up_pc (line 50) | def break_up_pc(self, pc):
method forward (line 56) | def forward(self, batch_dict):
class PointNet2Backbone (line 97) | class PointNet2Backbone(nn.Module):
method __init__ (line 101) | def __init__(self, model_cfg, input_channels, **kwargs):
method break_up_pc (line 142) | def break_up_pc(self, pc):
method forward (line 148) | def forward(self, batch_dict):
FILE: pcdet/models/backbones_3d/spconv_backbone.py
function post_act_block (line 7) | def post_act_block(in_channels, out_channels, kernel_size, indice_key=No...
class SparseBasicBlock (line 32) | class SparseBasicBlock(spconv.SparseModule):
method __init__ (line 35) | def __init__(self, inplanes, planes, stride=1, norm_fn=None, downsampl...
method forward (line 52) | def forward(self, x):
class BasicBlock (line 70) | class BasicBlock(spconv.SparseModule):
method __init__ (line 72) | def __init__(self, inplanes, planes, norm_fn=None, stride=2, padding...
method forward (line 120) | def forward(self, x):
class TeMMVoxelBackBone8x (line 133) | class TeMMVoxelBackBone8x(nn.Module):
method __init__ (line 134) | def __init__(self, model_cfg, input_channels, grid_size, **kwargs):
method decompose_tensor (line 233) | def decompose_tensor(self, tensor, i, batch_size):
method forward_test (line 254) | def forward_test(self, batch_dict):
method forward_train (line 397) | def forward_train(self, batch_dict):
method forward (line 500) | def forward(self, batch_dict):
class TeVoxelBackBone8x (line 507) | class TeVoxelBackBone8x(nn.Module):
method __init__ (line 508) | def __init__(self, model_cfg, input_channels, grid_size, **kwargs):
method decompose_tensor (line 572) | def decompose_tensor(self, tensor, i, batch_size):
method forward_test (line 593) | def forward_test(self, batch_dict):
method forward_train (line 736) | def forward_train(self, batch_dict):
method forward (line 840) | def forward(self, batch_dict):
FILE: pcdet/models/backbones_3d/spconv_unet.py
class SparseBasicBlock (line 11) | class SparseBasicBlock(spconv.SparseModule):
method __init__ (line 14) | def __init__(self, inplanes, planes, stride=1, downsample=None, indice...
method forward (line 28) | def forward(self, x):
class UNetV2 (line 49) | class UNetV2(nn.Module):
method __init__ (line 55) | def __init__(self, model_cfg, input_channels, grid_size, voxel_size, p...
method UR_block_forward (line 134) | def UR_block_forward(self, x_lateral, x_bottom, conv_t, conv_m, conv_i...
method channel_reduction (line 145) | def channel_reduction(x, out_channels):
method forward (line 161) | def forward(self, batch_dict):
FILE: pcdet/models/backbones_3d/vfe/mean_vfe.py
class MeanVFE (line 6) | class MeanVFE(VFETemplate):
method __init__ (line 7) | def __init__(self, model_cfg, num_point_features, **kwargs):
method get_output_feature_dim (line 12) | def get_output_feature_dim(self):
method forward (line 15) | def forward(self, batch_dict, **kwargs):
FILE: pcdet/models/backbones_3d/vfe/pillar_vfe.py
class PFNLayer (line 8) | class PFNLayer(nn.Module):
method __init__ (line 9) | def __init__(self,
method forward (line 29) | def forward(self, inputs):
class PillarVFE (line 52) | class PillarVFE(VFETemplate):
method __init__ (line 53) | def __init__(self, model_cfg, num_point_features, voxel_size, point_cl...
method get_output_feature_dim (line 83) | def get_output_feature_dim(self):
method get_paddings_indicator (line 86) | def get_paddings_indicator(self, actual_num, max_num, axis=0):
method forward (line 94) | def forward(self, batch_dict, **kwargs):
FILE: pcdet/models/backbones_3d/vfe/vfe_template.py
class VFETemplate (line 4) | class VFETemplate(nn.Module):
method __init__ (line 5) | def __init__(self, model_cfg, **kwargs):
method get_output_feature_dim (line 9) | def get_output_feature_dim(self):
method forward (line 12) | def forward(self, **kwargs):
FILE: pcdet/models/dense_heads/anchor_head_multi.py
class SingleHead (line 9) | class SingleHead(BaseBEVBackbone):
method __init__ (line 10) | def __init__(self, model_cfg, input_channels, num_class, num_anchors_p...
method init_weights (line 97) | def init_weights(self):
method forward (line 104) | def forward(self, spatial_features_2d):
class AnchorHeadMulti (line 151) | class AnchorHeadMulti(AnchorHeadTemplate):
method __init__ (line 152) | def __init__(self, model_cfg, input_channels, num_class, class_names, ...
method make_multihead (line 174) | def make_multihead(self, input_channels):
method forward (line 198) | def forward(self, data_dict):
method get_cls_layer_loss (line 245) | def get_cls_layer_loss(self):
method get_box_reg_layer_loss (line 303) | def get_box_reg_layer_loss(self):
FILE: pcdet/models/dense_heads/anchor_head_single.py
function get_layer (line 9) | def get_layer(dim,out_dim,init = None):
class AnchorHeadSingle (line 31) | class AnchorHeadSingle(AnchorHeadTemplate):
method __init__ (line 32) | def __init__(self, model_cfg, input_channels, num_class, class_names, ...
method init_weights (line 70) | def init_weights(self):
method get_anchor_mask (line 75) | def get_anchor_mask(self,data_dict,shape):
method forward (line 118) | def forward(self, data_dict):
FILE: pcdet/models/dense_heads/anchor_head_template.py
class AnchorHeadTemplate (line 13) | class AnchorHeadTemplate(nn.Module):
method __init__ (line 14) | def __init__(self, model_cfg, num_class, class_names, grid_size, point...
method generate_anchors (line 45) | def generate_anchors(anchor_generator_cfg, grid_size, point_cloud_rang...
method get_target_assigner (line 61) | def get_target_assigner(self, anchor_target_cfg):
method proposal_layer (line 82) | def proposal_layer(self, batch_dict, nms_config):
method build_losses (line 145) | def build_losses(self, losses_cfg):
method assign_targets (line 165) | def assign_targets(self, gt_boxes):
method get_cls_layer_loss (line 178) | def get_cls_layer_loss(self):
method add_sin_difference (line 218) | def add_sin_difference(boxes1, boxes2, dim=6):
method get_direction_target (line 227) | def get_direction_target(anchors, reg_targets, one_hot=True, dir_offse...
method get_box_reg_layer_loss (line 242) | def get_box_reg_layer_loss(self):
method get_od_loss (line 296) | def get_od_loss(self):
method get_loss (line 320) | def get_loss(self):
method generate_predicted_boxes (line 335) | def generate_predicted_boxes(self, batch_size, cls_preds, box_preds, d...
method forward (line 384) | def forward(self, **kwargs):
FILE: pcdet/models/dense_heads/center_head.py
class SeparateHead (line 11) | class SeparateHead(nn.Module):
method __init__ (line 12) | def __init__(self, input_channels, sep_head_dict, init_bias=-2.19, use...
method forward (line 40) | def forward(self, x):
class CenterHead (line 48) | class CenterHead(nn.Module):
method __init__ (line 49) | def __init__(self, model_cfg, num_frames, input_channels, num_class, c...
method build_losses (line 99) | def build_losses(self):
method assign_target_of_single_head (line 103) | def assign_target_of_single_head(
method assign_targets (line 159) | def assign_targets(self, gt_boxes, feature_map_size=None, **kwargs):
method sigmoid (line 221) | def sigmoid(self, x):
method get_loss (line 225) | def get_loss(self):
method generate_predicted_boxes (line 252) | def generate_predicted_boxes(self, batch_size, pred_dicts):
method reorder_rois_for_refining (line 306) | def reorder_rois_for_refining(batch_size, pred_dicts):
method forward (line 323) | def forward(self, data_dict):
FILE: pcdet/models/dense_heads/point_head_box.py
class PointHeadBox (line 7) | class PointHeadBox(PointHeadTemplate):
method __init__ (line 13) | def __init__(self, num_class, input_channels, model_cfg, predict_boxes...
method assign_targets (line 32) | def assign_targets(self, input_dict):
method get_loss (line 61) | def get_loss(self, tb_dict=None):
method forward (line 71) | def forward(self, batch_dict):
FILE: pcdet/models/dense_heads/point_head_simple.py
class PointHeadSimple (line 7) | class PointHeadSimple(PointHeadTemplate):
method __init__ (line 13) | def __init__(self, num_class, input_channels, model_cfg, **kwargs):
method assign_targets (line 21) | def assign_targets(self, input_dict):
method get_loss (line 50) | def get_loss(self, tb_dict=None):
method forward (line 58) | def forward(self, batch_dict):
FILE: pcdet/models/dense_heads/point_head_template.py
class PointHeadTemplate (line 9) | class PointHeadTemplate(nn.Module):
method __init__ (line 10) | def __init__(self, model_cfg, num_class):
method build_losses (line 18) | def build_losses(self, losses_cfg):
method make_fc_layers (line 36) | def make_fc_layers(fc_cfg, input_channels, output_channels):
method assign_stack_targets (line 49) | def assign_stack_targets(self, points, gt_boxes, extend_gt_boxes=None,
method get_cls_layer_loss (line 131) | def get_cls_layer_loss(self, tb_dict=None):
method get_part_layer_loss (line 157) | def get_part_layer_loss(self, tb_dict=None):
method get_box_layer_loss (line 172) | def get_box_layer_loss(self, tb_dict=None):
method generate_predicted_boxes (line 193) | def generate_predicted_boxes(self, points, point_cls_preds, point_box_...
method forward (line 209) | def forward(self, **kwargs):
FILE: pcdet/models/dense_heads/point_intra_part_head.py
class PointIntraPartOffsetHead (line 7) | class PointIntraPartOffsetHead(PointHeadTemplate):
method __init__ (line 13) | def __init__(self, num_class, input_channels, model_cfg, predict_boxes...
method assign_targets (line 39) | def assign_targets(self, input_dict):
method get_loss (line 68) | def get_loss(self, tb_dict=None):
method forward (line 79) | def forward(self, batch_dict):
FILE: pcdet/models/dense_heads/target_assigner/anchor_generator.py
class AnchorGenerator (line 4) | class AnchorGenerator(object):
method __init__ (line 5) | def __init__(self, anchor_range, anchor_generator_config):
method generate_anchors (line 17) | def generate_anchors(self, grid_sizes):
FILE: pcdet/models/dense_heads/target_assigner/atss_target_assigner.py
class ATSSTargetAssigner (line 7) | class ATSSTargetAssigner(object):
method __init__ (line 11) | def __init__(self, topk, box_coder, match_height=False):
method assign_targets (line 16) | def assign_targets(self, anchors_list, gt_boxes_with_classes, use_mult...
method assign_targets_single (line 75) | def assign_targets_single(self, anchors, gt_boxes, gt_classes):
FILE: pcdet/models/dense_heads/target_assigner/axis_aligned_target_assigner.py
class AxisAlignedTargetAssigner (line 9) | class AxisAlignedTargetAssigner(object):
method __init__ (line 10) | def __init__(self, model_cfg, class_names, box_coder, grid_size, point...
method assign_targets (line 46) | def assign_targets(self, all_anchors, gt_boxes_with_classes):
method assign_targets_single (line 156) | def assign_targets_single(self, anchors,
FILE: pcdet/models/detectors/__init__.py
function build_detector (line 10) | def build_detector(model_cfg, num_class, dataset):
FILE: pcdet/models/detectors/detector3d_template.py
class Detector3DTemplate (line 12) | class Detector3DTemplate(nn.Module):
method __init__ (line 13) | def __init__(self, model_cfg, num_class, dataset):
method mode (line 29) | def mode(self):
method update_global_step (line 32) | def update_global_step(self):
method build_networks (line 35) | def build_networks(self):
method build_vfe (line 51) | def build_vfe(self, model_info_dict):
method build_backbone_3d (line 65) | def build_backbone_3d(self, model_info_dict):
method build_map_to_bev_module (line 80) | def build_map_to_bev_module(self, model_info_dict):
method build_backbone_2d (line 93) | def build_backbone_2d(self, model_info_dict):
method build_pfe (line 107) | def build_pfe(self, model_info_dict):
method build_dense_head (line 127) | def build_dense_head(self, model_info_dict):
method build_point_head (line 144) | def build_point_head(self, model_info_dict):
method build_roi_head (line 163) | def build_roi_head(self, model_info_dict):
method forward (line 177) | def forward(self, **kwargs):
method post_processing (line 180) | def post_processing(self, batch_dict):
method generate_recall_record (line 303) | def generate_recall_record(box_preds, recall_dict, batch_index, data_d...
method _load_state_dict (line 346) | def _load_state_dict(self, model_state_disk, *, strict=True):
method load_params_from_file (line 377) | def load_params_from_file(self, filename, logger, to_cpu=False):
method load_params_with_optimizer (line 398) | def load_params_with_optimizer(self, filename, to_cpu=False, optimizer...
FILE: pcdet/models/detectors/voxel_rcnn.py
class VoxelRCNN (line 3) | class VoxelRCNN(Detector3DTemplate):
method __init__ (line 4) | def __init__(self, model_cfg, num_class, dataset):
method forward (line 8) | def forward(self, batch_dict):
method get_training_loss (line 24) | def get_training_loss(self):
FILE: pcdet/models/model_utils/centernet_utils.py
function gaussian_radius (line 9) | def gaussian_radius(height, width, min_overlap=0.5):
function gaussian2D (line 38) | def gaussian2D(shape, sigma=1):
function draw_gaussian_to_heatmap (line 47) | def draw_gaussian_to_heatmap(heatmap, center, radius, k=1, valid_mask=No...
function _nms (line 72) | def _nms(heat, kernel=3):
function circle_nms (line 81) | def circle_nms(dets, thresh):
function _circle_nms (line 107) | def _circle_nms(boxes, min_radius, post_max_size=83):
function _gather_feat (line 118) | def _gather_feat(feat, ind, mask=None):
function _transpose_and_gather_feat (line 129) | def _transpose_and_gather_feat(feat, ind):
function _topk (line 136) | def _topk(scores, K=40):
function decode_bbox_from_heatmap (line 154) | def decode_bbox_from_heatmap(heatmap, rot_cos, rot_sin, center, center_z...
FILE: pcdet/models/model_utils/ctrans.py
class PositionalEmbedding (line 13) | class PositionalEmbedding(nn.Module):
method __init__ (line 14) | def __init__(self, demb=256):
method forward (line 23) | def forward(self, pos_seq, batch_size=2):
class CrossAttention (line 32) | class CrossAttention(nn.Module):
method __init__ (line 34) | def __init__(self, hidden_dim, pos = True, head = 4):
method forward (line 56) | def forward(self, inputs, Q_in): # N,B,C
class Attention_Layer (line 81) | class Attention_Layer(nn.Module):
method __init__ (line 83) | def __init__(self, hidden_dim):
method forward (line 92) | def forward(self, inputs): # B,K,N
function gen_sample_grid (line 110) | def gen_sample_grid(rois, grid_size=7, grid_offsets=(0, 0), spatial_scal...
function bilinear_interpolate_torch_gridsample (line 137) | def bilinear_interpolate_torch_gridsample(image, samples_x, samples_y):
class MLP (line 160) | class MLP(nn.Module):
method __init__ (line 163) | def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
method forward (line 171) | def forward(self, x):
method init_weights (line 176) | def init_weights(self):
function MLP_v2 (line 185) | def MLP_v2(channels: list, do_bn=True):
class Transformer (line 198) | class Transformer(nn.Module):
method __init__ (line 200) | def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
method _reset_parameters (line 222) | def _reset_parameters(self):
method forward (line 227) | def forward(self, src, query_embed, pos_embed):
class TransformerEncoder (line 239) | class TransformerEncoder(nn.Module):
method __init__ (line 241) | def __init__(self, encoder_layer, num_layers, norm=None):
method forward (line 247) | def forward(self, src,
class TransformerDecoder (line 263) | class TransformerDecoder(nn.Module):
method __init__ (line 265) | def __init__(self, decoder_layer, num_layers, norm=None, return_interm...
method forward (line 272) | def forward(self, tgt, memory,
class TransformerEncoderLayer (line 304) | class TransformerEncoderLayer(nn.Module):
method __init__ (line 306) | def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
method with_pos_embed (line 323) | def with_pos_embed(self, tensor, pos: Optional[Tensor]):
method forward_post (line 326) | def forward_post(self,
method forward_pre (line 341) | def forward_pre(self, src,
method forward (line 355) | def forward(self, src,
function attention (line 364) | def attention(query, key, value):
class MultiHeadedAttention (line 372) | class MultiHeadedAttention(nn.Module):
method __init__ (line 374) | def __init__(self, num_heads: int, d_model: int):
method forward (line 384) | def forward(self, query, key, value):
class TransformerDecoderLayer (line 394) | class TransformerDecoderLayer(nn.Module):
method __init__ (line 396) | def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
method with_pos_embed (line 418) | def with_pos_embed(self, tensor, pos: Optional[Tensor]):
method forward_post (line 421) | def forward_post(self, tgt, memory,
method forward_pre (line 445) | def forward_pre(self, tgt, memory,
method forward (line 468) | def forward(self, tgt, memory,
function _get_clones (line 482) | def _get_clones(module, N):
function build_transformer (line 486) | def build_transformer(args):
function _get_activation_fn (line 499) | def _get_activation_fn(activation):
FILE: pcdet/models/model_utils/model_nms_utils.py
function limit (line 5) | def limit(ang):
function compute_WBF (line 14) | def compute_WBF(det_names, det_scores, det_boxes, iou_thresh=0.85, iou_t...
function class_agnostic_nms (line 108) | def class_agnostic_nms(box_scores, box_preds, nms_config, score_thresh=N...
function multi_classes_nms (line 130) | def multi_classes_nms(cls_scores, box_preds, nms_config, score_thresh=No...
FILE: pcdet/models/roi_heads/roi_head_template.py
class RoIHeadTemplate (line 12) | class RoIHeadTemplate(nn.Module):
method __init__ (line 13) | def __init__(self, num_class, model_cfg):
method build_losses (line 29) | def build_losses(self, losses_cfg):
method make_fc_layers (line 35) | def make_fc_layers(self, input_channels, output_channels, fc_list):
method proposal_layer (line 52) | def proposal_layer(self, batch_dict, nms_config):
method assign_targets (line 116) | def assign_targets(self, batch_dict, rot_num_id, enable_dif = False):
method get_box_reg_layer_loss (line 156) | def get_box_reg_layer_loss(self, forward_ret_dict):
method get_box_cls_layer_loss (line 240) | def get_box_cls_layer_loss(self, forward_ret_dict):
method get_loss (line 262) | def get_loss(self, tb_dict=None):
method generate_predicted_boxes (line 289) | def generate_predicted_boxes(self, batch_size, rois, cls_preds, box_pr...
FILE: pcdet/models/roi_heads/target_assigner/proposal_target_layer.py
class ProposalTargetLayer (line 7) | class ProposalTargetLayer(nn.Module):
method __init__ (line 8) | def __init__(self, roi_sampler_cfg):
method limit (line 12) | def limit(self,ang):
method ang_weight (line 21) | def ang_weight(self,pred, gt):
method forward (line 32) | def forward(self, batch_dict, ind=''):
method sample_rois_for_rcnn (line 196) | def sample_rois_for_rcnn(self, batch_dict, ind=''):
method subsample_rois (line 254) | def subsample_rois(self, max_overlaps, gts=None):
method sample_bg_inds (line 326) | def sample_bg_inds(hard_bg_inds, easy_bg_inds, bg_rois_per_this_image,...
method get_max_iou_with_same_class (line 356) | def get_max_iou_with_same_class(rois, roi_labels, gt_boxes, gt_labels):
class ProposalTargetLayerT (line 391) | class ProposalTargetLayerT(nn.Module):
method __init__ (line 392) | def __init__(self, roi_sampler_cfg):
method limit (line 396) | def limit(self,ang):
method ang_weight (line 405) | def ang_weight(self,pred, gt):
method forward (line 416) | def forward(self, batch_dict):
method sample_rois_for_rcnn (line 498) | def sample_rois_for_rcnn(self, batch_dict):
method subsample_rois (line 579) | def subsample_rois(self, max_overlaps):
method sample_bg_inds (line 627) | def sample_bg_inds(hard_bg_inds, easy_bg_inds, bg_rois_per_this_image,...
method get_max_iou_with_same_class (line 657) | def get_max_iou_with_same_class(rois, roi_labels, gt_boxes, gt_labels):
FILE: pcdet/models/roi_heads/target_assigner/proposal_target_layer3.py
class ProposalTargetLayer (line 7) | class ProposalTargetLayer(nn.Module):
method __init__ (line 8) | def __init__(self, roi_sampler_cfg):
method limit (line 12) | def limit(self,ang):
method ang_weight (line 21) | def ang_weight(self,pred, gt):
method forward (line 32) | def forward(self, batch_dict,ind=''):
method sample_rois_for_rcnn (line 127) | def sample_rois_for_rcnn(self, batch_dict, ind=''):
method subsample_rois (line 184) | def subsample_rois(self, max_overlaps, gts=None):
method sample_bg_inds (line 254) | def sample_bg_inds(hard_bg_inds, easy_bg_inds, bg_rois_per_this_image,...
method get_max_iou_with_same_class (line 284) | def get_max_iou_with_same_class(rois, roi_labels, gt_boxes, gt_labels):
class ProposalTargetLayerT (line 319) | class ProposalTargetLayerT(nn.Module):
method __init__ (line 320) | def __init__(self, roi_sampler_cfg):
method limit (line 324) | def limit(self,ang):
method ang_weight (line 333) | def ang_weight(self,pred, gt):
method forward (line 344) | def forward(self, batch_dict):
method sample_rois_for_rcnn (line 426) | def sample_rois_for_rcnn(self, batch_dict):
method subsample_rois (line 507) | def subsample_rois(self, max_overlaps):
method sample_bg_inds (line 555) | def sample_bg_inds(hard_bg_inds, easy_bg_inds, bg_rois_per_this_image,...
method get_max_iou_with_same_class (line 585) | def get_max_iou_with_same_class(rois, roi_labels, gt_boxes, gt_labels):
FILE: pcdet/models/roi_heads/ted_head.py
class PositionalEmbedding (line 15) | class PositionalEmbedding(nn.Module):
method __init__ (line 16) | def __init__(self, demb=256):
method forward (line 25) | def forward(self, pos_seq, batch_size=2):
class CrossAttention (line 34) | class CrossAttention(nn.Module):
method __init__ (line 36) | def __init__(self, hidden_dim, pos = True, head = 4):
method forward (line 58) | def forward(self, inputs, Q_in): # N,B,C
class Attention_Layer (line 82) | class Attention_Layer(nn.Module):
method __init__ (line 84) | def __init__(self, hidden_dim):
method forward (line 93) | def forward(self, inputs): # B,K,N
function gen_sample_grid (line 110) | def gen_sample_grid(rois, grid_size=7, grid_offsets=(0, 0), spatial_scal...
function bilinear_interpolate_torch_gridsample (line 137) | def bilinear_interpolate_torch_gridsample(image, samples_x, samples_y):
class TEDSHead (line 158) | class TEDSHead(RoIHeadTemplate):
method __init__ (line 159) | def __init__(self, input_channels, model_cfg, point_cloud_range=None, ...
method init_weights (line 247) | def init_weights(self):
method roi_grid_pool (line 265) | def roi_grid_pool(self, batch_dict, i):
method get_global_grid_points_of_roi (line 369) | def get_global_grid_points_of_roi(self, rois, grid_size):
method get_dense_grid_points (line 382) | def get_dense_grid_points(rois, batch_size_rcnn, grid_size):
method roi_x_trans (line 392) | def roi_x_trans(self, rois, rot_num_i, transform_param):
method pred_x_trans (line 416) | def pred_x_trans(self, preds, rot_num_i, transform_param):
method multi_grid_pool_aggregation (line 436) | def multi_grid_pool_aggregation(self, batch_dict, targets_dict):
method forward (line 499) | def forward(self, batch_dict):
class TEDMHead (line 517) | class TEDMHead(RoIHeadTemplate):
method __init__ (line 518) | def __init__(self, input_channels, model_cfg, point_cloud_range=None, ...
method init_weights (line 765) | def init_weights(self):
method obtain_conf_preds (line 784) | def obtain_conf_preds(self, confi_im, anchors):
method roi_part_pool (line 803) | def roi_part_pool(self, batch_dict, parts_feat):
method roi_grid_pool (line 809) | def roi_grid_pool(self, batch_dict, i):
method roi_grid_pool_mm (line 912) | def roi_grid_pool_mm(self, batch_dict, i):
method get_global_grid_points_of_roi (line 1015) | def get_global_grid_points_of_roi(self, rois, grid_size):
method get_dense_grid_points (line 1028) | def get_dense_grid_points(rois, batch_size_rcnn, grid_size):
method roi_x_trans (line 1039) | def roi_x_trans(self, rois, trans_i, transform_param):
method roi_score_trans (line 1064) | def roi_score_trans(self, rois, trans_i, transform_param):
method pred_x_trans (line 1089) | def pred_x_trans(self, preds, trans_i, transform_param):
method multi_grid_pool_aggregation (line 1111) | def multi_grid_pool_aggregation(self, batch_dict, targets_dict):
method forward (line 1218) | def forward(self, batch_dict):
FILE: pcdet/ops/dcn/deform_conv.py
class DeformConvFunction (line 14) | class DeformConvFunction(Function):
method forward (line 17) | def forward(ctx,
method backward (line 62) | def backward(ctx, grad_output):
method _output_size (line 99) | def _output_size(input, weight, padding, dilation, stride):
class ModulatedDeformConvFunction (line 115) | class ModulatedDeformConvFunction(Function):
method forward (line 118) | def forward(ctx,
method backward (line 154) | def backward(ctx, grad_output):
method _infer_shape (line 176) | def _infer_shape(ctx, input, weight):
class DeformConv (line 192) | class DeformConv(nn.Module):
method __init__ (line 194) | def __init__(self,
method reset_parameters (line 232) | def reset_parameters(self):
method forward (line 239) | def forward(self, x, offset):
class DeformConvPack (line 258) | class DeformConvPack(DeformConv):
method __init__ (line 276) | def __init__(self, *args, **kwargs):
method init_offset (line 289) | def init_offset(self):
method forward (line 293) | def forward(self, x):
method _load_from_state_dict (line 298) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
class ModulatedDeformConv (line 326) | class ModulatedDeformConv(nn.Module):
method __init__ (line 328) | def __init__(self,
method reset_parameters (line 361) | def reset_parameters(self):
method forward (line 370) | def forward(self, x, offset, mask):
class ModulatedDeformConvPack (line 376) | class ModulatedDeformConvPack(ModulatedDeformConv):
method __init__ (line 394) | def __init__(self, *args, **kwargs):
method init_offset (line 407) | def init_offset(self):
method forward (line 411) | def forward(self, x):
method _load_from_state_dict (line 420) | def _load_from_state_dict(self, state_dict, prefix, local_metadata, st...
FILE: pcdet/ops/dcn/src/deform_conv_cuda.cpp
function shape_check (line 62) | void shape_check(at::Tensor input, at::Tensor offset, at::Tensor *gradOu...
function deform_conv_forward_cuda (line 152) | int deform_conv_forward_cuda(at::Tensor input, at::Tensor weight,
function deform_conv_backward_input_cuda (line 262) | int deform_conv_backward_input_cuda(at::Tensor input, at::Tensor offset,
function deform_conv_backward_parameters_cuda (line 376) | int deform_conv_backward_parameters_cuda(
function modulated_deform_conv_cuda_forward (line 490) | void modulated_deform_conv_cuda_forward(
function modulated_deform_conv_cuda_backward (line 571) | void modulated_deform_conv_cuda_backward(
function PYBIND11_MODULE (line 687) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/dcn/src/deform_pool_cuda.cpp
function deform_psroi_pooling_cuda_forward (line 31) | void deform_psroi_pooling_cuda_forward(
function deform_psroi_pooling_cuda_backward (line 56) | void deform_psroi_pooling_cuda_backward(
function PYBIND11_MODULE (line 84) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/iou3d_nms/iou3d_nms_utils.py
function boxes_bev_iou_cpu (line 12) | def boxes_bev_iou_cpu(boxes_a, boxes_b):
function boxes_iou_bev (line 31) | def boxes_iou_bev(boxes_a, boxes_b):
function boxes_dis (line 47) | def boxes_dis(boxes_a, boxes_b):
function boxes_iou3d_gpu (line 67) | def boxes_iou3d_gpu(boxes_a, boxes_b):
function nms_gpu (line 103) | def nms_gpu(boxes, scores, thresh, pre_maxsize=None, **kwargs):
function nms_normal_gpu (line 121) | def nms_normal_gpu(boxes, scores, thresh, **kwargs):
FILE: pcdet/ops/iou3d_nms/src/iou3d_cpu.cpp
function min (line 30) | inline float min(float a, float b){
function max (line 34) | inline float max(float a, float b){
type Point (line 39) | struct Point {
method __device__ (line 41) | __device__ Point() {}
method __device__ (line 42) | __device__ Point(double _x, double _y){
method __device__ (line 46) | __device__ void set(float _x, float _y){
method __device__ (line 50) | __device__ Point operator +(const Point &b)const{
method __device__ (line 54) | __device__ Point operator -(const Point &b)const{
function cross (line 59) | inline float cross(const Point &a, const Point &b){
function cross (line 63) | inline float cross(const Point &p1, const Point &p2, const Point &p0){
function check_rect_cross (line 67) | inline int check_rect_cross(const Point &p1, const Point &p2, const Poin...
function check_in_box2d (line 75) | inline int check_in_box2d(const float *box, const Point &p){
function intersection (line 87) | inline int intersection(const Point &p1, const Point &p0, const Point &q...
function rotate_around_center (line 118) | inline void rotate_around_center(const Point ¢er, const float angle_...
function point_cmp (line 124) | inline int point_cmp(const Point &a, const Point &b, const Point ¢er){
function box_overlap (line 128) | inline float box_overlap(const float *box_a, const float *box_b){
function iou_bev (line 222) | inline float iou_bev(const float *box_a, const float *box_b){
function boxes_iou_bev_cpu (line 232) | int boxes_iou_bev_cpu(at::Tensor boxes_a_tensor, at::Tensor boxes_b_tens...
FILE: pcdet/ops/iou3d_nms/src/iou3d_nms.cpp
function gpuAssert (line 31) | inline void gpuAssert(cudaError_t code, const char *file, int line, bool...
function boxes_overlap_bev_gpu (line 49) | int boxes_overlap_bev_gpu(at::Tensor boxes_a, at::Tensor boxes_b, at::Te...
function boxes_iou_bev_gpu (line 70) | int boxes_iou_bev_gpu(at::Tensor boxes_a, at::Tensor boxes_b, at::Tensor...
function nms_gpu (line 90) | int nms_gpu(at::Tensor boxes, at::Tensor keep, float nms_overlap_thresh){
function nms_normal_gpu (line 139) | int nms_normal_gpu(at::Tensor boxes, at::Tensor keep, float nms_overlap_...
FILE: pcdet/ops/iou3d_nms/src/iou3d_nms_api.cpp
function PYBIND11_MODULE (line 11) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/pointnet2/pointnet2_batch/pointnet2_modules.py
class _PointnetSAModuleBase (line 10) | class _PointnetSAModuleBase(nn.Module):
method __init__ (line 12) | def __init__(self):
method forward (line 19) | def forward(self, xyz: torch.Tensor, features: torch.Tensor = None, ne...
class PointnetSAModuleMSG (line 58) | class PointnetSAModuleMSG(_PointnetSAModuleBase):
method __init__ (line 61) | def __init__(self, *, npoint: int, radii: List[float], nsamples: List[...
class PointnetSAModule (line 102) | class PointnetSAModule(PointnetSAModuleMSG):
method __init__ (line 105) | def __init__(self, *, mlp: List[int], npoint: int = None, radius: floa...
class PointnetFPModule (line 122) | class PointnetFPModule(nn.Module):
method __init__ (line 125) | def __init__(self, *, mlp: List[int], bn: bool = True):
method forward (line 141) | def forward(
FILE: pcdet/ops/pointnet2/pointnet2_batch/pointnet2_utils.py
class FurthestPointSampling (line 10) | class FurthestPointSampling(Function):
method forward (line 12) | def forward(ctx, xyz: torch.Tensor, npoint: int) -> torch.Tensor:
method backward (line 32) | def backward(xyz, a=None):
class GatherOperation (line 39) | class GatherOperation(Function):
method forward (line 42) | def forward(ctx, features: torch.Tensor, idx: torch.Tensor) -> torch.T...
method backward (line 63) | def backward(ctx, grad_out):
class ThreeNN (line 76) | class ThreeNN(Function):
method forward (line 79) | def forward(ctx, unknown: torch.Tensor, known: torch.Tensor) -> Tuple[...
method backward (line 101) | def backward(ctx, a=None, b=None):
class ThreeInterpolate (line 108) | class ThreeInterpolate(Function):
method forward (line 111) | def forward(ctx, features: torch.Tensor, idx: torch.Tensor, weight: to...
method backward (line 134) | def backward(ctx, grad_out: torch.Tensor) -> Tuple[torch.Tensor, torch...
class GroupingOperation (line 156) | class GroupingOperation(Function):
method forward (line 159) | def forward(ctx, features: torch.Tensor, idx: torch.Tensor) -> torch.T...
method backward (line 180) | def backward(ctx, grad_out: torch.Tensor) -> Tuple[torch.Tensor, torch...
class BallQuery (line 200) | class BallQuery(Function):
method forward (line 203) | def forward(ctx, radius: float, nsample: int, xyz: torch.Tensor, new_x...
method backward (line 224) | def backward(ctx, a=None):
class QueryAndGroup (line 231) | class QueryAndGroup(nn.Module):
method __init__ (line 232) | def __init__(self, radius: float, nsample: int, use_xyz: bool = True):
method forward (line 241) | def forward(self, xyz: torch.Tensor, new_xyz: torch.Tensor, features: ...
class GroupAll (line 267) | class GroupAll(nn.Module):
method __init__ (line 268) | def __init__(self, use_xyz: bool = True):
method forward (line 272) | def forward(self, xyz: torch.Tensor, new_xyz: torch.Tensor, features: ...
FILE: pcdet/ops/pointnet2/pointnet2_batch/src/ball_query.cpp
function ball_query_wrapper_fast (line 32) | int ball_query_wrapper_fast(int b, int n, int m, float radius, int nsample,
FILE: pcdet/ops/pointnet2/pointnet2_batch/src/cuda_utils.h
function opt_n_threads (line 10) | inline int opt_n_threads(int work_size) {
FILE: pcdet/ops/pointnet2/pointnet2_batch/src/group_points.cpp
function group_points_grad_wrapper_fast (line 18) | int group_points_grad_wrapper_fast(int b, int c, int n, int npoints, int...
function group_points_wrapper_fast (line 30) | int group_points_wrapper_fast(int b, int c, int n, int npoints, int nsam...
FILE: pcdet/ops/pointnet2/pointnet2_batch/src/interpolate.cpp
function three_nn_wrapper_fast (line 21) | void three_nn_wrapper_fast(int b, int n, int m, at::Tensor unknown_tensor,
function three_interpolate_wrapper_fast (line 32) | void three_interpolate_wrapper_fast(int b, int c, int m, int n,
function three_interpolate_grad_wrapper_fast (line 46) | void three_interpolate_grad_wrapper_fast(int b, int c, int n, int m,
FILE: pcdet/ops/pointnet2/pointnet2_batch/src/pointnet2_api.cpp
function PYBIND11_MODULE (line 10) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/pointnet2/pointnet2_batch/src/sampling.cpp
function gather_points_wrapper_fast (line 18) | int gather_points_wrapper_fast(int b, int c, int n, int npoints,
function gather_points_grad_wrapper_fast (line 29) | int gather_points_grad_wrapper_fast(int b, int c, int n, int npoints,
function furthest_point_sampling_wrapper (line 41) | int furthest_point_sampling_wrapper(int b, int n, int m,
FILE: pcdet/ops/pointnet2/pointnet2_stack/pointnet2_modules.py
function build_local_aggregation_module (line 10) | def build_local_aggregation_module(input_channels, config):
class StackSAModuleMSG (line 30) | class StackSAModuleMSG(nn.Module):
method __init__ (line 32) | def __init__(self, *, radii: List[float], nsamples: List[int], mlps: L...
method init_weights (line 68) | def init_weights(self):
method forward (line 78) | def forward(self, xyz, xyz_batch_cnt, new_xyz, new_xyz_batch_cnt, feat...
class StackPointnetFPModule (line 115) | class StackPointnetFPModule(nn.Module):
method __init__ (line 116) | def __init__(self, *, mlp: List[int]):
method forward (line 131) | def forward(self, unknown, unknown_batch_cnt, known, known_batch_cnt, ...
class VectorPoolLocalInterpolateModule (line 160) | class VectorPoolLocalInterpolateModule(nn.Module):
method __init__ (line 161) | def __init__(self, mlp, num_voxels, max_neighbour_distance, nsample, n...
method forward (line 200) | def forward(self, support_xyz, support_features, xyz_batch_cnt, new_xy...
class VectorPoolAggregationModule (line 247) | class VectorPoolAggregationModule(nn.Module):
method __init__ (line 248) | def __init__(
method init_weights (line 299) | def init_weights(self):
method extra_repr (line 309) | def extra_repr(self) -> str:
method vector_pool_with_voxel_query (line 316) | def vector_pool_with_voxel_query(self, xyz, xyz_batch_cnt, features, n...
method get_dense_voxels_by_center (line 337) | def get_dense_voxels_by_center(point_centers, max_neighbour_distance, ...
method vector_pool_with_local_interpolate (line 361) | def vector_pool_with_local_interpolate(self, xyz, xyz_batch_cnt, featu...
method forward (line 383) | def forward(self, xyz, xyz_batch_cnt, new_xyz, new_xyz_batch_cnt, feat...
class VectorPoolAggregationModuleMSG (line 423) | class VectorPoolAggregationModuleMSG(nn.Module):
method __init__ (line 424) | def __init__(self, input_channels, config):
method forward (line 458) | def forward(self, **kwargs):
FILE: pcdet/ops/pointnet2/pointnet2_stack/pointnet2_utils.py
class BallQuery (line 8) | class BallQuery(Function):
method forward (line 11) | def forward(ctx, radius: float, nsample: int, xyz: torch.Tensor, xyz_b...
method backward (line 41) | def backward(ctx, a=None):
class GroupingOperation (line 48) | class GroupingOperation(Function):
method forward (line 51) | def forward(ctx, features: torch.Tensor, features_batch_cnt: torch.Ten...
method backward (line 85) | def backward(ctx, grad_out: torch.Tensor):
class QueryAndGroup (line 108) | class QueryAndGroup(nn.Module):
method __init__ (line 109) | def __init__(self, radius: float, nsample: int, use_xyz: bool = True):
method forward (line 119) | def forward(self, xyz: torch.Tensor, xyz_batch_cnt: torch.Tensor,
class FarthestPointSampling (line 158) | class FarthestPointSampling(Function):
method forward (line 160) | def forward(ctx, xyz: torch.Tensor, npoint: int):
method backward (line 180) | def backward(xyz, a=None):
class StackFarthestPointSampling (line 187) | class StackFarthestPointSampling(Function):
method forward (line 189) | def forward(ctx, xyz, xyz_batch_cnt, npoint):
method backward (line 217) | def backward(xyz, a=None):
class ThreeNN (line 224) | class ThreeNN(Function):
method forward (line 226) | def forward(ctx, unknown, unknown_batch_cnt, known, known_batch_cnt):
method backward (line 253) | def backward(ctx, a=None, b=None):
class ThreeInterpolate (line 260) | class ThreeInterpolate(Function):
method forward (line 263) | def forward(ctx, features: torch.Tensor, idx: torch.Tensor, weight: to...
method backward (line 282) | def backward(ctx, grad_out: torch.Tensor):
class ThreeNNForVectorPoolByTwoStep (line 302) | class ThreeNNForVectorPoolByTwoStep(Function):
method forward (line 304) | def forward(ctx, support_xyz, xyz_batch_cnt, new_xyz, new_xyz_grid_cen...
class VectorPoolWithVoxelQuery (line 357) | class VectorPoolWithVoxelQuery(Function):
method forward (line 359) | def forward(ctx, support_xyz: torch.Tensor, xyz_batch_cnt: torch.Tenso...
method backward (line 428) | def backward(ctx, grad_new_features: torch.Tensor, grad_local_xyz: tor...
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/ball_query.cpp
function ball_query_wrapper_stack (line 31) | int ball_query_wrapper_stack(int B, int M, float radius, int nsample,
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/ball_query_deform.cpp
function ball_query_deform_wrapper_stack (line 24) | int ball_query_deform_wrapper_stack(int B, int M, int nsample,
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/group_points.cpp
function group_points_grad_wrapper_stack (line 31) | int group_points_grad_wrapper_stack(int B, int M, int C, int N, int nsam...
function group_points_wrapper_stack (line 52) | int group_points_wrapper_stack(int B, int M, int C, int nsample,
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/interpolate.cpp
function three_nn_wrapper_stack (line 35) | void three_nn_wrapper_stack(at::Tensor unknown_tensor,
function three_interpolate_wrapper_stack (line 66) | void three_interpolate_wrapper_stack(at::Tensor features_tensor,
function three_interpolate_grad_wrapper_stack (line 89) | void three_interpolate_grad_wrapper_stack(at::Tensor grad_out_tensor, at...
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/pointnet2_api.cpp
function PYBIND11_MODULE (line 12) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/sampling.cpp
function farthest_point_sampling_wrapper (line 24) | int farthest_point_sampling_wrapper(int b, int n, int m,
function stack_farthest_point_sampling_wrapper (line 40) | int stack_farthest_point_sampling_wrapper(at::Tensor points_tensor,
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/vector_pool.cpp
function query_stacked_local_neighbor_idxs_wrapper_stack (line 35) | int query_stacked_local_neighbor_idxs_wrapper_stack(at::Tensor support_x...
function query_three_nn_by_stacked_local_idxs_wrapper_stack (line 78) | int query_three_nn_by_stacked_local_idxs_wrapper_stack(at::Tensor suppor...
function vector_pool_wrapper_stack (line 116) | int vector_pool_wrapper_stack(at::Tensor support_xyz_tensor, at::Tensor ...
function vector_pool_grad_wrapper_stack (line 173) | int vector_pool_grad_wrapper_stack(at::Tensor grad_new_features_tensor,
FILE: pcdet/ops/pointnet2/pointnet2_stack/src/voxel_query.cpp
function voxel_query_wrapper_stack (line 25) | int voxel_query_wrapper_stack(int M, int R1, int R2, int R3, int nsample...
FILE: pcdet/ops/pointnet2/pointnet2_stack/voxel_pool_modules.py
class NeighborVoxelSAModuleMSG (line 8) | class NeighborVoxelSAModuleMSG(nn.Module):
method __init__ (line 10) | def __init__(self, *, query_ranges: List[List[int]], radii: List[float],
method init_weights (line 60) | def init_weights(self):
method forward (line 70) | def forward(self, xyz, xyz_batch_cnt, new_xyz, new_xyz_batch_cnt, \
FILE: pcdet/ops/pointnet2/pointnet2_stack/voxel_query_utils.py
class VoxelQuery (line 10) | class VoxelQuery(Function):
method forward (line 13) | def forward(ctx, max_range: int, radius: float, nsample: int, xyz: tor...
method backward (line 45) | def backward(ctx, a=None):
class VoxelQueryAndGrouping (line 51) | class VoxelQueryAndGrouping(nn.Module):
method __init__ (line 52) | def __init__(self, max_range: int, radius: float, nsample: int):
method forward (line 61) | def forward(self, new_coords: torch.Tensor, xyz: torch.Tensor, xyz_bat...
FILE: pcdet/ops/roiaware_pool3d/roiaware_pool3d_utils.py
function points_in_boxes_cpu (line 9) | def points_in_boxes_cpu(points, boxes):
function points_in_boxes_gpu (line 28) | def points_in_boxes_gpu(points, boxes):
class RoIAwarePool3d (line 44) | class RoIAwarePool3d(nn.Module):
method __init__ (line 45) | def __init__(self, out_size, max_pts_each_voxel=128):
method forward (line 50) | def forward(self, rois, pts, pts_feature, pool_method='max'):
class RoIAwarePool3dFunction (line 55) | class RoIAwarePool3dFunction(Function):
method forward (line 57) | def forward(ctx, rois, pts, pts_feature, out_size, max_pts_each_voxel,...
method backward (line 96) | def backward(ctx, grad_out):
FILE: pcdet/ops/roiaware_pool3d/src/roiaware_pool3d.cpp
function roiaware_pool3d_gpu (line 29) | int roiaware_pool3d_gpu(at::Tensor rois, at::Tensor pts, at::Tensor pts_...
function roiaware_pool3d_gpu_backward (line 68) | int roiaware_pool3d_gpu_backward(at::Tensor pts_idx_of_voxels, at::Tenso...
function points_in_boxes_gpu (line 98) | int points_in_boxes_gpu(at::Tensor boxes_tensor, at::Tensor pts_tensor, ...
function lidar_to_local_coords_cpu (line 121) | inline void lidar_to_local_coords_cpu(float shift_x, float shift_y, floa...
function check_pt_in_box3d_cpu (line 128) | inline int check_pt_in_box3d_cpu(const float *pt, const float *box3d, fl...
function points_in_boxes_cpu (line 143) | int points_in_boxes_cpu(at::Tensor boxes_tensor, at::Tensor pts_tensor, ...
function PYBIND11_MODULE (line 172) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/roipoint_pool3d/roipoint_pool3d_utils.py
class RoIPointPool3d (line 9) | class RoIPointPool3d(nn.Module):
method __init__ (line 10) | def __init__(self, num_sampled_points=512, pool_extra_width=1.0):
method forward (line 15) | def forward(self, points, point_features, boxes3d):
class RoIPointPool3dFunction (line 31) | class RoIPointPool3dFunction(Function):
method forward (line 33) | def forward(ctx, points, point_features, boxes3d, pool_extra_width, nu...
method backward (line 62) | def backward(ctx, grad_out):
FILE: pcdet/ops/roipoint_pool3d/src/roipoint_pool3d.cpp
function roipool3d_gpu (line 23) | int roipool3d_gpu(at::Tensor xyz, at::Tensor boxes3d, at::Tensor pts_fea...
function PYBIND11_MODULE (line 57) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/votr_ops/src/build_attention_indices.cpp
function sparse_local_attention_with_tensor_wrapper (line 29) | int sparse_local_attention_with_tensor_wrapper(int x_max, int y_max, int...
function sparse_local_attention_with_hash_wrapper (line 45) | int sparse_local_attention_with_hash_wrapper(int x_max, int y_max, int z...
function subm_local_attention_with_tensor_wrapper (line 61) | int subm_local_attention_with_tensor_wrapper(int x_max, int y_max, int z...
function subm_local_attention_with_hash_wrapper (line 76) | int subm_local_attention_with_hash_wrapper(int x_max, int y_max, int z_m...
function sparse_strided_attention_with_tensor_wrapper (line 91) | int sparse_strided_attention_with_tensor_wrapper(int x_max, int y_max, i...
function sparse_strided_attention_with_hash_wrapper (line 110) | int sparse_strided_attention_with_hash_wrapper(int x_max, int y_max, int...
function subm_strided_attention_with_tensor_wrapper (line 129) | int subm_strided_attention_with_tensor_wrapper(int x_max, int y_max, int...
function subm_strided_attention_with_hash_wrapper (line 147) | int subm_strided_attention_with_hash_wrapper(int x_max, int y_max, int z...
FILE: pcdet/ops/votr_ops/src/build_mapping.cpp
function build_mapping_with_tensor_wrapper (line 29) | int build_mapping_with_tensor_wrapper(int x_max, int y_max, int z_max, i...
function downsample_with_tensor_wrapper (line 43) | int downsample_with_tensor_wrapper(int x_max, int y_max, int z_max, int ...
function build_mapping_with_hash_wrapper (line 61) | int build_mapping_with_hash_wrapper(int x_max, int y_max, int z_max, int...
function downsample_with_hash_wrapper (line 75) | int downsample_with_hash_wrapper(int x_max, int y_max, int z_max, int x_...
FILE: pcdet/ops/votr_ops/src/group_features.cpp
function group_features_grad_wrapper_stack (line 31) | int group_features_grad_wrapper_stack(int B, int M, int C, int N, int ns...
function group_features_wrapper_stack (line 52) | int group_features_wrapper_stack(int B, int M, int C, int nsample,
FILE: pcdet/ops/votr_ops/src/votr_api.cpp
function PYBIND11_MODULE (line 8) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
FILE: pcdet/ops/votr_ops/votr_utils.py
class BuildTensorTable (line 6) | class BuildTensorTable(Function):
method forward (line 9) | def forward(ctx, batch_size, spatial_shape, voxel_indices, v_bs_cnt):
method backward (line 26) | def backward(ctx, a=None):
class BuildHashTable (line 31) | class BuildHashTable(Function):
method forward (line 34) | def forward(ctx, batch_size, hash_size, spatial_shape, voxel_indices, ...
method backward (line 51) | def backward(ctx, a=None):
class TensorDownSample (line 56) | class TensorDownSample(Function):
method forward (line 58) | def forward(ctx, strides, num_ds_voxels, batch_size, spatial_shape, vo...
method backward (line 88) | def backward(ctx, a=None):
class HashTableDownSample (line 93) | class HashTableDownSample(Function):
method forward (line 95) | def forward(ctx, strides, num_ds_voxels, batch_size, hash_size, spatia...
method backward (line 125) | def backward(ctx, a=None):
class SparseLocalAttentionTensorIndices (line 130) | class SparseLocalAttentionTensorIndices(Function):
method forward (line 133) | def forward(ctx, attend_size, attend_range, strides, dense_map, voxel_...
method backward (line 154) | def backward(ctx, a=None):
class SparseLocalAttentionHashIndices (line 159) | class SparseLocalAttentionHashIndices(Function):
method forward (line 162) | def forward(ctx, spatial_shape, attend_size, attend_range, strides, de...
method backward (line 184) | def backward(ctx, a=None):
class SparseStridedAttentionTensorIndices (line 189) | class SparseStridedAttentionTensorIndices(Function):
method forward (line 192) | def forward(ctx, attend_size, range_spec, strides, dense_map, voxel_in...
method backward (line 215) | def backward(ctx, a=None):
class SparseStridedAttentionHashIndices (line 220) | class SparseStridedAttentionHashIndices(Function):
method forward (line 223) | def forward(ctx, spatial_shape, attend_size, range_spec, strides, dens...
method backward (line 247) | def backward(ctx, a=None):
class SubMLocalAttentionTensorIndices (line 252) | class SubMLocalAttentionTensorIndices(Function):
method forward (line 255) | def forward(ctx, attend_size, attend_range, dense_map, voxel_indices):
method backward (line 275) | def backward(ctx, a=None):
class SubMLocalAttentionHashIndices (line 280) | class SubMLocalAttentionHashIndices(Function):
method forward (line 283) | def forward(ctx, spatial_shape, attend_size, attend_range, dense_map, ...
method backward (line 304) | def backward(ctx, a=None):
class SubMStridedAttentionTensorIndices (line 309) | class SubMStridedAttentionTensorIndices(Function):
method forward (line 312) | def forward(ctx, attend_size, range_spec, dense_map, voxel_indices):
method backward (line 333) | def backward(ctx, a=None):
class SubMStridedAttentionHashIndices (line 338) | class SubMStridedAttentionHashIndices(Function):
method forward (line 341) | def forward(ctx, spatial_shape, attend_size, range_spec, dense_map, vo...
method backward (line 363) | def backward(ctx, a=None):
class GroupingOperation (line 368) | class GroupingOperation(Function):
method forward (line 371) | def forward(ctx, features: torch.Tensor, features_batch_cnt: torch.Ten...
method backward (line 405) | def backward(ctx, grad_out: torch.Tensor):
FILE: pcdet/utils/bbloss.py
function limit (line 4) | def limit( ang):
function ang_weight (line 14) | def ang_weight(pred, gt):
function compute_iou (line 20) | def compute_iou(x,w,y,l):
function bb_loss (line 30) | def bb_loss(pred, target):
class APLoss (line 50) | class APLoss(torch.autograd.Function):
method forward (line 52) | def forward(ctx, logits, targets):
method backward (line 61) | def backward(ctx, out_grad1):
function AP_loss (line 66) | def AP_loss(logits, targets):
FILE: pcdet/utils/box_coder_utils.py
class ResidualCoder (line 5) | class ResidualCoder(object):
method __init__ (line 6) | def __init__(self, code_size=7, encode_angle_by_sincos=False, **kwargs):
method encode_torch (line 13) | def encode_torch(self, boxes, anchors):
method decode_torch (line 46) | def decode_torch(self, box_encodings, anchors):
class ResidualCoderV2 (line 81) | class ResidualCoderV2(object):
method __init__ (line 82) | def __init__(self, code_size=7, encode_angle_by_sincos=False, **kwargs):
method encode_torch (line 89) | def encode_torch(self, boxes, anchors):
method decode_torch (line 124) | def decode_torch(self, box_encodings, anchors):
class ResidualCoderFree (line 160) | class ResidualCoderFree(object):
method __init__ (line 161) | def __init__(self, code_size=8, **kwargs):
method encode_torch (line 165) | def encode_torch(self, boxes, centers):
method decode_torch (line 193) | def decode_torch(self, box_encodings, centers):
class PreviousResidualDecoder (line 218) | class PreviousResidualDecoder(object):
method __init__ (line 219) | def __init__(self, code_size=7, **kwargs):
method decode_torch (line 224) | def decode_torch(box_encodings, anchors):
class PreviousResidualRoIDecoder (line 250) | class PreviousResidualRoIDecoder(object):
method __init__ (line 251) | def __init__(self, code_size=7, **kwargs):
method decode_torch (line 256) | def decode_torch(box_encodings, anchors):
class PointResidualCoder (line 282) | class PointResidualCoder(object):
method __init__ (line 283) | def __init__(self, code_size=8, use_mean_size=True, **kwargs):
method encode_torch (line 291) | def encode_torch(self, gt_boxes, points, gt_classes=None):
method decode_torch (line 327) | def decode_torch(self, box_encodings, points, pred_classes=None):
FILE: pcdet/utils/box_np_ops.py
function corners_nd (line 5) | def corners_nd(dims, origin=0.5):
function rotation_3d_in_axis (line 38) | def rotation_3d_in_axis(points, angles, axis=0):
function center_to_corner_box3d (line 69) | def center_to_corner_box3d(centers,
function box2d_to_corner_jit (line 106) | def box2d_to_corner_jit(boxes):
function corner_to_standup_nd_jit (line 140) | def corner_to_standup_nd_jit(boxes_corner):
function corner_to_surfaces_3d_jit (line 161) | def corner_to_surfaces_3d_jit(corners):
function rotation_points_single_angle (line 190) | def rotation_points_single_angle(points, angle, axis=0):
function corner_to_surfaces_3d (line 222) | def corner_to_surfaces_3d(corners):
function surface_equ_3d (line 244) | def surface_equ_3d(polygon_surfaces):
function _points_in_convex_polygon_3d_jit (line 269) | def _points_in_convex_polygon_3d_jit(points, polygon_surfaces, normal_ve...
function points_in_convex_polygon_3d_jit (line 306) | def points_in_convex_polygon_3d_jit(points,
function points_in_convex_polygon_jit (line 336) | def points_in_convex_polygon_jit(points, polygon, clockwise=True):
FILE: pcdet/utils/box_utils.py
function in_hull (line 10) | def in_hull(p, hull):
function boxes_to_corners_3d (line 27) | def boxes_to_corners_3d(boxes3d):
function mask_boxes_outside_range_numpy (line 55) | def mask_boxes_outside_range_numpy(boxes, limit_range, min_num_corners=1):
function remove_points_in_boxes3d (line 74) | def remove_points_in_boxes3d(points, boxes3d):
function boxes3d_kitti_camera_to_lidar (line 91) | def boxes3d_kitti_camera_to_lidar(boxes3d_camera, calib):
function boxes3d_kitti_fakelidar_to_lidar (line 108) | def boxes3d_kitti_fakelidar_to_lidar(boxes3d_lidar):
function boxes3d_kitti_lidar_to_fakelidar (line 122) | def boxes3d_kitti_lidar_to_fakelidar(boxes3d_lidar):
function enlarge_box3d (line 136) | def enlarge_box3d(boxes3d, extra_width=(0, 0, 0)):
function boxes3d_lidar_to_kitti_camera (line 152) | def boxes3d_lidar_to_kitti_camera(boxes3d_lidar, calib):
function boxes3d_to_corners3d_kitti_camera (line 169) | def boxes3d_to_corners3d_kitti_camera(boxes3d, bottom_center=True):
function boxes3d_kitti_camera_to_imageboxes (line 215) | def boxes3d_kitti_camera_to_imageboxes(boxes3d, calib, image_shape=None):
function boxes_iou_normal (line 238) | def boxes_iou_normal(boxes_a, boxes_b):
function boxes3d_lidar_to_aligned_bev_boxes (line 261) | def boxes3d_lidar_to_aligned_bev_boxes(boxes3d):
function boxes3d_nearest_bev_iou (line 275) | def boxes3d_nearest_bev_iou(boxes_a, boxes_b):
FILE: pcdet/utils/calibration_kitti.py
function get_calib_from_file (line 24) | def get_calib_from_file(filepath):
class Calibration (line 60) | class Calibration(object):
method __init__ (line 61) | def __init__(self, calib_file):
method cart_to_hom (line 79) | def cart_to_hom(self, pts):
method cart_to_hom_cuda (line 87) | def cart_to_hom_cuda(self, pts):
method rect_to_lidar (line 95) | def rect_to_lidar(self, pts_rect):
method lidar_to_rect (line 110) | def lidar_to_rect(self, pts_lidar):
method lidar_to_rect_cuda (line 120) | def lidar_to_rect_cuda(self, pts_lidar):
method rect_to_img (line 132) | def rect_to_img(self, pts_rect):
method rect_to_img_cuda (line 143) | def rect_to_img_cuda(self, pts_rect):
method lidar_to_img (line 155) | def lidar_to_img(self, pts_lidar):
method img_to_rect (line 164) | def img_to_rect(self, u, v, depth_rect):
method corners3d_to_img_boxes (line 176) | def corners3d_to_img_boxes(self, corners3d):
FILE: pcdet/utils/common_utils.py
function check_numpy_to_torch (line 14) | def check_numpy_to_torch(x):
function limit_period (line 20) | def limit_period(val, offset=0.5, period=np.pi):
function drop_info_with_name (line 26) | def drop_info_with_name(info, name):
function rotate_points_along_z (line 34) | def rotate_points_along_z(points, angle):
function mask_points_by_range (line 59) | def mask_points_by_range(points, limit_range):
function get_voxel_centers (line 65) | def get_voxel_centers(voxel_coords, downsample_times, voxel_size, point_...
function create_logger (line 84) | def create_logger(log_file=None, rank=0, log_level=logging.INFO):
function set_random_seed (line 100) | def set_random_seed(seed):
function keep_arrays_by_name (line 108) | def keep_arrays_by_name(gt_names, used_classes):
function init_dist_slurm (line 114) | def init_dist_slurm(tcp_port, local_rank, backend='nccl'):
function init_dist_pytorch (line 141) | def init_dist_pytorch(tcp_port, local_rank, backend='nccl'):
function get_dist_info (line 157) | def get_dist_info():
function merge_results_dist (line 174) | def merge_results_dist(result_part, size, tmpdir):
FILE: pcdet/utils/commu_utils.py
function get_world_size (line 15) | def get_world_size():
function get_rank (line 23) | def get_rank():
function is_main_process (line 31) | def is_main_process():
function synchronize (line 35) | def synchronize():
function all_gather (line 50) | def all_gather(data):
function reduce_dict (line 114) | def reduce_dict(input_dict, average=True):
function average_reduce_value (line 143) | def average_reduce_value(data):
function all_reduce (line 148) | def all_reduce(data, op="sum", average=False):
function concat_all_gather (line 172) | def concat_all_gather(tensor):
FILE: pcdet/utils/loss_utils.py
class SigmoidFocalClassificationLoss (line 9) | class SigmoidFocalClassificationLoss(nn.Module):
method __init__ (line 14) | def __init__(self, gamma: float = 2.0, alpha: float = 0.25):
method sigmoid_cross_entropy_with_logits (line 25) | def sigmoid_cross_entropy_with_logits(input: torch.Tensor, target: tor...
method forward (line 44) | def forward(self, input: torch.Tensor, target: torch.Tensor, weights: ...
class WeightedSmoothL1Loss (line 75) | class WeightedSmoothL1Loss(nn.Module):
method __init__ (line 84) | def __init__(self, beta: float = 1.0 / 9.0, code_weights: list = None):
method smooth_l1_loss (line 100) | def smooth_l1_loss(diff, beta):
method forward (line 109) | def forward(self, input: torch.Tensor, target: torch.Tensor, weights: ...
class WeightedL1Loss (line 139) | class WeightedL1Loss(nn.Module):
method __init__ (line 140) | def __init__(self, code_weights: list = None):
method forward (line 151) | def forward(self, input: torch.Tensor, target: torch.Tensor, weights: ...
class WeightedCrossEntropyLoss (line 181) | class WeightedCrossEntropyLoss(nn.Module):
method __init__ (line 186) | def __init__(self):
method forward (line 189) | def forward(self, input: torch.Tensor, target: torch.Tensor, weights: ...
function get_corner_loss_lidar (line 209) | def get_corner_loss_lidar(pred_bbox3d: torch.Tensor, gt_bbox3d: torch.Te...
function compute_fg_mask (line 235) | def compute_fg_mask(gt_boxes2d, shape, downsample_factor=1, device=torch...
function neg_loss_cornernet (line 264) | def neg_loss_cornernet(pred, gt, mask=None):
class FocalLossCenterNet (line 302) | class FocalLossCenterNet(nn.Module):
method __init__ (line 306) | def __init__(self):
method forward (line 310) | def forward(self, out, target, mask=None):
function _reg_loss (line 314) | def _reg_loss(regr, gt_regr, mask):
function _gather_feat (line 346) | def _gather_feat(feat, ind, mask=None):
function _transpose_and_gather_feat (line 357) | def _transpose_and_gather_feat(feat, ind):
class RegLossCenterNet (line 364) | class RegLossCenterNet(nn.Module):
method __init__ (line 369) | def __init__(self):
method forward (line 372) | def forward(self, output, mask, ind=None, target=None):
FILE: pcdet/utils/object3d_kitti.py
function get_objects_from_label (line 4) | def get_objects_from_label(label_file):
function get_objects_from_tracking_label (line 11) | def get_objects_from_tracking_label(label_file):
function cls_type_to_id (line 16) | def cls_type_to_id(cls_type):
class Object3d (line 23) | class Object3d(object):
method __init__ (line 24) | def __init__(self, line):
method get_kitti_obj_level (line 48) | def get_kitti_obj_level(self):
method get_kitti_tracking_obj_level (line 63) | def get_kitti_tracking_obj_level(self):
method generate_corners3d (line 79) | def generate_corners3d(self):
method to_str (line 97) | def to_str(self):
method to_kitti_format (line 103) | def to_kitti_format(self):
FILE: pcdet/utils/odiou_loss.py
class compute_vertex (line 15) | class compute_vertex(Function):
method forward (line 21) | def forward(ctx, corners_gboxes, corners_qboxes):
method backward (line 139) | def backward(ctx, *grad_outputs):
class sort_vertex (line 278) | class sort_vertex(Function):
method forward (line 280) | def forward(ctx, int_pts, num_of_inter):
method backward (line 323) | def backward(ctx, grad_output):
class area_polygon (line 342) | class area_polygon(Function):
method forward (line 345) | def forward(ctx, int_pts, num_of_inter):
method backward (line 365) | def backward(ctx, *grad_outputs):
class rbbox_to_corners (line 448) | class rbbox_to_corners(nn.Module):
method _init_ (line 450) | def _init_(self, rbbox):
method forward (line 455) | def forward(ctx, rbbox):
class rinter_area_compute (line 486) | class rinter_area_compute(nn.Module):
method _init_ (line 488) | def _init_(self, corners_gboxes, corners_qboxes):
method forward (line 494) | def forward(ctx, corners_gboxes, corners_qboxes):
class find_convex_hull (line 505) | class find_convex_hull(Function):
method forward (line 509) | def forward(ctx, corners):
method backward (line 523) | def backward(ctx, *grad_outputs):
class mbr_convex_hull (line 535) | class mbr_convex_hull(nn.Module):
method _init_ (line 542) | def _init_(self, hull_points_2d):
method forward (line 547) | def forward(ctx, hull_points_2d):
class mbr_area_compute (line 569) | class mbr_area_compute(nn.Module):
method _init_ (line 572) | def _init_(self, corners):
method forward (line 577) | def forward(ctx, corners):
class mbr_diag_convex_hull (line 595) | class mbr_diag_convex_hull(nn.Module):
method _init_ (line 600) | def _init_(self, hull_points_2d):
method forward (line 605) | def forward(ctx, hull_points_2d):
class mbr_diag_compute (line 631) | class mbr_diag_compute(nn.Module):
method _init_ (line 633) | def _init_(self, corners):
method forward (line 638) | def forward(ctx, corners):
class _second_box_decode_operation (line 649) | class _second_box_decode_operation(nn.Module):
method _init_ (line 658) | def _init_(self, box_encodings, anchors, encode_angle_to_vector, smoot...
method forward (line 666) | def forward(ctx, box_encodings, anchors, encode_angle_to_vector, smoot...
class rbbox_corners_aligned (line 709) | class rbbox_corners_aligned(nn.Module):
method _init_ (line 711) | def _init_(self, gboxes):
method forward (line 716) | def forward(ctx, gboxes):
class align_inter_aligned (line 756) | class align_inter_aligned(nn.Module):
method _init_ (line 758) | def _init_(self, gboxes, qboxes):
method forward (line 764) | def forward(ctx, gboxes, qboxes):
class odiou_3D (line 835) | class odiou_3D(nn.Module):
method _init_ (line 836) | def _init_(self, gboxes=None, qboxes=None, aligned=False):
method forward (line 843) | def forward(ctx, gboxes, qboxes, weights, batch_size):
FILE: pcdet/utils/spconv_utils.py
function scatter_point_inds (line 4) | def scatter_point_inds(indices, point_inds, shape):
function generate_voxel2pinds (line 13) | def generate_voxel2pinds(sparse_tensor):
function generate_voxel2pinds2 (line 23) | def generate_voxel2pinds2(batch_size,spatial_shape,indices):
function find_all_spconv_keys (line 41) | def find_all_spconv_keys(model: nn.Module, prefix="") -> Set[str]:
function replace_feature (line 58) | def replace_feature(out, new_features):
FILE: pcdet/utils/transform_utils.py
function project_to_image (line 14) | def project_to_image(project, points):
function normalize_coords (line 38) | def normalize_coords(coords, shape):
function bin_depths (line 56) | def bin_depths(depth_map, mode, depth_min, depth_max, num_bins, target=F...
FILE: setup.py
function get_git_commit_number (line 8) | def get_git_commit_number():
function make_cuda_ext (line 17) | def make_cuda_ext(name, module, sources):
function write_version_to_file (line 25) | def write_version_to_file(version, target_file):
FILE: tools/PENet/CoordConv.py
class AddCoordsNp (line 5) | class AddCoordsNp():
method __init__ (line 7) | def __init__(self, x_dim=64, y_dim=64, with_r=False):
method call (line 12) | def call(self):
FILE: tools/PENet/basic.py
function weights_init (line 42) | def weights_init(m):
function convbnrelu (line 58) | def convbnrelu(in_channels, out_channels, kernel_size=3,stride=1, paddin...
function deconvbnrelu (line 65) | def deconvbnrelu(in_channels, out_channels, kernel_size=5, stride=2, pad...
function convbn (line 72) | def convbn(in_channels, out_channels, kernel_size=3,stride=1, padding=1):
function deconvbn (line 78) | def deconvbn(in_channels, out_channels, kernel_size=4, stride=2, padding...
class BasicBlock (line 84) | class BasicBlock(nn.Module):
method __init__ (line 88) | def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
method forward (line 112) | def forward(self, x):
function conv3x3 (line 130) | def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1, bias=...
function conv1x1 (line 137) | def conv1x1(in_planes, out_planes, stride=1, groups=1, bias=False):
class SparseDownSampleClose (line 141) | class SparseDownSampleClose(nn.Module):
method __init__ (line 142) | def __init__(self, stride):
method forward (line 146) | def forward(self, d, mask):
class CSPNGenerate (line 155) | class CSPNGenerate(nn.Module):
method __init__ (line 156) | def __init__(self, in_channels, kernel_size):
method forward (line 161) | def forward(self, feature):
class CSPN (line 190) | class CSPN(nn.Module):
method __init__ (line 191) | def __init__(self, kernel_size):
method forward (line 195) | def forward(self, guide_weight, hn, h0):
class CSPNGenerateAccelerate (line 220) | class CSPNGenerateAccelerate(nn.Module):
method __init__ (line 221) | def __init__(self, in_channels, kernel_size):
method forward (line 226) | def forward(self, feature):
function kernel_trans (line 242) | def kernel_trans(kernel, weight):
class CSPNAccelerate (line 247) | class CSPNAccelerate(nn.Module):
method __init__ (line 248) | def __init__(self, kernel_size, dilation=1, padding=1, stride=1):
method forward (line 255) | def forward(self, kernel, input, input0): #with standard CSPN, an addi...
class GeometryFeature (line 270) | class GeometryFeature(nn.Module):
method __init__ (line 271) | def __init__(self):
method forward (line 274) | def forward(self, z, vnorm, unorm, h, w, ch, cw, fh, fw):
class BasicBlockGeo (line 279) | class BasicBlockGeo(nn.Module):
method __init__ (line 283) | def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
method forward (line 308) | def forward(self, x, g1=None, g2=None):
FILE: tools/PENet/criteria.py
class MaskedMSELoss (line 6) | class MaskedMSELoss(nn.Module):
method __init__ (line 7) | def __init__(self):
method forward (line 10) | def forward(self, pred, target):
class MaskedL1Loss (line 19) | class MaskedL1Loss(nn.Module):
method __init__ (line 20) | def __init__(self):
method forward (line 23) | def forward(self, pred, target, weight=None):
FILE: tools/PENet/dataloaders/calibration_kitti.py
function get_calib_from_file (line 23) | def get_calib_from_file(filepath):
class Calibration (line 59) | class Calibration(object):
method __init__ (line 60) | def __init__(self, calib_file):
method cart_to_hom (line 78) | def cart_to_hom(self, pts):
method rect_to_lidar (line 86) | def rect_to_lidar(self, pts_rect):
method lidar_to_rect (line 101) | def lidar_to_rect(self, pts_lidar):
method rect_to_img (line 111) | def rect_to_img(self, pts_rect):
method lidar_to_img (line 122) | def lidar_to_img(self, pts_lidar):
method img_to_rect (line 131) | def img_to_rect(self, u, v, depth_rect):
method corners3d_to_img_boxes (line 143) | def corners3d_to_img_boxes(self, corners3d):
FILE: tools/PENet/dataloaders/kitti_loader.py
function load_calib (line 18) | def load_calib():
function get_paths_and_transform (line 40) | def get_paths_and_transform(split, args):
function rgb_read (line 167) | def rgb_read(filename):
function depth_read (line 176) | def depth_read(filename):
function drop_depth_measurements (line 193) | def drop_depth_measurements(depth, prob_keep):
function train_transform (line 198) | def train_transform(rgb, sparse, target, position, args):
function val_transform (line 275) | def val_transform(rgb, sparse, target, position, args):
function no_transform (line 294) | def no_transform(rgb, sparse, target, position, args):
function handle_gray (line 302) | def handle_gray(rgb, args):
function get_rgb_near (line 317) | def get_rgb_near(path, args):
class KittiDepth (line 348) | class KittiDepth(data.Dataset):
method __init__ (line 352) | def __init__(self, split, args):
method __getraw__ (line 362) | def __getraw__(self, index):
method __getitem__ (line 371) | def __getitem__(self, index):
method __len__ (line 392) | def __len__(self):
FILE: tools/PENet/dataloaders/my_loader.py
class VoxelGeneratorWrapper (line 20) | class VoxelGeneratorWrapper():
method __init__ (line 21) | def __init__(self, vsize_xyz, coors_range_xyz, num_point_features, max...
method generate (line 49) | def generate(self, points):
function get_fov_flag (line 76) | def get_fov_flag(pts_rect, img_shape, calib):
function load_depth_input (line 93) | def load_depth_input(calib, image, points):
function depth_read (line 115) | def depth_read(filename):
function depth2points (line 133) | def depth2points(depth, calib):
function depth2pointsrgb (line 143) | def depth2pointsrgb(depth, image, calib):
function to_sphere_coords (line 157) | def to_sphere_coords(points):
function de_noise (line 173) | def de_noise(points, vert_res = 0.05, hor_res = 0.05):
function la_sampling (line 206) | def la_sampling(points, vert_res = 0.002, hor_res = 0.002):
function la_sampling2 (line 238) | def la_sampling2(points, vert_res=0.002, hor_res=0.002):
function voxel_sampling (line 254) | def voxel_sampling(point2, res_x=0.05, res_y=0.05, res_z = 0.05):
function lidar_guied_voxel_sampling (line 277) | def lidar_guied_voxel_sampling(point2, ref_points, res_x=0.2, res_y=0.2,...
function lidar_guied_dis_sampling (line 315) | def lidar_guied_dis_sampling(point2, ref_points, dis = 0.3, res_z = 0.3):
function range_sampling (line 337) | def range_sampling(points2, ref_points, calib, pix_dis_x = 1, pix_dis_y ...
function range_sampling_torch (line 363) | def range_sampling_torch(points2, ref_points, calib, pix_dis_x = 4, pix_...
function depth2pointsrgbp (line 391) | def depth2pointsrgbp(depth, image, calib, lidar):
class MyLoader (line 420) | class MyLoader():
method __init__ (line 421) | def __init__(self, root_path=''):
method include_all_files (line 425) | def include_all_files(self):
method __len__ (line 434) | def __len__(self):
method __getitem__ (line 437) | def __getitem__(self, item):
FILE: tools/PENet/dataloaders/spconv_utils.py
function scatter_point_inds (line 4) | def scatter_point_inds(indices, point_inds, shape):
function generate_voxel2pinds (line 13) | def generate_voxel2pinds(sparse_tensor):
function generate_voxel2pinds2 (line 23) | def generate_voxel2pinds2(batch_size,spatial_shape,indices):
function find_all_spconv_keys (line 41) | def find_all_spconv_keys(model: nn.Module, prefix="") -> Set[str]:
function replace_feature (line 58) | def replace_feature(out, new_features):
FILE: tools/PENet/dataloaders/transforms.py
function _is_numpy_image (line 22) | def _is_numpy_image(img):
function _is_pil_image (line 26) | def _is_pil_image(img):
function _is_tensor_image (line 33) | def _is_tensor_image(img):
function adjust_brightness (line 37) | def adjust_brightness(img, brightness_factor):
function adjust_contrast (line 57) | def adjust_contrast(img, contrast_factor):
function adjust_saturation (line 77) | def adjust_saturation(img, saturation_factor):
function adjust_hue (line 97) | def adjust_hue(img, hue_factor):
function adjust_gamma (line 143) | def adjust_gamma(img, gamma, gain=1):
class Compose (line 177) | class Compose(object):
method __init__ (line 189) | def __init__(self, transforms):
method __call__ (line 192) | def __call__(self, img):
class ToTensor (line 198) | class ToTensor(object):
method __call__ (line 203) | def __call__(self, img):
class NormalizeNumpyArray (line 229) | class NormalizeNumpyArray(object):
method __init__ (line 239) | def __init__(self, mean, std):
method __call__ (line 243) | def __call__(self, img):
class NormalizeTensor (line 260) | class NormalizeTensor(object):
method __init__ (line 270) | def __init__(self, mean, std):
method __call__ (line 274) | def __call__(self, tensor):
class Rotate (line 290) | class Rotate(object):
method __init__ (line 296) | def __init__(self, angle):
method __call__ (line 299) | def __call__(self, img):
class Resize (line 312) | class Resize(object):
method __init__ (line 323) | def __init__(self, size, interpolation='nearest'):
method __call__ (line 328) | def __call__(self, img):
class CenterCrop (line 345) | class CenterCrop(object):
method __init__ (line 353) | def __init__(self, size):
method get_params (line 360) | def get_params(img, output_size):
method __call__ (line 382) | def __call__(self, img):
class BottomCrop (line 409) | class BottomCrop(object):
method __init__ (line 417) | def __init__(self, size):
method get_params (line 424) | def get_params(img, output_size):
method __call__ (line 446) | def __call__(self, img):
class RandomCrop (line 473) | class RandomCrop(object):
method __init__ (line 481) | def __init__(self, size):
method get_params (line 488) | def get_params(img, output_size):
method __call__ (line 508) | def __call__(self, img):
class Crop (line 535) | class Crop(object):
method __init__ (line 543) | def __init__(self, crop):
method get_params (line 547) | def get_params(img, crop):
method __call__ (line 568) | def __call__(self, img):
class Lambda (line 595) | class Lambda(object):
method __init__ (line 601) | def __init__(self, lambd):
method __call__ (line 605) | def __call__(self, img):
class HorizontalFlip (line 609) | class HorizontalFlip(object):
method __init__ (line 616) | def __init__(self, do_flip):
method __call__ (line 619) | def __call__(self, img):
class ColorJitter (line 636) | class ColorJitter(object):
method __init__ (line 649) | def __init__(self, brightness=0, contrast=0, saturation=0, hue=0):
method __call__ (line 660) | def __call__(self, img):
FILE: tools/PENet/helper.py
class logger (line 16) | class logger:
method __init__ (line 17) | def __init__(self, args, prepare=True):
method conditional_print (line 47) | def conditional_print(self, split, i, epoch, lr, n_set, blk_avg_meter,
method conditional_save_info (line 76) | def conditional_save_info(self, split, average_meter, epoch):
method save_single_txt (line 112) | def save_single_txt(self, filename, result, epoch):
method save_best_txt (line 126) | def save_best_txt(self, result, epoch):
method _get_img_comparison_name (line 129) | def _get_img_comparison_name(self, mode, epoch, is_best=False):
method conditional_save_img_comparison (line 138) | def conditional_save_img_comparison(self, mode, i, ele, pred, epoch, p...
method save_img_comparison_as_best (line 151) | def save_img_comparison_as_best(self, mode, epoch):
method get_ranking_error (line 156) | def get_ranking_error(self, result):
method rank_conditional_save_best (line 159) | def rank_conditional_save_best(self, mode, result, epoch):
method conditional_save_pred (line 169) | def conditional_save_pred(self, mode, i, pred, epoch):
method conditional_summarize (line 181) | def conditional_summarize(self, mode, avg, is_best):
function backup_source_code (line 210) | def backup_source_code(backup_directory):
function adjust_learning_rate (line 216) | def adjust_learning_rate(lr_init, optimizer, epoch, args):
function save_checkpoint (line 245) | def save_checkpoint(state, is_best, epoch, output_directory):
function get_folder_name (line 259) | def get_folder_name(args):
function multiscale (line 272) | def multiscale(img):
FILE: tools/PENet/main.py
function iterate (line 178) | def iterate(mode, args, loader, model, optimizer, logger, epoch):
function main (line 296) | def main():
FILE: tools/PENet/metrics.py
function log10 (line 8) | def log10(x):
class Result (line 13) | class Result(object):
method __init__ (line 14) | def __init__(self):
method set_to_worst (line 31) | def set_to_worst(self):
method update (line 47) | def update(self, irmse, imae, mse, rmse, mae, absrel, squared_rel, lg1...
method evaluate (line 65) | def evaluate(self, output, target, photometric=0):
class AverageMeter (line 105) | class AverageMeter(object):
method __init__ (line 106) | def __init__(self):
method reset (line 109) | def reset(self, time_stable):
method update (line 130) | def update(self, result, gpu_time, data_time, n=1):
method average (line 151) | def average(self):
FILE: tools/PENet/model.py
class ENet (line 3) | class ENet(nn.Module):
method __init__ (line 4) | def __init__(self, args):
method forward (line 68) | def forward(self, input):
class PENet_C1 (line 236) | class PENet_C1(nn.Module):
method __init__ (line 237) | def __init__(self, args):
method forward (line 290) | def forward(self, input):
class PENet_C2 (line 382) | class PENet_C2(nn.Module):
method __init__ (line 383) | def __init__(self, args):
method forward (line 447) | def forward(self, input):
class PENet_C4 (line 526) | class PENet_C4(nn.Module):
method __init__ (line 527) | def __init__(self, args):
method forward (line 605) | def forward(self, input):
class PENet_C1_train (line 742) | class PENet_C1_train(nn.Module):
method __init__ (line 743) | def __init__(self, args):
method forward (line 761) | def forward(self, input):
class PENet_C2_train (line 852) | class PENet_C2_train(nn.Module):
method __init__ (line 853) | def __init__(self, args):
method forward (line 882) | def forward(self, input):
FILE: tools/PENet/vis_utils.py
function validcrop (line 16) | def validcrop(img):
function depth_colorize (line 22) | def depth_colorize(depth):
function feature_colorize (line 27) | def feature_colorize(feature):
function mask_vis (line 32) | def mask_vis(mask):
function merge_into_row (line 37) | def merge_into_row(ele, pred, predrgb=None, predg=None, extra=None, extr...
function add_row (line 85) | def add_row(img_merge, row):
function save_image (line 89) | def save_image(img_merge, filename):
function save_image_torch (line 93) | def save_image_torch(rgb, filename):
function save_depth_as_uint16png (line 103) | def save_depth_as_uint16png(img, filename):
function get_fov_flag (line 109) | def get_fov_flag(pts_rect, img_shape, calib):
function save_depth_as_points (line 126) | def save_depth_as_points(depth, idx, root_path):
function save_depth_as_uint16png_upload (line 155) | def save_depth_as_uint16png_upload(img, filename):
function save_depth_as_uint8colored (line 164) | def save_depth_as_uint8colored(img, filename):
function save_mask_as_uint8colored (line 172) | def save_mask_as_uint8colored(img, filename, colored=True, normalized=Tr...
function save_feature_as_uint8colored (line 185) | def save_feature_as_uint8colored(img, filename):
FILE: tools/eval_utils/eval_utils.py
function statistics_info (line 14) | def statistics_info(cfg, ret_dict, metric, disp_dict):
function eval_one_epoch (line 24) | def eval_one_epoch(cfg, model, dataloader, epoch_id, logger, dist_test=F...
FILE: tools/test.py
function parse_config (line 21) | def parse_config():
function eval_single_ckpt (line 57) | def eval_single_ckpt(model, test_loader, args, eval_output_dir, logger, ...
function get_no_evaluated_ckpt (line 69) | def get_no_evaluated_ckpt(ckpt_dir, ckpt_record_file, args):
function repeat_eval_ckpt (line 87) | def repeat_eval_ckpt(model, test_loader, args, eval_output_dir, logger, ...
function main (line 126) | def main():
FILE: tools/train.py
function parse_config (line 21) | def parse_config():
function main (line 56) | def main():
FILE: tools/train_utils/optimization/__init__.py
function build_optimizer (line 11) | def build_optimizer(model, optim_cfg):
function build_scheduler (line 39) | def build_scheduler(optimizer, total_iters_each_epoch, total_epochs, las...
FILE: tools/train_utils/optimization/fastai_optim.py
function split_bn_bias (line 13) | def split_bn_bias(layer_groups):
function get_master (line 27) | def get_master(layer_groups, flat_master: bool = False):
function model_g2master_g (line 49) | def model_g2master_g(model_params, master_params, flat_master: bool = Fa...
function master2model (line 65) | def master2model(model_params, master_params, flat_master: bool = False)...
function listify (line 77) | def listify(p=None, q=None):
function trainable_params (line 91) | def trainable_params(m: nn.Module):
function is_tuple (line 97) | def is_tuple(x) -> bool: return isinstance(x, tuple)
class OptimWrapper (line 101) | class OptimWrapper():
method __init__ (line 104) | def __init__(self, opt, wd, true_wd: bool = False, bn_wd: bool = True):
method create (line 112) | def create(cls, opt_func, lr,
method new (line 121) | def new(self, layer_groups):
method __repr__ (line 128) | def __repr__(self) -> str:
method step (line 132) | def step(self) -> None:
method zero_grad (line 151) | def zero_grad(self) -> None:
method __getattr__ (line 156) | def __getattr__(self, k: str):
method clear (line 159) | def clear(self):
method lr (line 167) | def lr(self) -> float:
method lr (line 171) | def lr(self, val: float) -> None:
method mom (line 175) | def mom(self) -> float:
method mom (line 179) | def mom(self, val: float) -> None:
method beta (line 187) | def beta(self) -> float:
method beta (line 191) | def beta(self, val: float) -> None:
method wd (line 201) | def wd(self) -> float:
method wd (line 205) | def wd(self, val: float) -> None:
method read_defaults (line 211) | def read_defaults(self) -> None:
method set_val (line 220) | def set_val(self, key: str, val, bn_groups: bool = True):
method read_val (line 228) | def read_val(self, key: str):
class FastAIMixedOptim (line 235) | class FastAIMixedOptim(OptimWrapper):
method create (line 237) | def create(cls, opt_func, lr,
method step (line 254) | def step(self):
FILE: tools/train_utils/optimization/learning_schedules_fastai.py
class LRSchedulerStep (line 12) | class LRSchedulerStep(object):
method __init__ (line 13) | def __init__(self, fai_optimizer: OptimWrapper, total_step, lr_phases,
method step (line 44) | def step(self, step):
function annealing_cos (line 53) | def annealing_cos(start, end, pct):
class OneCycle (line 60) | class OneCycle(LRSchedulerStep):
method __init__ (line 61) | def __init__(self, fai_optimizer, total_step, lr_max, moms, div_factor,
class CosineWarmup (line 79) | class CosineWarmup():
method __init__ (line 80) | def __init__(self, optimizer, total_step, up_steps, lr_max, moms, div_...
method step (line 87) | def step(self, step):
class CosineWarmupLR (line 92) | class CosineWarmupLR(lr_sched._LRScheduler):
method __init__ (line 93) | def __init__(self, optimizer, T_max, eta_min=0, last_epoch=-1):
method get_lr (line 98) | def get_lr(self):
class FakeOptim (line 104) | class FakeOptim:
method __init__ (line 105) | def __init__(self):
FILE: tools/train_utils/train_utils.py
function train_one_epoch (line 13) | def train_one_epoch(model, optimizer, train_loader, model_func, lr_sched...
function train_model (line 73) | def train_model(model, optimizer, train_loader, model_func, lr_scheduler...
function model_state_to_cpu (line 121) | def model_state_to_cpu(model_state):
function checkpoint_state (line 128) | def checkpoint_state(model=None, optimizer=None, epoch=None, it=None):
function save_checkpoint (line 147) | def save_checkpoint(state, filename='checkpoint'):
FILE: tools/visual_utils/visualize_utils.py
function check_numpy_to_torch (line 13) | def check_numpy_to_torch(x):
function rotate_points_along_z (line 19) | def rotate_points_along_z(points, angle):
function boxes_to_corners_3d (line 44) | def boxes_to_corners_3d(boxes3d):
function visualize_pts (line 72) | def visualize_pts(pts, fig=None, bgcolor=(0, 0, 0), fgcolor=(1.0, 1.0, 1...
function draw_sphere_pts (line 94) | def draw_sphere_pts(pts, color=(0, 1, 0), fig=None, bgcolor=(0, 0, 0), s...
function draw_grid (line 126) | def draw_grid(x1, y1, x2, y2, fig, tube_radius=None, color=(0.5, 0.5, 0....
function draw_multi_grid_range (line 134) | def draw_multi_grid_range(fig, grid_size=20, bv_range=(-60, -60, 60, 60)):
function draw_scenes (line 142) | def draw_scenes(points, gt_boxes=None, ref_boxes=None, ref_scores=None, ...
function draw_corners3d (line 173) | def draw_corners3d(corners3d, fig, color=(1, 1, 1), line_width=2, cls=No...
Condensed preview — 182 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,587K chars).
[
{
"path": "LICENSE",
"chars": 11357,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "README.md",
"chars": 7035,
"preview": "\n# Transformation-Equivariant 3D Object Detection for Autonomous Driving\nThis is a improved version of [TED](https://arx"
},
{
"path": "data/kitti/ImageSets/test.txt",
"chars": 52625,
"preview": "000000\n000001\n000002\n000003\n000004\n000005\n000006\n000007\n000008\n000009\n000010\n000011\n000012\n000013\n000014\n000015\n000016\n0"
},
{
"path": "data/kitti/ImageSets/train.txt",
"chars": 25983,
"preview": "000000\n000003\n000007\n000009\n000010\n000011\n000012\n000013\n000014\n000016\n000017\n000018\n000022\n000026\n000029\n000030\n000032\n0"
},
{
"path": "data/kitti/ImageSets/val.txt",
"chars": 26382,
"preview": "000001\n000002\n000004\n000005\n000006\n000008\n000015\n000019\n000020\n000021\n000023\n000024\n000025\n000027\n000028\n000031\n000033\n0"
},
{
"path": "pcdet/__init__.py",
"chars": 535,
"preview": "import subprocess\nfrom pathlib import Path\n\nfrom .version import __version__\n\n__all__ = [\n '__version__'\n]\n\n\ndef get_"
},
{
"path": "pcdet/config.py",
"chars": 2750,
"preview": "from pathlib import Path\n\nimport yaml\nfrom easydict import EasyDict\n\n\ndef log_config_to_file(cfg, pre='cfg', logger=None"
},
{
"path": "pcdet/datasets/__init__.py",
"chars": 2520,
"preview": "import torch\nfrom torch.utils.data import DataLoader\nfrom torch.utils.data import DistributedSampler as _DistributedSamp"
},
{
"path": "pcdet/datasets/augmentor/X_transform.py",
"chars": 7044,
"preview": "from functools import partial\n\nimport numpy as np\n\nfrom ...utils import common_utils\nfrom . import augmentor_utils\nimpor"
},
{
"path": "pcdet/datasets/augmentor/augmentor_utils.py",
"chars": 34150,
"preview": "import numpy as np\nimport math\nimport copy\nfrom ...utils import common_utils,box_np_ops\nfrom ...utils import box_utils\ni"
},
{
"path": "pcdet/datasets/augmentor/data_augmentor.py",
"chars": 6403,
"preview": "from functools import partial\n\nimport numpy as np\n\nfrom ...utils import common_utils\nfrom . import augmentor_utils, data"
},
{
"path": "pcdet/datasets/augmentor/database_sampler.py",
"chars": 25878,
"preview": "import pathlib\nimport pickle\n\nimport numpy as np\n\nfrom ...ops.iou3d_nms import iou3d_nms_utils\nfrom ...utils import box_"
},
{
"path": "pcdet/datasets/dataset.py",
"chars": 9511,
"preview": "from collections import defaultdict\nfrom pathlib import Path\nimport torch\nimport numpy as np\nimport torch.utils.data as "
},
{
"path": "pcdet/datasets/kitti/kitti_dataset.py",
"chars": 19319,
"preview": "import copy\nimport pickle\n\nimport numpy as np\nfrom skimage import io\n\nfrom pcdet.ops.roiaware_pool3d import roiaware_poo"
},
{
"path": "pcdet/datasets/kitti/kitti_dataset_mm.py",
"chars": 20471,
"preview": "import copy\nimport pickle\n\nimport numpy as np\nfrom skimage import io\n\nfrom pcdet.ops.roiaware_pool3d import roiaware_poo"
},
{
"path": "pcdet/datasets/kitti/kitti_object_eval_python/LICENSE",
"chars": 1057,
"preview": "MIT License\n\nCopyright (c) 2018 \n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this s"
},
{
"path": "pcdet/datasets/kitti/kitti_object_eval_python/README.md",
"chars": 1725,
"preview": "# kitti-object-eval-python\n**Note**: This is borrowed from [traveller59/kitti-object-eval-python](https://github.com/tra"
},
{
"path": "pcdet/datasets/kitti/kitti_object_eval_python/eval.py",
"chars": 33791,
"preview": "import io as sysio\n\nimport numba\nimport numpy as np\n\nfrom .rotate_iou import rotate_iou_gpu_eval\nimport pickle\n@numba.ji"
},
{
"path": "pcdet/datasets/kitti/kitti_object_eval_python/evaluate.py",
"chars": 1694,
"preview": "import time\n\nimport fire\n\nimport pcdet.datasets.kitti.kitti_object_eval_python.kitti_common as kitti\nfrom pcdet.datasets"
},
{
"path": "pcdet/datasets/kitti/kitti_object_eval_python/kitti_common.py",
"chars": 16536,
"preview": "import concurrent.futures as futures\nimport os\nimport pathlib\nimport re\nfrom collections import OrderedDict\n\nimport nump"
},
{
"path": "pcdet/datasets/kitti/kitti_object_eval_python/rotate_iou.py",
"chars": 11552,
"preview": "#####################\n# Based on https://github.com/hongzhenwang/RRPN-revise\n# Licensed under The MIT License\n# Author: "
},
{
"path": "pcdet/datasets/processor/data_processor.py",
"chars": 10100,
"preview": "from functools import partial\n\nimport numpy as np\nfrom skimage import transform\n\nfrom ...utils import box_utils, common_"
},
{
"path": "pcdet/datasets/processor/point_feature_encoder.py",
"chars": 2474,
"preview": "import numpy as np\n\n\nclass PointFeatureEncoder(object):\n def __init__(self, config, point_cloud_range=None, rot_num=1"
},
{
"path": "pcdet/models/__init__.py",
"chars": 1094,
"preview": "from collections import namedtuple\n\nimport numpy as np\nimport torch\n\nfrom .detectors import build_detector\n\n\ndef build_n"
},
{
"path": "pcdet/models/backbones_2d/__init__.py",
"chars": 102,
"preview": "from .base_bev_backbone import BaseBEVBackbone\n\n__all__ = {\n 'BaseBEVBackbone': BaseBEVBackbone,\n}\n"
},
{
"path": "pcdet/models/backbones_2d/base_bev_backbone.py",
"chars": 4371,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\n\n\nclass BaseBEVBackbone(nn.Module):\n def __init__(self, model_c"
},
{
"path": "pcdet/models/backbones_2d/map_to_bev/__init__.py",
"chars": 176,
"preview": "from .height_compression import BEVPool\nfrom .pointpillar_scatter import PointPillarScatter\n\n__all__ = {\n 'BEVPool': "
},
{
"path": "pcdet/models/backbones_2d/map_to_bev/height_compression.py",
"chars": 5823,
"preview": "import torch.nn as nn\nimport numpy as np\nfrom pcdet.datasets.augmentor.X_transform import X_TRANS\nimport torch\n\ndef bili"
},
{
"path": "pcdet/models/backbones_2d/map_to_bev/pointpillar_scatter.py",
"chars": 1545,
"preview": "import torch\nimport torch.nn as nn\n\n\nclass PointPillarScatter(nn.Module):\n def __init__(self, model_cfg, grid_size, *"
},
{
"path": "pcdet/models/backbones_3d/__init__.py",
"chars": 315,
"preview": "from .pointnet2_backbone import PointNet2Backbone, PointNet2MSG\nfrom .spconv_backbone import TeMMVoxelBackBone8x,TeVoxel"
},
{
"path": "pcdet/models/backbones_3d/pfe/__init__.py",
"chars": 118,
"preview": "from .voxel_set_abstraction import VoxelSetAbstraction\n\n__all__ = {\n 'VoxelSetAbstraction': VoxelSetAbstraction,\n}\n"
},
{
"path": "pcdet/models/backbones_3d/pfe/bev_features_interpolation.py",
"chars": 5990,
"preview": "import torch\nimport torch.nn as nn\n\nfrom ....ops.pointnet2.pointnet2_stack import pointnet2_modules as pointnet2_stack_m"
},
{
"path": "pcdet/models/backbones_3d/pfe/voxel_set_abstraction.py",
"chars": 16412,
"preview": "import math\nimport numpy as np\nimport torch\nimport torch.nn as nn\n\nfrom ....ops.pointnet2.pointnet2_stack import pointne"
},
{
"path": "pcdet/models/backbones_3d/pointnet2_backbone.py",
"chars": 8527,
"preview": "import torch\nimport torch.nn as nn\n\nfrom ...ops.pointnet2.pointnet2_batch import pointnet2_modules\nfrom ...ops.pointnet2"
},
{
"path": "pcdet/models/backbones_3d/spconv_backbone.py",
"chars": 31999,
"preview": "from functools import partial\nfrom ...utils.spconv_utils import replace_feature, spconv\nimport torch.nn as nn\nimport num"
},
{
"path": "pcdet/models/backbones_3d/spconv_unet.py",
"chars": 8445,
"preview": "from functools import partial\n\nimport spconv\nimport torch\nimport torch.nn as nn\n\nfrom ...utils import common_utils\nfrom "
},
{
"path": "pcdet/models/backbones_3d/vfe/__init__.py",
"chars": 200,
"preview": "from .mean_vfe import MeanVFE\nfrom .pillar_vfe import PillarVFE\nfrom .vfe_template import VFETemplate\n\n__all__ = {\n '"
},
{
"path": "pcdet/models/backbones_3d/vfe/mean_vfe.py",
"chars": 2194,
"preview": "import torch\n\nfrom .vfe_template import VFETemplate\n\n\nclass MeanVFE(VFETemplate):\n def __init__(self, model_cfg, num_"
},
{
"path": "pcdet/models/backbones_3d/vfe/pillar_vfe.py",
"chars": 5089,
"preview": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom .vfe_template import VFETemplate\n\n\nclass PFNLay"
},
{
"path": "pcdet/models/backbones_3d/vfe/vfe_template.py",
"chars": 470,
"preview": "import torch.nn as nn\n\n\nclass VFETemplate(nn.Module):\n def __init__(self, model_cfg, **kwargs):\n super().__ini"
},
{
"path": "pcdet/models/dense_heads/__init__.py",
"chars": 674,
"preview": "from .anchor_head_multi import AnchorHeadMulti\nfrom .anchor_head_single import AnchorHeadSingle\nfrom .center_head import"
},
{
"path": "pcdet/models/dense_heads/anchor_head_multi.py",
"chars": 17031,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\n\nfrom ..backbones_2d import BaseBEVBackbone\nfrom .anchor_head_temp"
},
{
"path": "pcdet/models/dense_heads/anchor_head_single.py",
"chars": 5531,
"preview": "import numpy as np\nimport torch.nn as nn\n\nfrom .anchor_head_template import AnchorHeadTemplate\nimport torch\nimport cv2\ni"
},
{
"path": "pcdet/models/dense_heads/anchor_head_template.py",
"chars": 16384,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\n\nfrom ...utils import box_coder_utils, common_utils, loss_utils\nfr"
},
{
"path": "pcdet/models/dense_heads/center_head.py",
"chars": 15981,
"preview": "import copy\nimport numpy as np\nimport torch\nimport torch.nn as nn\nfrom torch.nn.init import kaiming_normal_\nfrom ..model"
},
{
"path": "pcdet/models/dense_heads/point_head_box.py",
"chars": 5152,
"preview": "import torch\n\nfrom ...utils import box_coder_utils, box_utils\nfrom .point_head_template import PointHeadTemplate\n\n\nclass"
},
{
"path": "pcdet/models/dense_heads/point_head_simple.py",
"chars": 3568,
"preview": "import torch\n\nfrom ...utils import box_utils\nfrom .point_head_template import PointHeadTemplate\n\n\nclass PointHeadSimple("
},
{
"path": "pcdet/models/dense_heads/point_head_template.py",
"chars": 9739,
"preview": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom ...ops.roiaware_pool3d import roiaware_pool3d_u"
},
{
"path": "pcdet/models/dense_heads/point_intra_part_head.py",
"chars": 5568,
"preview": "import torch\n\nfrom ...utils import box_coder_utils, box_utils\nfrom .point_head_template import PointHeadTemplate\n\n\nclass"
},
{
"path": "pcdet/models/dense_heads/target_assigner/anchor_generator.py",
"chars": 3990,
"preview": "import torch\n\n\nclass AnchorGenerator(object):\n def __init__(self, anchor_range, anchor_generator_config):\n sup"
},
{
"path": "pcdet/models/dense_heads/target_assigner/atss_target_assigner.py",
"chars": 6050,
"preview": "import torch\n\nfrom ....ops.iou3d_nms import iou3d_nms_utils\nfrom ....utils import common_utils\n\n\nclass ATSSTargetAssigne"
},
{
"path": "pcdet/models/dense_heads/target_assigner/axis_aligned_target_assigner.py",
"chars": 10969,
"preview": "import numpy as np\nimport torch\n\nfrom ....ops.iou3d_nms import iou3d_nms_utils\n\nfrom ....utils import box_utils\nimport t"
},
{
"path": "pcdet/models/detectors/__init__.py",
"chars": 355,
"preview": "from .detector3d_template import Detector3DTemplate\n\nfrom .voxel_rcnn import VoxelRCNN\n__all__ = {\n 'Detector3DTempla"
},
{
"path": "pcdet/models/detectors/detector3d_template.py",
"chars": 19468,
"preview": "import os\n\nimport torch\nimport torch.nn as nn\nfrom ...utils.spconv_utils import find_all_spconv_keys\nfrom ...ops.iou3d_n"
},
{
"path": "pcdet/models/detectors/voxel_rcnn.py",
"chars": 1022,
"preview": "from .detector3d_template import Detector3DTemplate\nimport time\nclass VoxelRCNN(Detector3DTemplate):\n def __init__(se"
},
{
"path": "pcdet/models/model_utils/centernet_utils.py",
"chars": 7235,
"preview": "# This file is modified from https://github.com/tianweiy/CenterPoint\n\nimport torch\nimport torch.nn.functional as F\nimpor"
},
{
"path": "pcdet/models/model_utils/ctrans.py",
"chars": 19359,
"preview": "import torch.nn as nn\nimport pdb\nimport torch\nimport numpy as np\nfrom numpy import *\nimport torch.nn.functional as F\nfro"
},
{
"path": "pcdet/models/model_utils/model_nms_utils.py",
"chars": 5703,
"preview": "import torch\nimport numpy as np\nfrom ...ops.iou3d_nms import iou3d_nms_utils\n\ndef limit(ang):\n ang = ang % (2 * np.pi"
},
{
"path": "pcdet/models/roi_heads/__init__.py",
"chars": 195,
"preview": "from .roi_head_template import RoIHeadTemplate\n\nfrom .ted_head import TEDMHead, TEDSHead\n\n__all__ = {\n 'RoIHeadTempla"
},
{
"path": "pcdet/models/roi_heads/roi_head_template.py",
"chars": 13914,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom ...utils import box_coder_uti"
},
{
"path": "pcdet/models/roi_heads/target_assigner/proposal_target_layer.py",
"chars": 29545,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\n\nfrom ....ops.iou3d_nms import iou3d_nms_utils\n\nclass ProposalTarg"
},
{
"path": "pcdet/models/roi_heads/target_assigner/proposal_target_layer3.py",
"chars": 26574,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\n\nfrom ....ops.iou3d_nms import iou3d_nms_utils\n\nclass ProposalTarg"
},
{
"path": "pcdet/models/roi_heads/ted_head.py",
"chars": 51240,
"preview": "import torch\nimport torch.nn as nn\nfrom .roi_head_template import RoIHeadTemplate\nfrom ...utils import common_utils, spc"
},
{
"path": "pcdet/ops/dcn/__init__.py",
"chars": 333,
"preview": "from .deform_conv import (DeformConv, DeformConvPack, ModulatedDeformConv,\n ModulatedDeformConv"
},
{
"path": "pcdet/ops/dcn/deform_conv.py",
"chars": 17555,
"preview": "import math\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.autograd import Function\nfrom"
},
{
"path": "pcdet/ops/dcn/setup.py",
"chars": 617,
"preview": "from setuptools import setup\nfrom torch.utils.cpp_extension import BuildExtension, CUDAExtension\n\nsetup(\n name='maske"
},
{
"path": "pcdet/ops/dcn/src/deform_conv_cuda.cpp",
"chars": 29533,
"preview": "// modify from\n// https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/def"
},
{
"path": "pcdet/ops/dcn/src/deform_conv_cuda_kernel.cu",
"chars": 42526,
"preview": "/*!\n ******************* BEGIN Caffe Copyright Notice and Disclaimer ****************\n *\n * COPYRIGHT\n *\n * All contribu"
},
{
"path": "pcdet/ops/dcn/src/deform_pool_cuda.cpp",
"chars": 4021,
"preview": "// modify from\n// https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/mod"
},
{
"path": "pcdet/ops/dcn/src/deform_pool_cuda_kernel.cu",
"chars": 16114,
"preview": "/*!\n * Copyright (c) 2017 Microsoft\n * Licensed under The MIT License [see LICENSE for details]\n * \\file deformable_psro"
},
{
"path": "pcdet/ops/iou3d_nms/iou3d_nms_utils.py",
"chars": 4137,
"preview": "\"\"\"\n3D IoU Calculation and Rotated NMS\nWritten by Shaoshuai Shi\nAll Rights Reserved 2019-2020.\n\"\"\"\nimport torch\n\nfrom .."
},
{
"path": "pcdet/ops/iou3d_nms/src/iou3d_cpu.cpp",
"chars": 8283,
"preview": "/*\n3D Rotated IoU Calculation (CPU)\nWritten by Shaoshuai Shi\nAll Rights Reserved 2020.\n*/\n\n#include <stdio.h>\n#include <"
},
{
"path": "pcdet/ops/iou3d_nms/src/iou3d_cpu.h",
"chars": 256,
"preview": "#ifndef IOU3D_CPU_H\n#define IOU3D_CPU_H\n\n#include <torch/serialize/tensor.h>\n#include <vector>\n#include <cuda.h>\n#includ"
},
{
"path": "pcdet/ops/iou3d_nms/src/iou3d_nms.cpp",
"chars": 6456,
"preview": "/*\n3D IoU Calculation and Rotated NMS(modified from 2D NMS written by others)\nWritten by Shaoshuai Shi\nAll Rights Reserv"
},
{
"path": "pcdet/ops/iou3d_nms/src/iou3d_nms.h",
"chars": 481,
"preview": "#ifndef IOU3D_NMS_H\n#define IOU3D_NMS_H\n\n#include <torch/serialize/tensor.h>\n#include <vector>\n#include <cuda.h>\n#includ"
},
{
"path": "pcdet/ops/iou3d_nms/src/iou3d_nms_api.cpp",
"chars": 553,
"preview": "#include <torch/serialize/tensor.h>\n#include <torch/extension.h>\n#include <vector>\n#include <cuda.h>\n#include <cuda_runt"
},
{
"path": "pcdet/ops/iou3d_nms/src/iou3d_nms_kernel.cu",
"chars": 16203,
"preview": "/*\n3D IoU Calculation and Rotated NMS(modified from 2D NMS written by others)\nWritten by Shaoshuai Shi\nAll Rights Reserv"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/pointnet2_modules.py",
"chars": 6631,
"preview": "from typing import List\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom . import pointnet2_uti"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/pointnet2_utils.py",
"chars": 9693,
"preview": "from typing import Tuple\n\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Function, Variable\n\nfrom . impor"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/ball_query.cpp",
"chars": 1255,
"preview": "/*\nbatch version of ball query, modified from the original implementation of official PointNet++ codes.\nWritten by Shaos"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/ball_query_gpu.cu",
"chars": 2178,
"preview": "/*\nbatch version of ball query, modified from the original implementation of official PointNet++ codes.\nWritten by Shaos"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/ball_query_gpu.h",
"chars": 455,
"preview": "#ifndef _BALL_QUERY_GPU_H\n#define _BALL_QUERY_GPU_H\n\n#include <torch/serialize/tensor.h>\n#include <vector>\n#include <cud"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/cuda_utils.h",
"chars": 353,
"preview": "#ifndef _CUDA_UTILS_H\n#define _CUDA_UTILS_H\n\n#include <cmath>\n\n#define TOTAL_THREADS 1024\n#define THREADS_PER_BLOCK 256\n"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/group_points.cpp",
"chars": 1198,
"preview": "/*\nbatch version of point grouping, modified from the original implementation of official PointNet++ codes.\nWritten by S"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/group_points_gpu.cu",
"chars": 3406,
"preview": "/*\nbatch version of point grouping, modified from the original implementation of official PointNet++ codes.\nWritten by S"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/group_points_gpu.h",
"chars": 794,
"preview": "#ifndef _GROUP_POINTS_GPU_H\n#define _GROUP_POINTS_GPU_H\n\n#include <torch/serialize/tensor.h>\n#include <cuda.h>\n#include "
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/interpolate.cpp",
"chars": 1992,
"preview": "/*\nbatch version of point interpolation, modified from the original implementation of official PointNet++ codes.\nWritten"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/interpolate_gpu.cu",
"chars": 5405,
"preview": "/*\nbatch version of point interpolation, modified from the original implementation of official PointNet++ codes.\nWritten"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/interpolate_gpu.h",
"chars": 1111,
"preview": "#ifndef _INTERPOLATE_GPU_H\n#define _INTERPOLATE_GPU_H\n\n#include <torch/serialize/tensor.h>\n#include<vector>\n#include <cu"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/pointnet2_api.cpp",
"chars": 1148,
"preview": "#include <torch/serialize/tensor.h>\n#include <torch/extension.h>\n\n#include \"ball_query_gpu.h\"\n#include \"group_points_gpu"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/sampling.cpp",
"chars": 1523,
"preview": "/*\nbatch version of point sampling and gathering, modified from the original implementation of official PointNet++ codes"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/sampling_gpu.cu",
"chars": 7895,
"preview": "/*\nbatch version of point sampling and gathering, modified from the original implementation of official PointNet++ codes"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_batch/src/sampling_gpu.h",
"chars": 982,
"preview": "#ifndef _SAMPLING_GPU_H\n#define _SAMPLING_GPU_H\n\n#include <torch/serialize/tensor.h>\n#include <ATen/cuda/CUDAContext.h>\n"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/pointnet2_modules.py",
"chars": 21385,
"preview": "from typing import List\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom . import pointnet2_uti"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/pointnet2_utils.py",
"chars": 17903,
"preview": "import torch\nimport torch.nn as nn\nfrom torch.autograd import Function, Variable\n\nfrom . import pointnet2_stack_cuda as "
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/ball_query.cpp",
"chars": 1562,
"preview": "/*\nStacked-batch-data version of ball query, modified from the original implementation of official PointNet++ codes.\nWri"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/ball_query_deform.cpp",
"chars": 1518,
"preview": "#include <torch/serialize/tensor.h>\n#include <vector>\n#include <THC/THC.h>\n#include <cuda.h>\n#include <cuda_runtime_api."
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/ball_query_deform_gpu.cu",
"chars": 3138,
"preview": "#include <math.h>\n#include <stdio.h>\n#include <stdlib.h>\n\n#include \"ball_query_deform_gpu.h\"\n#include \"cuda_utils.h\"\n\n\n_"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/ball_query_deform_gpu.h",
"chars": 643,
"preview": "#ifndef _STACK_BALL_QUERY_DEFORM_GPU_H\n#define _STACK_BALL_QUERY_DEFORM_GPU_H\n\n#include <torch/serialize/tensor.h>\n#incl"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/ball_query_gpu.cu",
"chars": 3066,
"preview": "/*\nStacked-batch-data version of ball query, modified from the original implementation of official PointNet++ codes.\nWri"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/ball_query_gpu.h",
"chars": 769,
"preview": "/*\nStacked-batch-data version of ball query, modified from the original implementation of official PointNet++ codes.\nWri"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/cuda_utils.h",
"chars": 162,
"preview": "#ifndef _STACK_CUDA_UTILS_H\n#define _STACK_CUDA_UTILS_H\n\n#include <cmath>\n\n#define THREADS_PER_BLOCK 256\n#define DIVUP(m"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/group_points.cpp",
"chars": 2485,
"preview": "/*\nStacked-batch-data version of point grouping, modified from the original implementation of official PointNet++ codes."
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/group_points_gpu.cu",
"chars": 5691,
"preview": "/*\nStacked-batch-data version of point grouping, modified from the original implementation of official PointNet++ codes."
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/group_points_gpu.h",
"chars": 1222,
"preview": "/*\nStacked-batch-data version of point grouping, modified from the original implementation of official PointNet++ codes."
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/interpolate.cpp",
"chars": 3916,
"preview": "/*\nStacked-batch-data version of point interpolation, modified from the original implementation of official PointNet++ c"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/interpolate_gpu.cu",
"chars": 6466,
"preview": "/*\nStacked-batch-data version of point interpolation, modified from the original implementation of official PointNet++ c"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/interpolate_gpu.h",
"chars": 1192,
"preview": "#ifndef _INTERPOLATE_GPU_H\n#define _INTERPOLATE_GPU_H\n\n#include <torch/serialize/tensor.h>\n#include<vector>\n#include <cu"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/pointnet2_api.cpp",
"chars": 1915,
"preview": "#include <torch/serialize/tensor.h>\n#include <torch/extension.h>\n\n#include \"ball_query_gpu.h\"\n#include \"group_points_gpu"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/sampling.cpp",
"chars": 1905,
"preview": "#include <torch/serialize/tensor.h>\n#include <ATen/cuda/CUDAContext.h>\n#include <vector>\n#include <THC/THC.h>\n\n#include "
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/sampling_gpu.cu",
"chars": 10229,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n\n#include \"cuda_utils.h\"\n#include \"sampling_gpu.h\"\n#define TOTAL_THREADS 1024\n\n\ni"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/sampling_gpu.h",
"chars": 769,
"preview": "#ifndef _SAMPLING_GPU_H\n#define _SAMPLING_GPU_H\n\n#include <torch/serialize/tensor.h>\n#include <ATen/cuda/CUDAContext.h>\n"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/vector_pool.cpp",
"chars": 9221,
"preview": "/*\nVector-pool aggregation based local feature aggregation for point cloud.\nPV-RCNN++: Point-Voxel Feature Set Abstracti"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/vector_pool_gpu.cu",
"chars": 20132,
"preview": "/*\nVector-pool aggregation based local feature aggregation for point cloud.\nPV-RCNN++: Point-Voxel Feature Set Abstracti"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/vector_pool_gpu.h",
"chars": 3324,
"preview": "/*\nVector-pool aggregation based local feature aggregation for point cloud.\nPV-RCNN++: Point-Voxel Feature Set Abstracti"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/voxel_query.cpp",
"chars": 1451,
"preview": "#include <torch/serialize/tensor.h>\n#include <vector>\n#include <THC/THC.h>\n#include <cuda.h>\n#include <cuda_runtime_api."
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/voxel_query_gpu.cu",
"chars": 4036,
"preview": "#include <math.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <curand_kernel.h>\n\n#include \"voxel_query_gpu.h\"\n#inclu"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/src/voxel_query_gpu.h",
"chars": 700,
"preview": "#ifndef _STACK_VOXEL_QUERY_GPU_H\n#define _STACK_VOXEL_QUERY_GPU_H\n\n#include <torch/serialize/tensor.h>\n#include <vector>"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/voxel_pool_modules.py",
"chars": 5672,
"preview": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom . import voxel_query_utils\nfrom typing import Li"
},
{
"path": "pcdet/ops/pointnet2/pointnet2_stack/voxel_query_utils.py",
"chars": 4148,
"preview": "import torch\nfrom torch.autograd import Variable\nfrom torch.autograd import Function\nimport torch.nn as nn\nfrom typing i"
},
{
"path": "pcdet/ops/roiaware_pool3d/roiaware_pool3d_utils.py",
"chars": 4075,
"preview": "import torch\nimport torch.nn as nn\nfrom torch.autograd import Function\n\nfrom ...utils import common_utils\nfrom . import "
},
{
"path": "pcdet/ops/roiaware_pool3d/src/roiaware_pool3d.cpp",
"chars": 7272,
"preview": "/*\nRoI-aware point cloud feature pooling\nReference paper: https://arxiv.org/abs/1907.03670\nWritten by Shaoshuai Shi\nAll"
},
{
"path": "pcdet/ops/roiaware_pool3d/src/roiaware_pool3d_kernel.cu",
"chars": 14858,
"preview": "/*\nRoI-aware point cloud feature pooling\nWritten by Shaoshuai Shi\nAll Rights Reserved 2019-2020.\n*/\n\n\n#include <math.h>\n"
},
{
"path": "pcdet/ops/roipoint_pool3d/roipoint_pool3d_utils.py",
"chars": 2226,
"preview": "import torch\nimport torch.nn as nn\nfrom torch.autograd import Function\n\nfrom ...utils import box_utils\nfrom . import roi"
},
{
"path": "pcdet/ops/roipoint_pool3d/src/roipoint_pool3d.cpp",
"chars": 2047,
"preview": "#include <torch/serialize/tensor.h>\n#include <torch/extension.h>\n\n#define CHECK_CUDA(x) do { \\\n if (!x.type().is_cuda()"
},
{
"path": "pcdet/ops/roipoint_pool3d/src/roipoint_pool3d_kernel.cu",
"chars": 6522,
"preview": "/*\nPoint cloud feature pooling\nWritten by Shaoshuai Shi\nAll Rights Reserved 2018.\n*/\n\n#include <math.h>\n#include <stdio."
},
{
"path": "pcdet/ops/votr_ops/src/build_attention_indices.cpp",
"chars": 8363,
"preview": "/*\nFind indices for each attention pattern\nWritten by Jiageng Mao\n*/\n\n#include <torch/serialize/tensor.h>\n#include <vect"
},
{
"path": "pcdet/ops/votr_ops/src/build_attention_indices_gpu.cu",
"chars": 32081,
"preview": "/*\nFind indices for each attention pattern\nWritten by Jiageng Mao\n*/\n\n#include <math.h>\n#include <stdio.h>\n#include <std"
},
{
"path": "pcdet/ops/votr_ops/src/build_attention_indices_gpu.h",
"chars": 5859,
"preview": "/*\nFind indices for each attention pattern\nWritten by Jiageng Mao\n*/\n\n#ifndef BUILD_ATTENTION_INDICES_GPU_H\n#define BUIL"
},
{
"path": "pcdet/ops/votr_ops/src/build_mapping.cpp",
"chars": 3821,
"preview": "/*\nBuilding xyz -> idx sparse tensor mapping\nWritten by Jiageng Mao\n*/\n\n#include <torch/serialize/tensor.h>\n#include <ve"
},
{
"path": "pcdet/ops/votr_ops/src/build_mapping_gpu.cu",
"chars": 11079,
"preview": "/*\nBuilding xyz -> idx sparse tensor mapping\nWritten by Jiageng Mao\n*/\n\n#include <math.h>\n#include <stdio.h>\n#include <s"
},
{
"path": "pcdet/ops/votr_ops/src/build_mapping_gpu.h",
"chars": 2675,
"preview": "/*\nBuilding xyz -> idx sparse tensor mapping\nWritten by Jiageng Mao\n*/\n\n#ifndef BUILD_MAPPING_GPU_H\n#define BUILD_MAPPIN"
},
{
"path": "pcdet/ops/votr_ops/src/group_features.cpp",
"chars": 2495,
"preview": "/*\nStacked-batch-data version of point grouping, modified from the original implementation of official PointNet++ codes."
},
{
"path": "pcdet/ops/votr_ops/src/group_features_gpu.cu",
"chars": 5758,
"preview": "/*\nModified from group points, don't care indices with -1(<0)\nWritten by Jiageng Mao\nAll Rights Reserved 2019-2020.\n*/\n\n"
},
{
"path": "pcdet/ops/votr_ops/src/group_features_gpu.h",
"chars": 1173,
"preview": "/*\nModified from group points, don't care indices with -1(<0)\nWritten by Jiageng Mao\nAll Rights Reserved 2019-2020.\n*/\n\n"
},
{
"path": "pcdet/ops/votr_ops/src/votr_api.cpp",
"chars": 2045,
"preview": "#include <torch/serialize/tensor.h>\n#include <torch/extension.h>\n\n#include \"build_mapping_gpu.h\"\n#include \"build_attenti"
},
{
"path": "pcdet/ops/votr_ops/src/votr_cuda_utils.h",
"chars": 200,
"preview": "#ifndef VOTR_CUDA_UTILS_H\n#define VOTR_CUDA_UTILS_H\n\n#include <cmath>\n\n#define THREADS_PER_BLOCK 256\n#define DIVUP(m,n) "
},
{
"path": "pcdet/ops/votr_ops/votr_utils.py",
"chars": 17196,
"preview": "import torch\nfrom torch.autograd import Function, Variable\n\nfrom . import votr_ops_cuda as votr\n\nclass BuildTensorTable("
},
{
"path": "pcdet/utils/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "pcdet/utils/bbloss.py",
"chars": 3287,
"preview": "import torch\nimport numpy as np\n\ndef limit( ang):\n ang = ang % (2 * np.pi)\n\n ang[ang > np.pi] = ang[ang > np.pi] -"
},
{
"path": "pcdet/utils/box_coder_utils.py",
"chars": 11656,
"preview": "import numpy as np\nimport torch\n\n\nclass ResidualCoder(object):\n def __init__(self, code_size=7, encode_angle_by_sinco"
},
{
"path": "pcdet/utils/box_np_ops.py",
"chars": 14036,
"preview": "import numba\nimport numpy as np\n\n\ndef corners_nd(dims, origin=0.5):\n \"\"\"Generate relative box corners based on length"
},
{
"path": "pcdet/utils/box_utils.py",
"chars": 10214,
"preview": "import numpy as np\nimport scipy\nimport torch\nfrom scipy.spatial import Delaunay\n\nfrom ..ops.roiaware_pool3d import roiaw"
},
{
"path": "pcdet/utils/calibration_kitti.py",
"chars": 6955,
"preview": "import numpy as np\nimport re\nimport torch\n'''\ndef get_calib_from_file(calib_file):\n with open(calib_file) as f:\n "
},
{
"path": "pcdet/utils/common_utils.py",
"chars": 5750,
"preview": "import logging\nimport os\nimport pickle\nimport random\nimport shutil\nimport subprocess\n\nimport numpy as np\nimport torch\nim"
},
{
"path": "pcdet/utils/commu_utils.py",
"chars": 5253,
"preview": "\"\"\"\nThis file contains primitives for multi-gpu communication.\nThis is useful when doing distributed training.\n\ndeeply b"
},
{
"path": "pcdet/utils/loss_utils.py",
"chars": 12608,
"preview": "import numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom . import box_utils\n\n\nclass S"
},
{
"path": "pcdet/utils/object3d_kitti.py",
"chars": 4510,
"preview": "import numpy as np\n\n\ndef get_objects_from_label(label_file):\n with open(label_file, 'r') as f:\n lines = f.read"
},
{
"path": "pcdet/utils/odiou_loss.py",
"chars": 44587,
"preview": "### Compute the IOU of two rotated 2D rectangle\n\nimport math\nimport numpy as np\nimport sys\nimport random\nimport torch\nfr"
},
{
"path": "pcdet/utils/spconv_utils.py",
"chars": 2051,
"preview": "import torch\n\n\ndef scatter_point_inds(indices, point_inds, shape):\n ret = -1 * torch.ones(*shape, dtype=point_inds.dt"
},
{
"path": "pcdet/utils/transform_utils.py",
"chars": 3092,
"preview": "import math\nimport torch\n\ntry:\n from kornia.geometry.conversions import (\n convert_points_to_homogeneous,\n "
},
{
"path": "pcdet/version.py",
"chars": 30,
"preview": "__version__ = \"0.3.0+0000000\"\n"
},
{
"path": "requirements.txt",
"chars": 70,
"preview": "numpy\ntorch>=1.1\nnumba\ntensorboardX\neasydict\npyyaml\nscikit-image\ntqdm\n"
},
{
"path": "setup.py",
"chars": 4406,
"preview": "import os\nimport subprocess\n\nfrom setuptools import find_packages, setup\nfrom torch.utils.cpp_extension import BuildExte"
},
{
"path": "tools/PENet/CoordConv.py",
"chars": 1534,
"preview": "from __future__ import print_function\n\nimport numpy as np\n\nclass AddCoordsNp():\n\t\"\"\"Add coords to a tensor\"\"\"\n\tdef __ini"
},
{
"path": "tools/PENet/LICENSE",
"chars": 1069,
"preview": "MIT License\n\nCopyright (c) 2018 Fangchang Ma\n\nPermission is hereby granted, free of charge, to any person obtaining a co"
},
{
"path": "tools/PENet/basic.py",
"chars": 12204,
"preview": "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport math\n\ngks = 5\npad = [i for i in range(gks*gks)"
},
{
"path": "tools/PENet/criteria.py",
"chars": 827,
"preview": "import torch\nimport torch.nn as nn\n\nloss_names = ['l1', 'l2']\n\nclass MaskedMSELoss(nn.Module):\n def __init__(self):\n "
},
{
"path": "tools/PENet/dataloaders/calib_cam_to_cam.txt",
"chars": 3001,
"preview": "calib_time: 09-Jan-2012 13:57:47\ncorner_dist: 9.950000e-02\nS_00: 1.392000e+03 5.120000e+02\nK_00: 9.842439e+02 0.000000e+"
},
{
"path": "tools/PENet/dataloaders/calibration_kitti.py",
"chars": 5763,
"preview": "import numpy as np\nimport re\n'''\ndef get_calib_from_file(calib_file):\n with open(calib_file) as f:\n lines = f."
},
{
"path": "tools/PENet/dataloaders/kitti_loader.py",
"chars": 13804,
"preview": "import os\nimport os.path\nimport glob\nimport fnmatch # pattern matching\nimport numpy as np\nfrom numpy import linalg as L"
},
{
"path": "tools/PENet/dataloaders/my_loader.py",
"chars": 13579,
"preview": "from dataloaders import calibration_kitti\nimport numpy as np\nfrom skimage import io\nimport cv2\nfrom PIL import Image\nimp"
},
{
"path": "tools/PENet/dataloaders/spconv_utils.py",
"chars": 2051,
"preview": "import torch\n\n\ndef scatter_point_inds(indices, point_inds, shape):\n ret = -1 * torch.ones(*shape, dtype=point_inds.dt"
},
{
"path": "tools/PENet/dataloaders/transforms.py",
"chars": 21000,
"preview": "from __future__ import division\nimport torch\nimport math\nimport random\n\nfrom PIL import Image, ImageOps, ImageEnhance\ntr"
},
{
"path": "tools/PENet/helper.py",
"chars": 11368,
"preview": "import math\nimport os, time\nimport shutil\nimport torch\nimport csv\nimport vis_utils\nfrom metrics import Result\n\nfieldname"
},
{
"path": "tools/PENet/main.py",
"chars": 17984,
"preview": "import argparse\nimport os\n#os.environ[\"CUDA_VISIBLE_DEVICES\"] = '1'\nimport torch\nimport torch.nn.parallel\nimport torch.o"
},
{
"path": "tools/PENet/metrics.py",
"chars": 7034,
"preview": "import torch\nimport math\nimport numpy as np\n\nlg_e_10 = math.log(10)\n\n\ndef log10(x):\n \"\"\"Convert a new tensor with the"
},
{
"path": "tools/PENet/model.py",
"chars": 43842,
"preview": "from basic import *\n\nclass ENet(nn.Module):\n def __init__(self, args):\n super(ENet, self).__init__()\n s"
},
{
"path": "tools/PENet/vis_utils.py",
"chars": 6320,
"preview": "import os\n\nimport matplotlib.pyplot as plt\nfrom PIL import Image\nimport numpy as np\nimport cv2\nfrom dataloaders import c"
},
{
"path": "tools/cfgs/dataset_configs/kitti_dataset.yaml",
"chars": 1996,
"preview": "DATA_PATH: '../data/kitti'\n\nDATASET: 'KittiDataset'\n\nMM_PATH: 'velodyne_depth'\n\nPOINT_CLOUD_RANGE: [0, -40, -3, 70.4, 40"
},
{
"path": "tools/cfgs/models/kitti/TED-M.yaml",
"chars": 8755,
"preview": "CLASS_NAMES: ['Car']\n\nDATA_CONFIG:\n _BASE_CONFIG_: cfgs/dataset_configs/kitti_dataset.yaml\n DATASET: 'KittiDataset"
},
{
"path": "tools/cfgs/models/kitti/TED-S.yaml",
"chars": 7918,
"preview": "CLASS_NAMES: ['Car']\n\nDATA_CONFIG:\n _BASE_CONFIG_: cfgs/dataset_configs/kitti_dataset.yaml\n DATASET: 'KittiDataset"
},
{
"path": "tools/dist_test.sh",
"chars": 156,
"preview": "#!/usr/bin/env bash\n\nCUDA_VISIBLE_DEVICES=1,2,3,4 nohup python3 -m torch.distributed.launch --nproc_per_node=4 test.py -"
},
{
"path": "tools/dist_train.sh",
"chars": 158,
"preview": "#!/usr/bin/env bash\n\nCUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 nohup python3 -m torch.distributed.launch --nproc_per_node=8 t"
},
{
"path": "tools/eval_utils/eval_utils.py",
"chars": 4924,
"preview": "import pickle\nimport time\n\nimport numpy as np\nimport torch\nimport tqdm\nimport os\n\nfrom pcdet.models import load_data_to_"
},
{
"path": "tools/test.py",
"chars": 7888,
"preview": "import os\nimport argparse\nimport datetime\nimport glob\nimport re\nimport time\nfrom pathlib import Path\n\nimport numpy as np"
},
{
"path": "tools/train.py",
"chars": 8759,
"preview": "import os\nimport argparse\nimport datetime\nimport glob\nfrom pathlib import Path\nfrom test import repeat_eval_ckpt\nimport "
},
{
"path": "tools/train_utils/optimization/__init__.py",
"chars": 2716,
"preview": "from functools import partial\n\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.optim.lr_scheduler as lr_s"
},
{
"path": "tools/train_utils/optimization/fastai_optim.py",
"chars": 10477,
"preview": "# This file is modified from https://github.com/traveller59/second.pytorch\n\nfrom collections import Iterable\n\nimport tor"
},
{
"path": "tools/train_utils/optimization/learning_schedules_fastai.py",
"chars": 4591,
"preview": "# This file is modified from https://github.com/traveller59/second.pytorch\n\nimport math\nfrom functools import partial\n\ni"
},
{
"path": "tools/train_utils/train_utils.py",
"chars": 5945,
"preview": "import glob\nimport os\n\nimport torch\nimport tqdm\nfrom torch.nn.utils import clip_grad_norm_\nimport numpy as np\nfrom pcdet"
},
{
"path": "tools/visual_utils/visualize_utils.py",
"chars": 8540,
"preview": "import mayavi.mlab as mlab\nimport numpy as np\nimport torch\n\nbox_colormap = [\n [1, 1, 1],\n [0, 1, 0],\n [0, 1, 1]"
}
]
About this extraction
This page contains the full source code of the hailanyi/TED GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 182 files (1.4 MB), approximately 426.9k tokens, and a symbol index with 1247 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.