devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

OpenPCDet训练Waymo数据集_openpcdet waymo open

作者：不正经 | 2024-03-27 15:44:12

赞

踩

openpcdet waymo open

一、前言

官方给出的方法：

https://github.com/open-mmlab/OpenPCDet/blob/master/docs/GETTING_STARTED.mdicon-default.png?t=N7T8https://github.com/open-mmlab/OpenPCDet/blob/master/docs/GETTING_STARTED.md

本文采用两个方法生成数据集：官方方法和自定义路径方法，后者是为了防止内存不够用。

二、使用官方方法生成并训练数据集

1、整理数据

（1）下载官方数据集

 Waymo Open Dataset, 包括训练数据：training_0000.tar~training_0031.tar以及验证集数据： validation_0000.tar~validation_0007.tar（如果仅仅只是想用一部分进行训练，可只下载几个tar压缩包就可以，数量不会影响）。

（2）将上述所有xxxx.tar文件解压到data/waymo/raw_data目录(可以得到798训练tfrecord和202验证tfrecord)。

（3）所有的数据集名称需要更改为：segment-xxxxxxxx.tfrecord。

（4）整理目录

在OpenPCDet-master/data文件目录需要整理如下：

├── data

│   ├── waymo

│   │   │── ImageSets

│   │   │── raw_data

│   │   │   │── segment-xxxxxxxx.tfrecord

|   |   |   |── ...

注意：这里只能在OpenPCDet根目录下生成数据集，否则需要更改源码，后面的方法有讲到

简单整理如下图所示：

raw_data目录：

注意：这里raw_data一定要将train和val的数据集放到一起，不能只放其中一个，否则之后eval会报错，无法评估结果。 

2、安装工具包

pip install waymo-open-dataset-tf-2.11.0==1.5.0

我安装的是waymo-open-dataset-tf-2.11.0，大家根据需求来安装版本，我的2-1-0不能用。

3、使用命令进行转换

从tfrecord中提取点云数据并生成数据信息：

python -m pcdet.datasets.waymo.waymo_dataset --func create_waymo_infos --cfg_file tools/cfgs/dataset_configs/waymo_dataset.yaml

最终生成的数据集目录如下所示：

# Download Waymo and organize it into the following form:

├── data

│   ├── waymo

│   │   │── ImageSets

│   │   │── raw_data

│   │   │   │── segment-xxxxxxxx.tfrecord

|   |   |   |── ...

|   |   |── waymo_processed_data

│   │   │   │── segment-xxxxxxxx/

|   |   |   |── ...

│   │   │── pcdet_gt_database_train_sampled_xx/

│   │   │── pcdet_waymo_dbinfos_train_sampled_xx.pkl

如图：

4、训练

这里以PV_RCNN++为例，使用命令：

python train.py --cfg_file /home/xd/xyy/OpenPCDet-master/tools/cfgs/waymo_models/pv_rcnn_plusplus.yaml

三、在自定义目录下生成并训练数据集

自定义目录下生成并训练数据集主要是为了节约内存，不同版本pcdet及相关代码共用一个数据集。

1、整理数据

（1）请下载官方数据集：

Waymo Open Dataset, 包括训练数据：training_0000.tar~training_0031.tar以及验证集数据： validation_0000.tar~validation_0007.tar.

（2）将上述所有xxxx.tar文件解压到data/waymo/raw_data目录(可以得到798训练tfrecord和202验证tfrecord)：

（3）所有的数据集名称需要更改为：segment-xxxxxxxx.tfrecord，如果是下载的是individual

（4）整理目录

前三步是与上面一样的。

下面整理目录可以将数据放在xxx/data文件目录下：

├xxx

├── data

│   ├── waymo

│   │   │── ImageSets

│   │   │── raw_data

│   │   │   │── segment-xxxxxxxx.tfrecord

|   |   |   |── ...

以下面图举例，我是放在了自定义文件夹hpc/data/waymo_pcdet_mini中，

raw_data文件夹如下所示：

2、安装工具包

pip install waymo-open-dataset-tf-2.11.0==1.5.0

3、更改waymo源码

注：源码只能在OpenPCDet-master目录下生成数据，这里需要新加一些可以传入的参数进行转换。

（1）更改生成数据源码——waymo_dataset.py

位置：

/OpenPCDet-master/pcdet/datasets/waymo/waymo_dataset.py

更改部分主要是：parser和ROOT_DIR

其中，更改部分如下图所示：

更改后的源码如下：

  1. # OpenPCDet PyTorch Dataloader and Evaluation Tools for Waymo Open Dataset
  2. # Reference https://github.com/open-mmlab/OpenPCDet
  3. # Written by Shaoshuai Shi, Chaoxu Guo
  4. # All Rights Reserved.
  5.  
  6. import os
  7. import pickle
  8. import copy
  9. import numpy as np
  10. import torch
  11. import multiprocessing
  12. import SharedArray
  13. import torch.distributed as dist
  14. from tqdm import tqdm
  15. from pathlib import Path
  16. from functools import partial
  17.  
  18. from ...ops.roiaware_pool3d import roiaware_pool3d_utils
  19. from ...utils import box_utils, common_utils
  20. from ..dataset import DatasetTemplate
  21.  
  22.  
  23. class WaymoDataset(DatasetTemplate):
  24.     def __init__(self, dataset_cfg, class_names, training=True, root_path=None, logger=None):
  25.         super().__init__(
  26.             dataset_cfg=dataset_cfg, class_names=class_names, training=training, root_path=root_path, logger=logger
  27.         )
  28.         self.data_path = self.root_path / self.dataset_cfg.PROCESSED_DATA_TAG
  29.         self.split = self.dataset_cfg.DATA_SPLIT[self.mode]
  30.         split_dir = self.root_path / 'ImageSets' / (self.split + '.txt')
  31.         self.sample_sequence_list = [x.strip() for x in open(split_dir).readlines()]
  32.  
  33.         self.infos = []
  34.         self.seq_name_to_infos = self.include_waymo_data(self.mode)
  35.  
  36.         self.use_shared_memory = self.dataset_cfg.get('USE_SHARED_MEMORY', False) and self.training
  37.         if self.use_shared_memory:
  38.             self.shared_memory_file_limit = self.dataset_cfg.get('SHARED_MEMORY_FILE_LIMIT', 0x7FFFFFFF)
  39.             self.load_data_to_shared_memory()
  40.  
  41.         if self.dataset_cfg.get('USE_PREDBOX', False):
  42.             self.pred_boxes_dict = self.load_pred_boxes_to_dict(
  43.                 pred_boxes_path=self.dataset_cfg.ROI_BOXES_PATH[self.mode]
  44.             )
  45.         else:
  46.             self.pred_boxes_dict = {}
  47.  
  48.     def set_split(self, split):
  49.         super().__init__(
  50.             dataset_cfg=self.dataset_cfg, class_names=self.class_names, training=self.training,
  51.             root_path=self.root_path, logger=self.logger
  52.         )
  53.         self.split = split
  54.         split_dir = self.root_path / 'ImageSets' / (self.split + '.txt')
  55.         self.sample_sequence_list = [x.strip() for x in open(split_dir).readlines()]
  56.         self.infos = []
  57.         self.seq_name_to_infos = self.include_waymo_data(self.mode)
  58.  
  59.     def include_waymo_data(self, mode):
  60.         self.logger.info('Loading Waymo dataset')
  61.         waymo_infos = []
  62.         seq_name_to_infos = {}
  63.  
  64.         num_skipped_infos = 0
  65.         for k in range(len(self.sample_sequence_list)):
  66.             sequence_name = os.path.splitext(self.sample_sequence_list[k])[0]
  67.             info_path = self.data_path / sequence_name / ('%s.pkl' % sequence_name)
  68.             info_path = self.check_sequence_name_with_all_version(info_path)
  69.             if not info_path.exists():
  70.                 num_skipped_infos += 1
  71.                 continue
  72.             with open(info_path, 'rb') as f:
  73.                 infos = pickle.load(f)
  74.                 waymo_infos.extend(infos)
  75.  
  76.             seq_name_to_infos[infos[0]['point_cloud']['lidar_sequence']] = infos
  77.  
  78.         self.infos.extend(waymo_infos[:])
  79.         self.logger.info('Total skipped info %s' % num_skipped_infos)
  80.         self.logger.info('Total samples for Waymo dataset: %d' % (len(waymo_infos)))
  81.  
  82.         if self.dataset_cfg.SAMPLED_INTERVAL[mode] > 1:
  83.             sampled_waymo_infos = []
  84.             for k in range(0, len(self.infos), self.dataset_cfg.SAMPLED_INTERVAL[mode]):
  85.                 sampled_waymo_infos.append(self.infos[k])
  86.             self.infos = sampled_waymo_infos
  87.             self.logger.info('Total sampled samples for Waymo dataset: %d' % len(self.infos))
  88.             
  89.         use_sequence_data = self.dataset_cfg.get('SEQUENCE_CONFIG', None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED
  90.         if not use_sequence_data:
  91.             seq_name_to_infos = None 
  92.         return seq_name_to_infos
  93.  
  94.     def load_pred_boxes_to_dict(self, pred_boxes_path):
  95.         self.logger.info(f'Loading and reorganizing pred_boxes to dict from path: {pred_boxes_path}')
  96.         with open(pred_boxes_path, 'rb') as f:
  97.             pred_dicts = pickle.load(f)
  98.  
  99.         pred_boxes_dict = {}
  100.         for index, box_dict in enumerate(pred_dicts):
  101.             seq_name = box_dict['frame_id'][:-4].replace('training_', '').replace('validation_', '')
  102.             sample_idx = int(box_dict['frame_id'][-3:])
  103.  
  104.             if seq_name not in pred_boxes_dict:
  105.                 pred_boxes_dict[seq_name] = {}
  106.  
  107.             pred_labels = np.array([self.class_names.index(box_dict['name'][k]) + 1 for k in range(box_dict['name'].shape[0])])
  108.             pred_boxes = np.concatenate((box_dict['boxes_lidar'], box_dict['score'][:, np.newaxis], pred_labels[:, np.newaxis]), axis=-1)
  109.             pred_boxes_dict[seq_name][sample_idx] = pred_boxes
  110.  
  111.         self.logger.info(f'Predicted boxes has been loaded, total sequences: {len(pred_boxes_dict)}')
  112.         return pred_boxes_dict
  113.  
  114.     def load_data_to_shared_memory(self):
  115.         self.logger.info(f'Loading training data to shared memory (file limit={self.shared_memory_file_limit})')
  116.  
  117.         cur_rank, num_gpus = common_utils.get_dist_info()
  118.         all_infos = self.infos[:self.shared_memory_file_limit] \
  119.             if self.shared_memory_file_limit < len(self.infos) else self.infos
  120.         cur_infos = all_infos[cur_rank::num_gpus]
  121.         for info in cur_infos:
  122.             pc_info = info['point_cloud']
  123.             sequence_name = pc_info['lidar_sequence']
  124.             sample_idx = pc_info['sample_idx']
  125.  
  126.             sa_key = f'{sequence_name}___{sample_idx}'
  127.             if os.path.exists(f"/dev/shm/{sa_key}"):
  128.                 continue
  129.  
  130.             points = self.get_lidar(sequence_name, sample_idx)
  131.             common_utils.sa_create(f"shm://{sa_key}", points)
  132.  
  133.         dist.barrier()
  134.         self.logger.info('Training data has been saved to shared memory')
  135.  
  136.     def clean_shared_memory(self):
  137.         self.logger.info(f'Clean training data from shared memory (file limit={self.shared_memory_file_limit})')
  138.  
  139.         cur_rank, num_gpus = common_utils.get_dist_info()
  140.         all_infos = self.infos[:self.shared_memory_file_limit] \
  141.             if self.shared_memory_file_limit < len(self.infos) else self.infos
  142.         cur_infos = all_infos[cur_rank::num_gpus]
  143.         for info in cur_infos:
  144.             pc_info = info['point_cloud']
  145.             sequence_name = pc_info['lidar_sequence']
  146.             sample_idx = pc_info['sample_idx']
  147.  
  148.             sa_key = f'{sequence_name}___{sample_idx}'
  149.             if not os.path.exists(f"/dev/shm/{sa_key}"):
  150.                 continue
  151.  
  152.             SharedArray.delete(f"shm://{sa_key}")
  153.  
  154.         if num_gpus > 1:
  155.             dist.barrier()
  156.         self.logger.info('Training data has been deleted from shared memory')
  157.  
  158.     @staticmethod
  159.     def check_sequence_name_with_all_version(sequence_file):
  160.         if not sequence_file.exists():
  161.             found_sequence_file = sequence_file
  162.             for pre_text in ['training', 'validation', 'testing']:
  163.                 if not sequence_file.exists():
  164.                     temp_sequence_file = Path(str(sequence_file).replace('segment', pre_text + '_segment'))
  165.                     if temp_sequence_file.exists():
  166.                         found_sequence_file = temp_sequence_file
  167.                         break
  168.             if not found_sequence_file.exists():
  169.                 found_sequence_file = Path(str(sequence_file).replace('_with_camera_labels', ''))
  170.             if found_sequence_file.exists():
  171.                 sequence_file = found_sequence_file
  172.         return sequence_file
  173.  
  174.     def get_infos(self, raw_data_path, save_path, num_workers=multiprocessing.cpu_count(), has_label=True, sampled_interval=1, update_info_only=False):
  175.         from . import waymo_utils
  176.         print('---------------The waymo sample interval is %d, total sequecnes is %d-----------------'
  177.               % (sampled_interval, len(self.sample_sequence_list)))
  178.  
  179.         process_single_sequence = partial(
  180.             waymo_utils.process_single_sequence,
  181.             save_path=save_path, sampled_interval=sampled_interval, has_label=has_label, update_info_only=update_info_only
  182.         )
  183.         sample_sequence_file_list = [
  184.             self.check_sequence_name_with_all_version(raw_data_path / sequence_file)
  185.             for sequence_file in self.sample_sequence_list
  186.         ]
  187.  
  188.         # process_single_sequence(sample_sequence_file_list[0])
  189.         with multiprocessing.Pool(num_workers) as p:
  190.             sequence_infos = list(tqdm(p.imap(process_single_sequence, sample_sequence_file_list),
  191.                                        total=len(sample_sequence_file_list)))
  192.  
  193.         all_sequences_infos = [item for infos in sequence_infos for item in infos]
  194.         return all_sequences_infos
  195.  
  196.     def get_lidar(self, sequence_name, sample_idx):
  197.         lidar_file = self.data_path / sequence_name / ('%04d.npy' % sample_idx)
  198.         point_features = np.load(lidar_file)  # (N, 7): [x, y, z, intensity, elongation, NLZ_flag]
  199.  
  200.         points_all, NLZ_flag = point_features[:, 0:5], point_features[:, 5]
  201.         if not self.dataset_cfg.get('DISABLE_NLZ_FLAG_ON_POINTS', False):
  202.             points_all = points_all[NLZ_flag == -1]
  203.         points_all[:, 3] = np.tanh(points_all[:, 3])
  204.         return points_all
  205.  
  206.     @staticmethod
  207.     def transform_prebox_to_current(pred_boxes3d, pose_pre, pose_cur):
  208.         """
  210.         Args:
  211.             pred_boxes3d (N, 9 or 11): [x, y, z, dx, dy, dz, raw, <vx, vy,> score, label]
  212.             pose_pre (4, 4):
  213.             pose_cur (4, 4):
  214.         Returns:
  216.         """
  217.         assert pred_boxes3d.shape[-1] in [9, 11]
  218.         pred_boxes3d = pred_boxes3d.copy()
  219.         expand_bboxes = np.concatenate([pred_boxes3d[:, :3], np.ones((pred_boxes3d.shape[0], 1))], axis=-1)
  220.  
  221.         bboxes_global = np.dot(expand_bboxes, pose_pre.T)[:, :3]
  222.         expand_bboxes_global = np.concatenate([bboxes_global[:, :3],np.ones((bboxes_global.shape[0], 1))], axis=-1)
  223.         bboxes_pre2cur = np.dot(expand_bboxes_global, np.linalg.inv(pose_cur.T))[:, :3]
  224.         pred_boxes3d[:, 0:3] = bboxes_pre2cur
  225.  
  226.         if pred_boxes3d.shape[-1] == 11:
  227.             expand_vels = np.concatenate([pred_boxes3d[:, 7:9], np.zeros((pred_boxes3d.shape[0], 1))], axis=-1)
  228.             vels_global = np.dot(expand_vels, pose_pre[:3, :3].T)
  229.             vels_pre2cur = np.dot(vels_global, np.linalg.inv(pose_cur[:3, :3].T))[:,:2]
  230.             pred_boxes3d[:, 7:9] = vels_pre2cur
  231.  
  232.         pred_boxes3d[:, 6]  = pred_boxes3d[..., 6] + np.arctan2(pose_pre[..., 1, 0], pose_pre[..., 0, 0])
  233.         pred_boxes3d[:, 6]  = pred_boxes3d[..., 6] - np.arctan2(pose_cur[..., 1, 0], pose_cur[..., 0, 0])
  234.         return pred_boxes3d
  235.  
  236.     @staticmethod
  237.     def reorder_rois_for_refining(pred_bboxes):
  238.         num_max_rois = max([len(bbox) for bbox in pred_bboxes])
  239.         num_max_rois = max(1, num_max_rois)  # at least one faked rois to avoid error
  240.         ordered_bboxes = np.zeros([len(pred_bboxes), num_max_rois, pred_bboxes[0].shape[-1]], dtype=np.float32)
  241.  
  242.         for bs_idx in range(ordered_bboxes.shape[0]):
  243.             ordered_bboxes[bs_idx, :len(pred_bboxes[bs_idx])] = pred_bboxes[bs_idx]
  244.         return ordered_bboxes
  245.  
  246.     def get_sequence_data(self, info, points, sequence_name, sample_idx, sequence_cfg, load_pred_boxes=False):
  247.         """
  248.         Args:
  249.             info:
  250.             points:
  251.             sequence_name:
  252.             sample_idx:
  253.             sequence_cfg:
  254.         Returns:
  255.         """
  256.  
  257.         def remove_ego_points(points, center_radius=1.0):
  258.             mask = ~((np.abs(points[:, 0]) < center_radius) & (np.abs(points[:, 1]) < center_radius))
  259.             return points[mask]
  260.  
  261.         def load_pred_boxes_from_dict(sequence_name, sample_idx):
  262.             """
  263.             boxes: (N, 11)  [x, y, z, dx, dy, dn, raw, vx, vy, score, label]
  264.             """
  265.             sequence_name = sequence_name.replace('training_', '').replace('validation_', '')
  266.             load_boxes = self.pred_boxes_dict[sequence_name][sample_idx]
  267.             assert load_boxes.shape[-1] == 11
  268.             load_boxes[:, 7:9] = -0.1 * load_boxes[:, 7:9]  # transfer speed to negtive motion from t to t-1
  269.             return load_boxes
  270.  
  271.         pose_cur = info['pose'].reshape((4, 4))
  272.         num_pts_cur = points.shape[0]
  273.         sample_idx_pre_list = np.clip(sample_idx + np.arange(sequence_cfg.SAMPLE_OFFSET[0], sequence_cfg.SAMPLE_OFFSET[1]), 0, 0x7FFFFFFF)
  274.         sample_idx_pre_list = sample_idx_pre_list[::-1]
  275.  
  276.         if sequence_cfg.get('ONEHOT_TIMESTAMP', False):
  277.             onehot_cur = np.zeros((points.shape[0], len(sample_idx_pre_list) + 1)).astype(points.dtype)
  278.             onehot_cur[:, 0] = 1
  279.             points = np.hstack([points, onehot_cur])
  280.         else:
  281.             points = np.hstack([points, np.zeros((points.shape[0], 1)).astype(points.dtype)])
  282.         points_pre_all = []
  283.         num_points_pre = []
  284.  
  285.         pose_all = [pose_cur]
  286.         pred_boxes_all = []
  287.         if load_pred_boxes:
  288.             pred_boxes = load_pred_boxes_from_dict(sequence_name, sample_idx)
  289.             pred_boxes_all.append(pred_boxes)
  290.  
  291.         sequence_info = self.seq_name_to_infos[sequence_name]
  292.  
  293.         for idx, sample_idx_pre in enumerate(sample_idx_pre_list):
  294.  
  295.             points_pre = self.get_lidar(sequence_name, sample_idx_pre)
  296.             pose_pre = sequence_info[sample_idx_pre]['pose'].reshape((4, 4))
  297.             expand_points_pre = np.concatenate([points_pre[:, :3], np.ones((points_pre.shape[0], 1))], axis=-1)
  298.             points_pre_global = np.dot(expand_points_pre, pose_pre.T)[:, :3]
  299.             expand_points_pre_global = np.concatenate([points_pre_global, np.ones((points_pre_global.shape[0], 1))], axis=-1)
  300.             points_pre2cur = np.dot(expand_points_pre_global, np.linalg.inv(pose_cur.T))[:, :3]
  301.             points_pre = np.concatenate([points_pre2cur, points_pre[:, 3:]], axis=-1)
  302.             if sequence_cfg.get('ONEHOT_TIMESTAMP', False):
  303.                 onehot_vector = np.zeros((points_pre.shape[0], len(sample_idx_pre_list) + 1))
  304.                 onehot_vector[:, idx + 1] = 1
  305.                 points_pre = np.hstack([points_pre, onehot_vector])
  306.             else:
  307.                 # add timestamp
  308.                 points_pre = np.hstack([points_pre, 0.1 * (sample_idx - sample_idx_pre) * np.ones((points_pre.shape[0], 1)).astype(points_pre.dtype)])  # one frame 0.1s
  309.             points_pre = remove_ego_points(points_pre, 1.0)
  310.             points_pre_all.append(points_pre)
  311.             num_points_pre.append(points_pre.shape[0])
  312.             pose_all.append(pose_pre)
  313.  
  314.             if load_pred_boxes:
  315.                 pose_pre = sequence_info[sample_idx_pre]['pose'].reshape((4, 4))
  316.                 pred_boxes = load_pred_boxes_from_dict(sequence_name, sample_idx_pre)
  317.                 pred_boxes = self.transform_prebox_to_current(pred_boxes, pose_pre, pose_cur)
  318.                 pred_boxes_all.append(pred_boxes)
  319.  
  320.         points = np.concatenate([points] + points_pre_all, axis=0).astype(np.float32)
  321.         num_points_all = np.array([num_pts_cur] + num_points_pre).astype(np.int32)
  322.         poses = np.concatenate(pose_all, axis=0).astype(np.float32)
  323.  
  324.         if load_pred_boxes:
  325.             temp_pred_boxes = self.reorder_rois_for_refining(pred_boxes_all)
  326.             pred_boxes = temp_pred_boxes[:, :, 0:9]
  327.             pred_scores = temp_pred_boxes[:, :, 9]
  328.             pred_labels = temp_pred_boxes[:, :, 10]
  329.         else:
  330.             pred_boxes = pred_scores = pred_labels = None
  331.  
  332.         return points, num_points_all, sample_idx_pre_list, poses, pred_boxes, pred_scores, pred_labels
  333.  
  334.     def __len__(self):
  335.         if self._merge_all_iters_to_one_epoch:
  336.             return len(self.infos) * self.total_epochs
  337.  
  338.         return len(self.infos)
  339.  
  340.     def __getitem__(self, index):
  341.         if self._merge_all_iters_to_one_epoch:
  342.             index = index % len(self.infos)
  343.  
  344.         info = copy.deepcopy(self.infos[index])
  345.         pc_info = info['point_cloud']
  346.         sequence_name = pc_info['lidar_sequence']
  347.         sample_idx = pc_info['sample_idx']
  348.         input_dict = {
  349.             'sample_idx': sample_idx
  350.         }
  351.         if self.use_shared_memory and index < self.shared_memory_file_limit:
  352.             sa_key = f'{sequence_name}___{sample_idx}'
  353.             points = SharedArray.attach(f"shm://{sa_key}").copy()
  354.         else:
  355.             points = self.get_lidar(sequence_name, sample_idx)
  356.  
  357.         if self.dataset_cfg.get('SEQUENCE_CONFIG', None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED:
  358.             points, num_points_all, sample_idx_pre_list, poses, pred_boxes, pred_scores, pred_labels = self.get_sequence_data(
  359.                 info, points, sequence_name, sample_idx, self.dataset_cfg.SEQUENCE_CONFIG,
  360.                 load_pred_boxes=self.dataset_cfg.get('USE_PREDBOX', False)
  361.             )
  362.             input_dict['poses'] = poses
  363.             if self.dataset_cfg.get('USE_PREDBOX', False):
  364.                 input_dict.update({
  365.                     'roi_boxes': pred_boxes,
  366.                     'roi_scores': pred_scores,
  367.                     'roi_labels': pred_labels,
  368.                 })
  369.  
  370.         input_dict.update({
  371.             'points': points,
  372.             'frame_id': info['frame_id'],
  373.         })
  374.  
  375.         if 'annos' in info:
  376.             annos = info['annos']
  377.             annos = common_utils.drop_info_with_name(annos, name='unknown')
  378.  
  379.             if self.dataset_cfg.get('INFO_WITH_FAKELIDAR', False):
  380.                 gt_boxes_lidar = box_utils.boxes3d_kitti_fakelidar_to_lidar(annos['gt_boxes_lidar'])
  381.             else:
  382.                 gt_boxes_lidar = annos['gt_boxes_lidar']
  383.  
  384.             if self.dataset_cfg.get('TRAIN_WITH_SPEED', False):
  385.                 assert gt_boxes_lidar.shape[-1] == 9
  386.             else:
  387.                 gt_boxes_lidar = gt_boxes_lidar[:, 0:7]
  388.  
  389.             if self.training and self.dataset_cfg.get('FILTER_EMPTY_BOXES_FOR_TRAIN', False):
  390.                 mask = (annos['num_points_in_gt'] > 0)  # filter empty boxes
  391.                 annos['name'] = annos['name'][mask]
  392.                 gt_boxes_lidar = gt_boxes_lidar[mask]
  393.                 annos['num_points_in_gt'] = annos['num_points_in_gt'][mask]
  394.  
  395.             input_dict.update({
  396.                 'gt_names': annos['name'],
  397.                 'gt_boxes': gt_boxes_lidar,
  398.                 'num_points_in_gt': annos.get('num_points_in_gt', None)
  399.             })
  400.  
  401.         data_dict = self.prepare_data(data_dict=input_dict)
  402.         data_dict['metadata'] = info.get('metadata', info['frame_id'])
  403.         data_dict.pop('num_points_in_gt', None)
  404.         return data_dict
  405.  
  406.     def evaluation(self, det_annos, class_names, **kwargs):
  407.         if 'annos' not in self.infos[0].keys():
  408.             return 'No ground-truth boxes for evaluation', {}
  409.  
  410.         def kitti_eval(eval_det_annos, eval_gt_annos):
  411.             from ..kitti.kitti_object_eval_python import eval as kitti_eval
  412.             from ..kitti import kitti_utils
  413.  
  414.             map_name_to_kitti = {
  415.                 'Vehicle': 'Car',
  416.                 'Pedestrian': 'Pedestrian',
  417.                 'Cyclist': 'Cyclist',
  418.                 'Sign': 'Sign',
  419.                 'Car': 'Car'
  420.             }
  421.             kitti_utils.transform_annotations_to_kitti_format(eval_det_annos, map_name_to_kitti=map_name_to_kitti)
  422.             kitti_utils.transform_annotations_to_kitti_format(
  423.                 eval_gt_annos, map_name_to_kitti=map_name_to_kitti,
  424.                 info_with_fakelidar=self.dataset_cfg.get('INFO_WITH_FAKELIDAR', False)
  425.             )
  426.             kitti_class_names = [map_name_to_kitti[x] for x in class_names]
  427.             ap_result_str, ap_dict = kitti_eval.get_official_eval_result(
  428.                 gt_annos=eval_gt_annos, dt_annos=eval_det_annos, current_classes=kitti_class_names
  429.             )
  430.             return ap_result_str, ap_dict
  431.  
  432.         def waymo_eval(eval_det_annos, eval_gt_annos):
  433.             from .waymo_eval import OpenPCDetWaymoDetectionMetricsEstimator
  434.             eval = OpenPCDetWaymoDetectionMetricsEstimator()
  435.  
  436.             ap_dict = eval.waymo_evaluation(
  437.                 eval_det_annos, eval_gt_annos, class_name=class_names,
  438.                 distance_thresh=1000, fake_gt_infos=self.dataset_cfg.get('INFO_WITH_FAKELIDAR', False)
  439.             )
  440.             ap_result_str = '\n'
  441.             for key in ap_dict:
  442.                 ap_dict[key] = ap_dict[key][0]
  443.                 ap_result_str += '%s: %.4f \n' % (key, ap_dict[key])
  444.  
  445.             return ap_result_str, ap_dict
  446.  
  447.         eval_det_annos = copy.deepcopy(det_annos)
  448.         eval_gt_annos = [copy.deepcopy(info['annos']) for info in self.infos]
  449.  
  450.         if kwargs['eval_metric'] == 'kitti':
  451.             ap_result_str, ap_dict = kitti_eval(eval_det_annos, eval_gt_annos)
  452.         elif kwargs['eval_metric'] == 'waymo':
  453.             ap_result_str, ap_dict = waymo_eval(eval_det_annos, eval_gt_annos)
  454.         else:
  455.             raise NotImplementedError
  456.  
  457.         return ap_result_str, ap_dict
  458.  
  459.     def create_groundtruth_database(self, info_path, save_path, used_classes=None, split='train', sampled_interval=10,
  460.                                     processed_data_tag=None):
  461.  
  462.         use_sequence_data = self.dataset_cfg.get('SEQUENCE_CONFIG', None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED
  463.  
  464.         if use_sequence_data:
  465.             st_frame, ed_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0], self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[1]
  466.             self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0] = min(-4, st_frame)  # at least we use 5 frames for generating gt database to support various sequence configs (<= 5 frames)
  467.             st_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0]
  468.             database_save_path = save_path / ('%s_gt_database_%s_sampled_%d_multiframe_%s_to_%s' % (processed_data_tag, split, sampled_interval, st_frame, ed_frame))
  469.             db_info_save_path = save_path / ('%s_waymo_dbinfos_%s_sampled_%d_multiframe_%s_to_%s.pkl' % (processed_data_tag, split, sampled_interval, st_frame, ed_frame))
  470.             db_data_save_path = save_path / ('%s_gt_database_%s_sampled_%d_multiframe_%s_to_%s_global.npy' % (processed_data_tag, split, sampled_interval, st_frame, ed_frame))
  471.         else:
  472.             database_save_path = save_path / ('%s_gt_database_%s_sampled_%d' % (processed_data_tag, split, sampled_interval))
  473.             db_info_save_path = save_path / ('%s_waymo_dbinfos_%s_sampled_%d.pkl' % (processed_data_tag, split, sampled_interval))
  474.             db_data_save_path = save_path / ('%s_gt_database_%s_sampled_%d_global.npy' % (processed_data_tag, split, sampled_interval))
  475.  
  476.         database_save_path.mkdir(parents=True, exist_ok=True)
  477.         all_db_infos = {}
  478.         with open(info_path, 'rb') as f:
  479.             infos = pickle.load(f)
  480.  
  481.         point_offset_cnt = 0
  482.         stacked_gt_points = []
  483.         for k in tqdm(range(0, len(infos), sampled_interval)):
  484.             # print('gt_database sample: %d/%d' % (k + 1, len(infos)))
  485.             info = infos[k]
  486.  
  487.             pc_info = info['point_cloud']
  488.             sequence_name = pc_info['lidar_sequence']
  489.             sample_idx = pc_info['sample_idx']
  490.             points = self.get_lidar(sequence_name, sample_idx)
  491.  
  492.             if use_sequence_data:
  493.                 points, num_points_all, sample_idx_pre_list, _, _, _, _ = self.get_sequence_data(
  494.                     info, points, sequence_name, sample_idx, self.dataset_cfg.SEQUENCE_CONFIG
  495.                 )
  496.  
  497.             annos = info['annos']
  498.             names = annos['name']
  499.             difficulty = annos['difficulty']
  500.             gt_boxes = annos['gt_boxes_lidar']
  501.  
  502.             if k % 4 != 0 and len(names) > 0:
  503.                 mask = (names == 'Vehicle')
  504.                 names = names[~mask]
  505.                 difficulty = difficulty[~mask]
  506.                 gt_boxes = gt_boxes[~mask]
  507.  
  508.             if k % 2 != 0 and len(names) > 0:
  509.                 mask = (names == 'Pedestrian')
  510.                 names = names[~mask]
  511.                 difficulty = difficulty[~mask]
  512.                 gt_boxes = gt_boxes[~mask]
  513.  
  514.             num_obj = gt_boxes.shape[0]
  515.             if num_obj == 0:
  516.                 continue
  517.  
  518.             box_idxs_of_pts = roiaware_pool3d_utils.points_in_boxes_gpu(
  519.                 torch.from_numpy(points[:, 0:3]).unsqueeze(dim=0).float().cuda(),
  520.                 torch.from_numpy(gt_boxes[:, 0:7]).unsqueeze(dim=0).float().cuda()
  521.             ).long().squeeze(dim=0).cpu().numpy()
  522.  
  523.             for i in range(num_obj):
  524.                 filename = '%s_%04d_%s_%d.bin' % (sequence_name, sample_idx, names[i], i)
  525.                 filepath = database_save_path / filename
  526.                 gt_points = points[box_idxs_of_pts == i]
  527.                 gt_points[:, :3] -= gt_boxes[i, :3]
  528.  
  529.                 if (used_classes is None) or names[i] in used_classes:
  530.                     gt_points = gt_points.astype(np.float32)
  531.                     assert gt_points.dtype == np.float32
  532.                     with open(filepath, 'w') as f:
  533.                         gt_points.tofile(f)
  534.  
  535.                     db_path = str(filepath.relative_to(self.root_path))  # gt_database/xxxxx.bin
  536.                     db_info = {'name': names[i], 'path': db_path, 'sequence_name': sequence_name,
  537.                                'sample_idx': sample_idx, 'gt_idx': i, 'box3d_lidar': gt_boxes[i],
  538.                                'num_points_in_gt': gt_points.shape[0], 'difficulty': difficulty[i]}
  539.  
  540.                     # it will be used if you choose to use shared memory for gt sampling
  541.                     stacked_gt_points.append(gt_points)
  542.                     db_info['global_data_offset'] = [point_offset_cnt, point_offset_cnt + gt_points.shape[0]]
  543.                     point_offset_cnt += gt_points.shape[0]
  544.  
  545.                     if names[i] in all_db_infos:
  546.                         all_db_infos[names[i]].append(db_info)
  547.                     else:
  548.                         all_db_infos[names[i]] = [db_info]
  549.         for k, v in all_db_infos.items():
  550.             print('Database %s: %d' % (k, len(v)))
  551.  
  552.         with open(db_info_save_path, 'wb') as f:
  553.             pickle.dump(all_db_infos, f)
  554.  
  555.         # it will be used if you choose to use shared memory for gt sampling
  556.         stacked_gt_points = np.concatenate(stacked_gt_points, axis=0)
  557.         np.save(db_data_save_path, stacked_gt_points)
  558.  
  559.     def create_gt_database_of_single_scene(self, info_with_idx, database_save_path=None, use_sequence_data=False, used_classes=None,
  560.                                            total_samples=0, use_cuda=False, crop_gt_with_tail=False):
  561.         info, info_idx = info_with_idx
  562.         print('gt_database sample: %d/%d' % (info_idx, total_samples))
  563.  
  564.         all_db_infos = {}
  565.         pc_info = info['point_cloud']
  566.         sequence_name = pc_info['lidar_sequence']
  567.         sample_idx = pc_info['sample_idx']
  568.         points = self.get_lidar(sequence_name, sample_idx)
  569.  
  570.         if use_sequence_data:
  571.             points, num_points_all, sample_idx_pre_list, _, _, _, _ = self.get_sequence_data(
  572.                 info, points, sequence_name, sample_idx, self.dataset_cfg.SEQUENCE_CONFIG
  573.             )
  574.  
  575.         annos = info['annos']
  576.         names = annos['name']
  577.         difficulty = annos['difficulty']
  578.         gt_boxes = annos['gt_boxes_lidar']
  579.  
  580.         if info_idx % 4 != 0 and len(names) > 0:
  581.             mask = (names == 'Vehicle')
  582.             names = names[~mask]
  583.             difficulty = difficulty[~mask]
  584.             gt_boxes = gt_boxes[~mask]
  585.  
  586.         if info_idx % 2 != 0 and len(names) > 0:
  587.             mask = (names == 'Pedestrian')
  588.             names = names[~mask]
  589.             difficulty = difficulty[~mask]
  590.             gt_boxes = gt_boxes[~mask]
  591.  
  592.         num_obj = gt_boxes.shape[0]
  593.         if num_obj == 0:
  594.             return {}
  595.  
  596.         if use_sequence_data and crop_gt_with_tail:
  597.             assert gt_boxes.shape[1] == 9
  598.             speed = gt_boxes[:, 7:9]
  599.             sequence_cfg = self.dataset_cfg.SEQUENCE_CONFIG
  600.             assert sequence_cfg.SAMPLE_OFFSET[1] == 0
  601.             assert sequence_cfg.SAMPLE_OFFSET[0] < 0
  602.             num_frames = sequence_cfg.SAMPLE_OFFSET[1] - sequence_cfg.SAMPLE_OFFSET[0] + 1
  603.             assert num_frames > 1
  604.             latest_center = gt_boxes[:, 0:2]
  605.             oldest_center = latest_center - speed * (num_frames - 1) * 0.1
  606.             new_center = (latest_center + oldest_center) * 0.5
  607.             new_length = gt_boxes[:, 3] + np.linalg.norm(latest_center - oldest_center, axis=-1)
  608.             gt_boxes_crop = gt_boxes.copy()
  609.             gt_boxes_crop[:, 0:2] = new_center
  610.             gt_boxes_crop[:, 3] = new_length
  611.  
  612.         else:
  613.             gt_boxes_crop = gt_boxes
  614.  
  615.         if use_cuda:
  616.             box_idxs_of_pts = roiaware_pool3d_utils.points_in_boxes_gpu(
  617.                 torch.from_numpy(points[:, 0:3]).unsqueeze(dim=0).float().cuda(),
  618.                 torch.from_numpy(gt_boxes_crop[:, 0:7]).unsqueeze(dim=0).float().cuda()
  619.             ).long().squeeze(dim=0).cpu().numpy()
  620.         else:
  621.             box_point_mask = roiaware_pool3d_utils.points_in_boxes_cpu(
  622.                 torch.from_numpy(points[:, 0:3]).float(),
  623.                 torch.from_numpy(gt_boxes_crop[:, 0:7]).float()
  624.             ).long().numpy()  # (num_boxes, num_points)
  625.  
  626.         for i in range(num_obj):
  627.             filename = '%s_%04d_%s_%d.bin' % (sequence_name, sample_idx, names[i], i)
  628.             filepath = database_save_path / filename
  629.             if use_cuda:
  630.                 gt_points = points[box_idxs_of_pts == i]
  631.             else:
  632.                 gt_points = points[box_point_mask[i] > 0]
  633.  
  634.             gt_points[:, :3] -= gt_boxes[i, :3]
  635.  
  636.             if (used_classes is None) or names[i] in used_classes:
  637.                 gt_points = gt_points.astype(np.float32)
  638.                 assert gt_points.dtype == np.float32
  639.                 with open(filepath, 'w') as f:
  640.                     gt_points.tofile(f)
  641.  
  642.                 db_path = str(filepath.relative_to(self.root_path))  # gt_database/xxxxx.bin
  643.                 db_info = {'name': names[i], 'path': db_path, 'sequence_name': sequence_name,
  644.                             'sample_idx': sample_idx, 'gt_idx': i, 'box3d_lidar': gt_boxes[i],
  645.                             'num_points_in_gt': gt_points.shape[0], 'difficulty': difficulty[i],
  646.                             'box3d_crop': gt_boxes_crop[i]}
  647.  
  648.                 if names[i] in all_db_infos:
  649.                     all_db_infos[names[i]].append(db_info)
  650.                 else:
  651.                     all_db_infos[names[i]] = [db_info]
  652.         return all_db_infos
  653.  
  654.     def create_groundtruth_database_parallel(self, info_path, save_path, used_classes=None, split='train', sampled_interval=10,
  655.                                              processed_data_tag=None, num_workers=16, crop_gt_with_tail=False):
  656.         use_sequence_data = self.dataset_cfg.get('SEQUENCE_CONFIG', None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED
  657.         if use_sequence_data:
  658.             st_frame, ed_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0], self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[1]
  659.             self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0] = min(-4, st_frame)  # at least we use 5 frames for generating gt database to support various sequence configs (<= 5 frames)
  660.             st_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0]
  661.             database_save_path = save_path / ('%s_gt_database_%s_sampled_%d_multiframe_%s_to_%s_%sparallel' % (processed_data_tag, split, sampled_interval, st_frame, ed_frame, 'tail_' if crop_gt_with_tail else ''))
  662.             db_info_save_path = save_path / ('%s_waymo_dbinfos_%s_sampled_%d_multiframe_%s_to_%s_%sparallel.pkl' % (processed_data_tag, split, sampled_interval, st_frame, ed_frame, 'tail_' if crop_gt_with_tail else ''))
  663.         else:
  664.             database_save_path = save_path / ('%s_gt_database_%s_sampled_%d_parallel' % (processed_data_tag, split, sampled_interval))
  665.             db_info_save_path = save_path / ('%s_waymo_dbinfos_%s_sampled_%d_parallel.pkl' % (processed_data_tag, split, sampled_interval))
  666.             
  667.         database_save_path.mkdir(parents=True, exist_ok=True)
  668.  
  669.         with open(info_path, 'rb') as f:
  670.             infos = pickle.load(f)
  671.  
  672.         print(f'Number workers: {num_workers}')
  673.         create_gt_database_of_single_scene = partial(
  674.             self.create_gt_database_of_single_scene,
  675.             use_sequence_data=use_sequence_data, database_save_path=database_save_path,
  676.             used_classes=used_classes, total_samples=len(infos), use_cuda=False,
  677.             crop_gt_with_tail=crop_gt_with_tail
  678.         )
  679.         # create_gt_database_of_single_scene((infos[300], 0))
  680.         with multiprocessing.Pool(num_workers) as p:
  681.             all_db_infos_list = list(p.map(create_gt_database_of_single_scene, zip(infos, np.arange(len(infos)))))
  682.  
  683.         all_db_infos = {}
  684.  
  685.         for cur_db_infos in all_db_infos_list:
  686.             for key, val in cur_db_infos.items():
  687.                 if key not in all_db_infos:
  688.                     all_db_infos[key] = val
  689.                 else:
  690.                     all_db_infos[key].extend(val)
  691.  
  692.         for k, v in all_db_infos.items():
  693.             print('Database %s: %d' % (k, len(v)))
  694.  
  695.         with open(db_info_save_path, 'wb') as f:
  696.             pickle.dump(all_db_infos, f)
  697.  
  698. def create_waymo_infos(dataset_cfg, class_names, data_path, save_path,
  699.                        raw_data_tag='raw_data', processed_data_tag='waymo_processed_data',
  700.                        workers=min(16, multiprocessing.cpu_count()), update_info_only=False):
  701.     dataset = WaymoDataset(
  702.         dataset_cfg=dataset_cfg, class_names=class_names, root_path=data_path,
  703.         training=False, logger=common_utils.create_logger()
  704.     )
  705.     train_split, val_split = 'train', 'val'
  706.  
  707.     train_filename = save_path / ('%s_infos_%s.pkl' % (processed_data_tag, train_split))
  708.     val_filename = save_path / ('%s_infos_%s.pkl' % (processed_data_tag, val_split))
  709.  
  710.     os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
  711.     print('---------------Start to generate data infos---------------')
  712.  
  713.     dataset.set_split(train_split)
  714.     waymo_infos_train = dataset.get_infos(
  715.         raw_data_path=data_path / raw_data_tag,
  716.         save_path=save_path / processed_data_tag, num_workers=workers, has_label=True,
  717.         sampled_interval=1, update_info_only=update_info_only
  718.     )
  719.     with open(train_filename, 'wb') as f:
  720.         pickle.dump(waymo_infos_train, f)
  721.     print('----------------Waymo info train file is saved to %s----------------' % train_filename)
  722.  
  723.     dataset.set_split(val_split)
  724.     waymo_infos_val = dataset.get_infos(
  725.         raw_data_path=data_path / raw_data_tag,
  726.         save_path=save_path / processed_data_tag, num_workers=workers, has_label=True,
  727.         sampled_interval=1, update_info_only=update_info_only
  728.     )
  729.     with open(val_filename, 'wb') as f:
  730.         pickle.dump(waymo_infos_val, f)
  731.     print('----------------Waymo info val file is saved to %s----------------' % val_filename)
  732.  
  733.     if update_info_only:
  734.         return
  735.  
  736.     print('---------------Start create groundtruth database for data augmentation---------------')
  737.     os.environ["CUDA_VISIBLE_DEVICES"] = "0"
  738.     dataset.set_split(train_split)
  739.     dataset.create_groundtruth_database(
  740.         info_path=train_filename, save_path=save_path, split='train', sampled_interval=1,
  741.         used_classes=['Vehicle', 'Pedestrian', 'Cyclist'], processed_data_tag=processed_data_tag
  742.     )
  743.     print('---------------Data preparation Done---------------')
  744.  
  745.  
  746. def create_waymo_gt_database(
  747.     dataset_cfg, class_names, data_path, save_path, processed_data_tag='waymo_processed_data',
  748.     workers=min(16, multiprocessing.cpu_count()), use_parallel=False, crop_gt_with_tail=False):
  749.     dataset = WaymoDataset(
  750.         dataset_cfg=dataset_cfg, class_names=class_names, root_path=data_path,
  751.         training=False, logger=common_utils.create_logger()
  752.     )
  753.     train_split = 'train'
  754.     train_filename = save_path / ('%s_infos_%s.pkl' % (processed_data_tag, train_split))
  755.  
  756.     print('---------------Start create groundtruth database for data augmentation---------------')
  757.     dataset.set_split(train_split)
  758.  
  759.     if use_parallel:
  760.         dataset.create_groundtruth_database_parallel(
  761.             info_path=train_filename, save_path=save_path, split='train', sampled_interval=1,
  762.             used_classes=['Vehicle', 'Pedestrian', 'Cyclist'], processed_data_tag=processed_data_tag,
  763.             num_workers=workers, crop_gt_with_tail=crop_gt_with_tail
  764.         )
  765.     else:
  766.         dataset.create_groundtruth_database(
  767.             info_path=train_filename, save_path=save_path, split='train', sampled_interval=1,
  768.             used_classes=['Vehicle', 'Pedestrian', 'Cyclist'], processed_data_tag=processed_data_tag
  769.         )
  770.     print('---------------Data preparation Done---------------')
  771.  
  772.  
  773. if __name__ == '__main__':
  774.     import argparse
  775.     import yaml
  776.     from easydict import EasyDict
  777.  
  778.     parser = argparse.ArgumentParser(description='arg parser')
  779.     parser.add_argument('--cfg_file', type=str, default=None, help='specify the config of dataset')
  780.     parser.add_argument('--func', type=str, default='create_waymo_infos', help='')
  781.     parser.add_argument('--processed_data_tag', type=str, default='waymo_processed_data_v0_5_0', help='')
  782.     parser.add_argument('--update_info_only', action='store_true', default=False, help='')
  783.     parser.add_argument('--use_parallel', action='store_true', default=False, help='')
  784.     parser.add_argument('--wo_crop_gt_with_tail', action='store_true', default=False, help='')
  785.     parser.add_argument('--data_path', default=None, help='')
  786.  
  787.     args = parser.parse_args()
  788.     if args.data_path is not None:
  789.         ROOT_DIR = (Path(args.data_path)).resolve()
  790.     else:
  791.         ROOT_DIR = (Path(__file__).resolve().parent / '../../../').resolve() / 'data'/'waymo'
  792.     # ROOT_DIR = (Path(self.dataset_cfg.DATA_PATH)).resolve()
  793.     if args.func == 'create_waymo_infos':
  794.         try:
  795.             yaml_config = yaml.safe_load(open(args.cfg_file), Loader=yaml.FullLoader)
  796.         except:
  797.             yaml_config = yaml.safe_load(open(args.cfg_file))
  798.         dataset_cfg = EasyDict(yaml_config)
  799.         dataset_cfg.PROCESSED_DATA_TAG = args.processed_data_tag
  800.         create_waymo_infos(
  801.             dataset_cfg=dataset_cfg,
  802.             class_names=['Vehicle', 'Pedestrian', 'Cyclist'],
  803.             data_path=ROOT_DIR,
  804.             save_path=ROOT_DIR,
  805.             raw_data_tag='raw_data',
  806.             processed_data_tag=args.processed_data_tag,
  807.             update_info_only=args.update_info_only
  808.         )
  809.     elif args.func == 'create_waymo_gt_database':
  810.         try:
  811.             yaml_config = yaml.safe_load(open(args.cfg_file), Loader=yaml.FullLoader)
  812.         except:
  813.             yaml_config = yaml.safe_load(open(args.cfg_file))
  814.         dataset_cfg = EasyDict(yaml_config)
  815.         dataset_cfg.PROCESSED_DATA_TAG = args.processed_data_tag
  816.         create_waymo_gt_database(
  817.             dataset_cfg=dataset_cfg,
  818.             class_names=['Vehicle', 'Pedestrian', 'Cyclist'],
  819.             data_path=ROOT_DIR,
  820.             save_path=ROOT_DIR,
  821.             processed_data_tag=args.processed_data_tag,
  822.             use_parallel=args.use_parallel, 
  823.             crop_gt_with_tail=not args.wo_crop_gt_with_tail
  824.         )
  825.     else:
  826.         raise NotImplementedError

（2）更改训练源码

位置：OpenPCDet-master/tools/cfgs/dataset_configs/waymo_dataset.yaml

将DATA_PATH改为自己数据集的路径：

4、使用命令进行转换

从tfrecord中提取点云数据并生成数据信息：

python -m pcdet.datasets.waymo.waymo_dataset --func create_waymo_infos --cfg_file tools/cfgs/dataset_configs/waymo_dataset.yaml --data_path /media/xd/hpc/data/waymo_pcdet_mini/

指令格式：

指令格式为：python -m pcdet.datasets.waymo.waymo_dataset --func create_waymo_infos --cfg_file tools/cfgs/dataset_configs/waymo_dataset.yaml --data_path /media/xd/hpc/data/waymo_pcdet_mini/（waymo数据集路径）

5、训练

这里用PV_RCNN++举例，命令为

python train.py --cfg_file /home/xd/xyy/OpenPCDet-master/tools/cfgs/waymo_models/pv_rcnn_plusplus.yaml

四、关于数据集划分大小测验

我选择测试的是PV-RCNN++，官方的精度为：

测试1/8的结果如下（Traning和validation各取1/8）：

 测试一半的数据集时（Traning和validation各取一半），测试结果如下：

这时已经很接近官方的结果了，所以最后还是拿全集去测试。

五、遇到问题

1、ModuleNotFoundError: No module named 'numpy.typing'

答：numpy版本太低了，需要安装numpy>=1.21.0。

2、NotImplementedError: Cannot convert a symbolic Tensor (strided_slice:0) to a numpy array. This error may indicate that you're trying to pass a Tensor to a NumPy call, which is not supported

答：

这是一个很恶心的问题，主要是由于tensorflow与numpy版本不匹配，如果你使用的是官方的指令就容易出现这种错误：

pip install waymo_open_dataset-tf-2-1-0

问题描述：这里的tf-2-1-0指的就是在tensorflow2.1环境下运行，而源码中有些地方需要numpy>=2.21.0（例如：av2需要numpy>=2.21.0)。

提升或降低numpy版本：如果升numpy版本，就会遇到现在这个问题，如果降低numpy版本，又会报问题1的错误。

提升或降低tensorflow版本：不管提升还是降低tensorflow版本，都会由于av2过不了evaluation。

因此会陷入死循环，所以建议提升waymo_open_dataset-tf工具版本。

解决方法：把tensorflow版本提高，用如下指令：

pip install waymo_open_dataset-tf-2.11.0==1.5.0

这个指令会自动安装waymo_open_dataset-tf-2.11.0最新版本工具以及对应版本的tensorflow。

注：对于waymo数据集工具箱与tensorflow版本对应关系如下所示：

tensor版本waymo_open_dataset版本numpy版本
tensorflow 2.1至 tensorflow 2.6waymo_open_dataset-tf-2-1-0至waymo_open_dataset-tf-2-6-01.19.2及以下
tensorflow 2.11waymo_open_dataset-tf-2.11.01.21.5

 中间的tensorflow2.7-2.10目前都是没有开发的，具体可以参考最新手册及案例：

https://github.com/waymo-research/waymo-open-dataset/blob/master/tutorial/tutorial_v2.ipynbicon-default.png?t=N7T8https://github.com/waymo-research/waymo-open-dataset/blob/master/tutorial/tutorial_v2.ipynb

3、ImportError: cannot import name 'ParamSpec' from 'typing_extensions'

答：将typing_extenstions降级：

pip install typing-extensions==4.3.0

如果低版本安装不了，可以卸载了重新装一个不同版本的就可以。

参考：

ImportError: cannot import name 'ParamSpec' from 'typing_extensions'-编程语言-CSDN问答https://ask.csdn.net/questions/7829856

4、

 ImportError: cannot import name 'TypeGuard' from 'typing_extensions'

解决方法：同问题3.

5、AttributeError: module 'numpy.typing' has no attribute 'NDArray'

答：同问题1，numpy版本太低了，需要安装numpy>=1.21.0。

6、AttributeError: module ‘spconv‘ has no attribute ‘SparseModule‘

答：spconv2.x版本太高，需要安装spconv1.2.1进行降级。

CUDA11.x以上建议安装spconv2.x高版本，除非你是CUDA10.2，否则不建议安装spconv1.2.1，过程异常麻烦，且很大概率会在spconv构建环境build时报错：Subprocess.CalledProcessError。

具体可以参考我以前的博客：

九天毕昇”云平台：python3.7+CUDA10.1+torch1.6.0+spconcv1.2.1安装OpenPCDet全流程_空持千百偈，不如吃茶去的博客-CSDN博客主要在云平台上搭建OpenPCDet环境https://blog.csdn.net/weixin_44013732/article/details/126030624

7、ValueError: need at least one array to concatenate 

答：原因有很多，路径错误，文件名称错误，或者是train数据集和val数据集没有放到一起去转化。

8、tensorflow.python.framework.errors_impl.NotFoundError: /home/xd/anaconda3/lib/python3.8/site-packages/waymo_open_dataset/metrics/ops/metrics_ops.so: undefined symbol: _ZNK10tensorflow8OpKernel11TraceStringERKNS_15OpKernelContextEb 

答：waymo_open_dataset-tf的版本与tensorflow不匹配。

 9、ImportError: cannot import name 'detection_metrics' from 'waymo_open_dataset.metrics.python' (unknown location)

答：重装一遍waymo_open_dataset-tf。 

10、ZeroDivisionError: float division by zero

问题详细描述：

Traceback (most recent call last):
  File "train.py", line 229, in <module>
    main()
  File "train.py", line 219, in main
    repeat_eval_ckpt(
  File "/home/xyy/OpenPCDet-master/tools/test.py", line 123, in repeat_eval_ckpt
    tb_dict = eval_utils.eval_one_epoch(
  File "/home/xyy/OpenPCDet-master/tools/eval_utils/eval_utils.py", line 95, in eval_one_epoch
    sec_per_example = (time.time() - start_time) / len(dataloader.dataset)
ZeroDivisionError: float division by zero

解决方法：

将val数据集放到/waymo/raw_data下一起转换。

具体解释如下：

首先我们查看一下报错的信息：

 ZeroDivisionError: float division by zero代表着分母为0除不尽。

接着，我们来到报错的位置，尝试输出len(dataloader.dataset)：

所以我们可以得出结论，就是dataloader没有读入数据，因此我们开始向上看信息。

查看前面有没有这样的提示：

2023-08-25 19:44:58,443   INFO  Total skipped info 202
2023-08-25 19:44:58,443   INFO  Total samples for Waymo dataset: 0

信息中说明，跳过了202个，采样到了0个waymo数据。

我们来到total skipped info程序中，位置在：tools/cfgs/dataset_configs/waymo_dataset.py 

我们发现，跳过的个数是依靠num_skipped_info 来计数的，当info_path（也就是数据集路径）中没有val.txt(在data/waymo/ImageSets)所提到的数据，那么就计数加1，所以在这里我们输出info_path。

发现跳过的就是val.txt中的文件，经查发现，/raw_data文件夹下确实忘记把val数据集放进去了。

所以结论很明了，我们只需要将val的解压包进行解压，放到val.

11、TFrecord文件错误

问题描述：

在转换waymo的tfrecord遇到这么一个阴间问题，导致我查了很久：

multiprocessing.pool.RemoteTraceback: 
"""
Traceback (most recent call last):
  File "/data/conda/envs/pcdet/lib/python3.8/multiprocessing/pool.py", line 125, in worker
    result = (True, func(*args, **kwds))
  File "/home/xyy/OpenPCDet-master/pcdet/datasets/waymo/waymo_utils.py", line 225, in process_single_sequence
    for cnt, data in enumerate(dataset):
  File "/home/user/.local/lib/python3.8/site-packages/tensorflow/python/data/ops/iterator_ops.py", line 787, in __next__
    return self._next_internal()
  File "/home/user/.local/lib/python3.8/site-packages/tensorflow/python/data/ops/iterator_ops.py", line 770, in _next_internal
    ret = gen_dataset_ops.iterator_get_next(
  File "/home/user/.local/lib/python3.8/site-packages/tensorflow/python/ops/gen_dataset_ops.py", line 3017, in iterator_get_next
    _ops.raise_from_not_ok_status(e, name)
  File "/home/user/.local/lib/python3.8/site-packages/tensorflow/python/framework/ops.py", line 7215, in raise_from_not_ok_status
    raise core._status_to_exception(e) from None  # pylint: disable=protected-access
tensorflow.python.framework.errors_impl.DataLossError: {{function_node __wrapped__IteratorGetNext_output_types_1_device_/job:localhost/replica:0/task:0/device:CPU:0}} corrupted record at 969164982 [Op:IteratorGetNext]
"""

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "/data/conda/envs/pcdet/lib/python3.8/runpy.py", line 194, in _run_module_as_main
    return _run_code(code, main_globals, None,
  File "/data/conda/envs/pcdet/lib/python3.8/runpy.py", line 87, in _run_code
    exec(code, run_globals)
  File "/home/xyy/OpenPCDet-master/pcdet/datasets/waymo/waymo_dataset.py", line 831, in <module>
    create_waymo_infos(
  File "/home/xyy/OpenPCDet-master/pcdet/datasets/waymo/waymo_dataset.py", line 744, in create_waymo_infos
    waymo_infos_train = dataset.get_infos(
  File "/home/xyy/OpenPCDet-master/pcdet/datasets/waymo/waymo_dataset.py", line 199, in get_infos
    sequence_infos = list(tqdm(p.imap(process_single_sequence, sample_sequence_file_list),
  File "/data/conda/envs/pcdet/lib/python3.8/site-packages/tqdm/std.py", line 1178, in __iter__
    for obj in iterable:
  File "/data/conda/envs/pcdet/lib/python3.8/multiprocessing/pool.py", line 868, in next
    raise value
tensorflow.python.framework.errors_impl.DataLossError: {{function_node __wrapped__IteratorGetNext_output_types_1_device_/job:localhost/replica:0/task:0/device:CPU:0}} corrupted record at 969164982 [Op:IteratorGetNext]

 问题原因：就是官方数据集在转换tfrecord时出了问题，这个现象在v1.4.1更为常见，因此，我们最主要的目的就是查出问题文件并删除。

省事方法：

将名为segment-9175749307679169289_5933_260_5953_260_with_camera_labels.tfrecord文件删除（或先放到一个新建的文件夹里）。

详细处理步骤：

根据问题描述，我们先来到 /OpenPCDet-master/pcdet/datasets/waymo/waymo_utils.py文件的225行：

 我们在代码上面输出一下当前转换的tfrecord文件：

 接着看下一个问题，定位到了读条函数那里，我们来到/OpenPCDet-master/pcdet/datasets/waymo/waymo_dataset.py的199行：

 我们将读条函数的num_workers改为1，让他一个一个转换，看具体是哪个出了问题：

 最后再运行一下生成数据指令：

python -m pcdet.datasets.waymo.waymo_dataset --func create_waymo_infos --cfg_file tools/cfgs/dataset_configs/waymo_dataset.yaml

查看到的结果如下：

 因此，我们将这个文件拿去即可接着转换：

 没问题喽~。

修改源码如下：

/OpenPCDet-master/pcdet/datasets/waymo/waymo_dataset.py:

  1. # OpenPCDet PyTorch Dataloader and Evaluation Tools for Waymo Open Dataset
  2. # Reference https://github.com/open-mmlab/OpenPCDet
  3. # Written by Shaoshuai Shi, Chaoxu Guo
  4. # All Rights Reserved.
  5.  
  6. import os
  7. import pickle
  8. import copy
  9. import numpy as np
  10. import torch
  11. import multiprocessing
  12. import SharedArray
  13. import torch.distributed as dist
  14. from tqdm import tqdm
  15. from pathlib import Path
  16. from functools import partial
  17.  
  18. from ...ops.roiaware_pool3d import roiaware_pool3d_utils
  19. from ...utils import box_utils, common_utils
  20. from ..dataset import DatasetTemplate
  21.  
  22.  
  23. class WaymoDataset(DatasetTemplate):
  24.     def __init__(self, dataset_cfg, class_names, training=True, root_path=None, logger=None):
  25.         super().__init__(
  26.             dataset_cfg=dataset_cfg, class_names=class_names, training=training, root_path=root_path, logger=logger
  27.         )
  28.         self.data_path = self.root_path / self.dataset_cfg.PROCESSED_DATA_TAG
  29.         self.split = self.dataset_cfg.DATA_SPLIT[self.mode]
  30.         split_dir = self.root_path / 'ImageSets' / (self.split + '.txt')
  31.         self.sample_sequence_list = [x.strip() for x in open(split_dir).readlines()]
  32.  
  33.         self.infos = []
  34.         self.seq_name_to_infos = self.include_waymo_data(self.mode)
  35.  
  36.         self.use_shared_memory = self.dataset_cfg.get('USE_SHARED_MEMORY', False) and self.training
  37.         if self.use_shared_memory:
  38.             self.shared_memory_file_limit = self.dataset_cfg.get('SHARED_MEMORY_FILE_LIMIT', 0x7FFFFFFF)
  39.             self.load_data_to_shared_memory()
  40.  
  41.         if self.dataset_cfg.get('USE_PREDBOX', False):
  42.             self.pred_boxes_dict = self.load_pred_boxes_to_dict(
  43.                 pred_boxes_path=self.dataset_cfg.ROI_BOXES_PATH[self.mode]
  44.             )
  45.         else:
  46.             self.pred_boxes_dict = {}
  47.  
  48.     def set_split(self, split):
  49.         super().__init__(
  50.             dataset_cfg=self.dataset_cfg, class_names=self.class_names, training=self.training,
  51.             root_path=self.root_path, logger=self.logger
  52.         )
  53.         self.split = split
  54.         split_dir = self.root_path / 'ImageSets' / (self.split + '.txt')
  55.         self.sample_sequence_list = [x.strip() for x in open(split_dir).readlines()]
  56.         self.infos = []
  57.         self.seq_name_to_infos = self.include_waymo_data(self.mode)
  58.  
  59.     def include_waymo_data(self, mode):
  60.         self.logger.info('Loading Waymo dataset')
  61.         waymo_infos = []
  62.         seq_name_to_infos = {}
  63.  
  64.         num_skipped_infos = 0
  65.         for k in range(len(self.sample_sequence_list)):
  66.             sequence_name = os.path.splitext(self.sample_sequence_list[k])[0]
  67.             info_path = self.data_path / sequence_name / ('%s.pkl' % sequence_name)
  68.             info_path = self.check_sequence_name_with_all_version(info_path)
  69.             # print(info_path)
  70.             if not info_path.exists():
  71.                 num_skipped_infos += 1
  72.                 continue
  73.             with open(info_path, 'rb') as f:
  74.                 infos = pickle.load(f)
  75.                 waymo_infos.extend(infos)
  76.  
  77.             seq_name_to_infos[infos[0]['point_cloud']['lidar_sequence']] = infos
  78.  
  79.         self.infos.extend(waymo_infos[:])
  80.         self.logger.info('Total skipped info %s' % num_skipped_infos)
  81.         self.logger.info('Total samples for Waymo dataset: %d' % (len(waymo_infos)))
  82.  
  83.         if self.dataset_cfg.SAMPLED_INTERVAL[mode] > 1:
  84.             sampled_waymo_infos = []
  85.             for k in range(0, len(self.infos), self.dataset_cfg.SAMPLED_INTERVAL[mode]):
  86.                 sampled_waymo_infos.append(self.infos[k])
  87.             self.infos = sampled_waymo_infos
  88.             self.logger.info('Total sampled samples for Waymo dataset: %d' % len(self.infos))
  89.  
  90.         use_sequence_data = self.dataset_cfg.get('SEQUENCE_CONFIG',
  91.                                                  None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED
  92.         if not use_sequence_data:
  93.             seq_name_to_infos = None
  94.         return seq_name_to_infos
  95.  
  96.     def load_pred_boxes_to_dict(self, pred_boxes_path):
  97.         self.logger.info(f'Loading and reorganizing pred_boxes to dict from path: {pred_boxes_path}')
  98.         with open(pred_boxes_path, 'rb') as f:
  99.             pred_dicts = pickle.load(f)
  100.  
  101.         pred_boxes_dict = {}
  102.         for index, box_dict in enumerate(pred_dicts):
  103.             seq_name = box_dict['frame_id'][:-4].replace('training_', '').replace('validation_', '')
  104.             sample_idx = int(box_dict['frame_id'][-3:])
  105.  
  106.             if seq_name not in pred_boxes_dict:
  107.                 pred_boxes_dict[seq_name] = {}
  108.  
  109.             pred_labels = np.array(
  110.                 [self.class_names.index(box_dict['name'][k]) + 1 for k in range(box_dict['name'].shape[0])])
  111.             pred_boxes = np.concatenate(
  112.                 (box_dict['boxes_lidar'], box_dict['score'][:, np.newaxis], pred_labels[:, np.newaxis]), axis=-1)
  113.             pred_boxes_dict[seq_name][sample_idx] = pred_boxes
  114.  
  115.         self.logger.info(f'Predicted boxes has been loaded, total sequences: {len(pred_boxes_dict)}')
  116.         return pred_boxes_dict
  117.  
  118.     def load_data_to_shared_memory(self):
  119.         self.logger.info(f'Loading training data to shared memory (file limit={self.shared_memory_file_limit})')
  120.  
  121.         cur_rank, num_gpus = common_utils.get_dist_info()
  122.         all_infos = self.infos[:self.shared_memory_file_limit] \
  123.             if self.shared_memory_file_limit < len(self.infos) else self.infos
  124.         cur_infos = all_infos[cur_rank::num_gpus]
  125.         for info in cur_infos:
  126.             pc_info = info['point_cloud']
  127.             sequence_name = pc_info['lidar_sequence']
  128.             sample_idx = pc_info['sample_idx']
  129.  
  130.             sa_key = f'{sequence_name}___{sample_idx}'
  131.             if os.path.exists(f"/dev/shm/{sa_key}"):
  132.                 continue
  133.  
  134.             points = self.get_lidar(sequence_name, sample_idx)
  135.             common_utils.sa_create(f"shm://{sa_key}", points)
  136.  
  137.         dist.barrier()
  138.         self.logger.info('Training data has been saved to shared memory')
  139.  
  140.     def clean_shared_memory(self):
  141.         self.logger.info(f'Clean training data from shared memory (file limit={self.shared_memory_file_limit})')
  142.  
  143.         cur_rank, num_gpus = common_utils.get_dist_info()
  144.         all_infos = self.infos[:self.shared_memory_file_limit] \
  145.             if self.shared_memory_file_limit < len(self.infos) else self.infos
  146.         cur_infos = all_infos[cur_rank::num_gpus]
  147.         for info in cur_infos:
  148.             pc_info = info['point_cloud']
  149.             sequence_name = pc_info['lidar_sequence']
  150.             sample_idx = pc_info['sample_idx']
  151.  
  152.             sa_key = f'{sequence_name}___{sample_idx}'
  153.             if not os.path.exists(f"/dev/shm/{sa_key}"):
  154.                 continue
  155.  
  156.             SharedArray.delete(f"shm://{sa_key}")
  157.  
  158.         if num_gpus > 1:
  159.             dist.barrier()
  160.         self.logger.info('Training data has been deleted from shared memory')
  161.  
  162.     @staticmethod
  163.     def check_sequence_name_with_all_version(sequence_file):
  164.         if not sequence_file.exists():
  165.             found_sequence_file = sequence_file
  166.             for pre_text in ['training', 'validation', 'testing']:
  167.                 if not sequence_file.exists():
  168.                     temp_sequence_file = Path(str(sequence_file).replace('segment', pre_text + '_segment'))
  169.                     if temp_sequence_file.exists():
  170.                         found_sequence_file = temp_sequence_file
  171.                         break
  172.             if not found_sequence_file.exists():
  173.                 found_sequence_file = Path(str(sequence_file).replace('_with_camera_labels', ''))
  174.             if found_sequence_file.exists():
  175.                 sequence_file = found_sequence_file
  176.         return sequence_file
  177.  
  178.     def get_infos(self, raw_data_path, save_path, num_workers=multiprocessing.cpu_count(), has_label=True,
  179.                   sampled_interval=1, update_info_only=False):
  180.         from . import waymo_utils
  181.         print('---------------The waymo sample interval is %d, total sequecnes is %d-----------------'
  182.               % (sampled_interval, len(self.sample_sequence_list)))
  183.  
  184.         process_single_sequence = partial(
  185.             waymo_utils.process_single_sequence,
  186.             save_path=save_path, sampled_interval=sampled_interval, has_label=has_label,
  187.             update_info_only=update_info_only
  188.         )
  189.         sample_sequence_file_list = [
  190.             self.check_sequence_name_with_all_version(raw_data_path / sequence_file)
  191.             for sequence_file in self.sample_sequence_list
  192.         ]
  193.  
  194.         # process_single_sequence(sample_sequence_file_list[0])
  195.         # 读条
  196.         num_workers=1
  197.         with multiprocessing.Pool(num_workers) as p:
  198.             sequence_infos = list(tqdm(p.imap(process_single_sequence, sample_sequence_file_list),
  199.                                        total=len(sample_sequence_file_list)))
  200.  
  201.         all_sequences_infos = [item for infos in sequence_infos for item in infos]
  202.         return all_sequences_infos
  203.  
  204.     def get_lidar(self, sequence_name, sample_idx):
  205.         lidar_file = self.data_path / sequence_name / ('%04d.npy' % sample_idx)
  206.         point_features = np.load(lidar_file)  # (N, 7): [x, y, z, intensity, elongation, NLZ_flag]
  207.  
  208.         points_all, NLZ_flag = point_features[:, 0:5], point_features[:, 5]
  209.         if not self.dataset_cfg.get('DISABLE_NLZ_FLAG_ON_POINTS', False):
  210.             points_all = points_all[NLZ_flag == -1]
  211.         points_all[:, 3] = np.tanh(points_all[:, 3])
  212.         return points_all
  213.  
  214.     @staticmethod
  215.     def transform_prebox_to_current(pred_boxes3d, pose_pre, pose_cur):
  216.         """
  217.         Args:
  218.             pred_boxes3d (N, 9 or 11): [x, y, z, dx, dy, dz, raw, <vx, vy,> score, label]
  219.             pose_pre (4, 4):
  220.             pose_cur (4, 4):
  221.         Returns:
  222.         """
  223.         assert pred_boxes3d.shape[-1] in [9, 11]
  224.         pred_boxes3d = pred_boxes3d.copy()
  225.         expand_bboxes = np.concatenate([pred_boxes3d[:, :3], np.ones((pred_boxes3d.shape[0], 1))], axis=-1)
  226.  
  227.         bboxes_global = np.dot(expand_bboxes, pose_pre.T)[:, :3]
  228.         expand_bboxes_global = np.concatenate([bboxes_global[:, :3], np.ones((bboxes_global.shape[0], 1))], axis=-1)
  229.         bboxes_pre2cur = np.dot(expand_bboxes_global, np.linalg.inv(pose_cur.T))[:, :3]
  230.         pred_boxes3d[:, 0:3] = bboxes_pre2cur
  231.  
  232.         if pred_boxes3d.shape[-1] == 11:
  233.             expand_vels = np.concatenate([pred_boxes3d[:, 7:9], np.zeros((pred_boxes3d.shape[0], 1))], axis=-1)
  234.             vels_global = np.dot(expand_vels, pose_pre[:3, :3].T)
  235.             vels_pre2cur = np.dot(vels_global, np.linalg.inv(pose_cur[:3, :3].T))[:, :2]
  236.             pred_boxes3d[:, 7:9] = vels_pre2cur
  237.  
  238.         pred_boxes3d[:, 6] = pred_boxes3d[..., 6] + np.arctan2(pose_pre[..., 1, 0], pose_pre[..., 0, 0])
  239.         pred_boxes3d[:, 6] = pred_boxes3d[..., 6] - np.arctan2(pose_cur[..., 1, 0], pose_cur[..., 0, 0])
  240.         return pred_boxes3d
  241.  
  242.     @staticmethod
  243.     def reorder_rois_for_refining(pred_bboxes):
  244.         num_max_rois = max([len(bbox) for bbox in pred_bboxes])
  245.         num_max_rois = max(1, num_max_rois)  # at least one faked rois to avoid error
  246.         ordered_bboxes = np.zeros([len(pred_bboxes), num_max_rois, pred_bboxes[0].shape[-1]], dtype=np.float32)
  247.  
  248.         for bs_idx in range(ordered_bboxes.shape[0]):
  249.             ordered_bboxes[bs_idx, :len(pred_bboxes[bs_idx])] = pred_bboxes[bs_idx]
  250.         return ordered_bboxes
  251.  
  252.     def get_sequence_data(self, info, points, sequence_name, sample_idx, sequence_cfg, load_pred_boxes=False):
  253.         """
  254.         Args:
  255.             info:
  256.             points:
  257.             sequence_name:
  258.             sample_idx:
  259.             sequence_cfg:
  260.         Returns:
  261.         """
  262.  
  263.         def remove_ego_points(points, center_radius=1.0):
  264.             mask = ~((np.abs(points[:, 0]) < center_radius) & (np.abs(points[:, 1]) < center_radius))
  265.             return points[mask]
  266.  
  267.         def load_pred_boxes_from_dict(sequence_name, sample_idx):
  268.             """
  269.             boxes: (N, 11)  [x, y, z, dx, dy, dn, raw, vx, vy, score, label]
  270.             """
  271.             sequence_name = sequence_name.replace('training_', '').replace('validation_', '')
  272.             load_boxes = self.pred_boxes_dict[sequence_name][sample_idx]
  273.             assert load_boxes.shape[-1] == 11
  274.             load_boxes[:, 7:9] = -0.1 * load_boxes[:, 7:9]  # transfer speed to negtive motion from t to t-1
  275.             return load_boxes
  276.  
  277.         pose_cur = info['pose'].reshape((4, 4))
  278.         num_pts_cur = points.shape[0]
  279.         sample_idx_pre_list = np.clip(
  280.             sample_idx + np.arange(sequence_cfg.SAMPLE_OFFSET[0], sequence_cfg.SAMPLE_OFFSET[1]), 0, 0x7FFFFFFF)
  281.         sample_idx_pre_list = sample_idx_pre_list[::-1]
  282.  
  283.         if sequence_cfg.get('ONEHOT_TIMESTAMP', False):
  284.             onehot_cur = np.zeros((points.shape[0], len(sample_idx_pre_list) + 1)).astype(points.dtype)
  285.             onehot_cur[:, 0] = 1
  286.             points = np.hstack([points, onehot_cur])
  287.         else:
  288.             points = np.hstack([points, np.zeros((points.shape[0], 1)).astype(points.dtype)])
  289.         points_pre_all = []
  290.         num_points_pre = []
  291.  
  292.         pose_all = [pose_cur]
  293.         pred_boxes_all = []
  294.         if load_pred_boxes:
  295.             pred_boxes = load_pred_boxes_from_dict(sequence_name, sample_idx)
  296.             pred_boxes_all.append(pred_boxes)
  297.  
  298.         sequence_info = self.seq_name_to_infos[sequence_name]
  299.  
  300.         for idx, sample_idx_pre in enumerate(sample_idx_pre_list):
  301.  
  302.             points_pre = self.get_lidar(sequence_name, sample_idx_pre)
  303.             pose_pre = sequence_info[sample_idx_pre]['pose'].reshape((4, 4))
  304.             expand_points_pre = np.concatenate([points_pre[:, :3], np.ones((points_pre.shape[0], 1))], axis=-1)
  305.             points_pre_global = np.dot(expand_points_pre, pose_pre.T)[:, :3]
  306.             expand_points_pre_global = np.concatenate([points_pre_global, np.ones((points_pre_global.shape[0], 1))],
  307.                                                       axis=-1)
  308.             points_pre2cur = np.dot(expand_points_pre_global, np.linalg.inv(pose_cur.T))[:, :3]
  309.             points_pre = np.concatenate([points_pre2cur, points_pre[:, 3:]], axis=-1)
  310.             if sequence_cfg.get('ONEHOT_TIMESTAMP', False):
  311.                 onehot_vector = np.zeros((points_pre.shape[0], len(sample_idx_pre_list) + 1))
  312.                 onehot_vector[:, idx + 1] = 1
  313.                 points_pre = np.hstack([points_pre, onehot_vector])
  314.             else:
  315.                 # add timestamp
  316.                 points_pre = np.hstack([points_pre,
  317.                                         0.1 * (sample_idx - sample_idx_pre) * np.ones((points_pre.shape[0], 1)).astype(
  318.                                             points_pre.dtype)])  # one frame 0.1s
  319.             points_pre = remove_ego_points(points_pre, 1.0)
  320.             points_pre_all.append(points_pre)
  321.             num_points_pre.append(points_pre.shape[0])
  322.             pose_all.append(pose_pre)
  323.  
  324.             if load_pred_boxes:
  325.                 pose_pre = sequence_info[sample_idx_pre]['pose'].reshape((4, 4))
  326.                 pred_boxes = load_pred_boxes_from_dict(sequence_name, sample_idx_pre)
  327.                 pred_boxes = self.transform_prebox_to_current(pred_boxes, pose_pre, pose_cur)
  328.                 pred_boxes_all.append(pred_boxes)
  329.  
  330.         points = np.concatenate([points] + points_pre_all, axis=0).astype(np.float32)
  331.         num_points_all = np.array([num_pts_cur] + num_points_pre).astype(np.int32)
  332.         poses = np.concatenate(pose_all, axis=0).astype(np.float32)
  333.  
  334.         if load_pred_boxes:
  335.             temp_pred_boxes = self.reorder_rois_for_refining(pred_boxes_all)
  336.             pred_boxes = temp_pred_boxes[:, :, 0:9]
  337.             pred_scores = temp_pred_boxes[:, :, 9]
  338.             pred_labels = temp_pred_boxes[:, :, 10]
  339.         else:
  340.             pred_boxes = pred_scores = pred_labels = None
  341.  
  342.         return points, num_points_all, sample_idx_pre_list, poses, pred_boxes, pred_scores, pred_labels
  343.  
  344.     def __len__(self):
  345.         if self._merge_all_iters_to_one_epoch:
  346.             return len(self.infos) * self.total_epochs
  347.  
  348.         return len(self.infos)
  349.  
  350.     def __getitem__(self, index):
  351.         if self._merge_all_iters_to_one_epoch:
  352.             index = index % len(self.infos)
  353.  
  354.         info = copy.deepcopy(self.infos[index])
  355.         pc_info = info['point_cloud']
  356.         sequence_name = pc_info['lidar_sequence']
  357.         sample_idx = pc_info['sample_idx']
  358.         input_dict = {
  359.             'sample_idx': sample_idx
  360.         }
  361.         if self.use_shared_memory and index < self.shared_memory_file_limit:
  362.             sa_key = f'{sequence_name}___{sample_idx}'
  363.             points = SharedArray.attach(f"shm://{sa_key}").copy()
  364.         else:
  365.             points = self.get_lidar(sequence_name, sample_idx)
  366.  
  367.         if self.dataset_cfg.get('SEQUENCE_CONFIG', None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED:
  368.             points, num_points_all, sample_idx_pre_list, poses, pred_boxes, pred_scores, pred_labels = self.get_sequence_data(
  369.                 info, points, sequence_name, sample_idx, self.dataset_cfg.SEQUENCE_CONFIG,
  370.                 load_pred_boxes=self.dataset_cfg.get('USE_PREDBOX', False)
  371.             )
  372.             input_dict['poses'] = poses
  373.             if self.dataset_cfg.get('USE_PREDBOX', False):
  374.                 input_dict.update({
  375.                     'roi_boxes': pred_boxes,
  376.                     'roi_scores': pred_scores,
  377.                     'roi_labels': pred_labels,
  378.                 })
  379.  
  380.         input_dict.update({
  381.             'points': points,
  382.             'frame_id': info['frame_id'],
  383.         })
  384.  
  385.         if 'annos' in info:
  386.             annos = info['annos']
  387.             annos = common_utils.drop_info_with_name(annos, name='unknown')
  388.  
  389.             if self.dataset_cfg.get('INFO_WITH_FAKELIDAR', False):
  390.                 gt_boxes_lidar = box_utils.boxes3d_kitti_fakelidar_to_lidar(annos['gt_boxes_lidar'])
  391.             else:
  392.                 gt_boxes_lidar = annos['gt_boxes_lidar']
  393.  
  394.             if self.dataset_cfg.get('TRAIN_WITH_SPEED', False):
  395.                 assert gt_boxes_lidar.shape[-1] == 9
  396.             else:
  397.                 gt_boxes_lidar = gt_boxes_lidar[:, 0:7]
  398.  
  399.             if self.training and self.dataset_cfg.get('FILTER_EMPTY_BOXES_FOR_TRAIN', False):
  400.                 mask = (annos['num_points_in_gt'] > 0)  # filter empty boxes
  401.                 annos['name'] = annos['name'][mask]
  402.                 gt_boxes_lidar = gt_boxes_lidar[mask]
  403.                 annos['num_points_in_gt'] = annos['num_points_in_gt'][mask]
  404.  
  405.             input_dict.update({
  406.                 'gt_names': annos['name'],
  407.                 'gt_boxes': gt_boxes_lidar,
  408.                 'num_points_in_gt': annos.get('num_points_in_gt', None)
  409.             })
  410.  
  411.         data_dict = self.prepare_data(data_dict=input_dict)
  412.         data_dict['metadata'] = info.get('metadata', info['frame_id'])
  413.         data_dict.pop('num_points_in_gt', None)
  414.         return data_dict
  415.  
  416.     def evaluation(self, det_annos, class_names, **kwargs):
  417.         if 'annos' not in self.infos[0].keys():
  418.             return 'No ground-truth boxes for evaluation', {}
  419.  
  420.         def kitti_eval(eval_det_annos, eval_gt_annos):
  421.             from ..kitti.kitti_object_eval_python import eval as kitti_eval
  422.             from ..kitti import kitti_utils
  423.  
  424.             map_name_to_kitti = {
  425.                 'Vehicle': 'Car',
  426.                 'Pedestrian': 'Pedestrian',
  427.                 'Cyclist': 'Cyclist',
  428.                 'Sign': 'Sign',
  429.                 'Car': 'Car'
  430.             }
  431.             kitti_utils.transform_annotations_to_kitti_format(eval_det_annos, map_name_to_kitti=map_name_to_kitti)
  432.             kitti_utils.transform_annotations_to_kitti_format(
  433.                 eval_gt_annos, map_name_to_kitti=map_name_to_kitti,
  434.                 info_with_fakelidar=self.dataset_cfg.get('INFO_WITH_FAKELIDAR', False)
  435.             )
  436.             kitti_class_names = [map_name_to_kitti[x] for x in class_names]
  437.             ap_result_str, ap_dict = kitti_eval.get_official_eval_result(
  438.                 gt_annos=eval_gt_annos, dt_annos=eval_det_annos, current_classes=kitti_class_names
  439.             )
  440.             return ap_result_str, ap_dict
  441.  
  442.         def waymo_eval(eval_det_annos, eval_gt_annos):
  443.             from .waymo_eval import OpenPCDetWaymoDetectionMetricsEstimator
  444.             eval = OpenPCDetWaymoDetectionMetricsEstimator()
  445.  
  446.             ap_dict = eval.waymo_evaluation(
  447.                 eval_det_annos, eval_gt_annos, class_name=class_names,
  448.                 distance_thresh=1000, fake_gt_infos=self.dataset_cfg.get('INFO_WITH_FAKELIDAR', False)
  449.             )
  450.             ap_result_str = '\n'
  451.             for key in ap_dict:
  452.                 ap_dict[key] = ap_dict[key][0]
  453.                 ap_result_str += '%s: %.4f \n' % (key, ap_dict[key])
  454.  
  455.             return ap_result_str, ap_dict
  456.  
  457.         eval_det_annos = copy.deepcopy(det_annos)
  458.         eval_gt_annos = [copy.deepcopy(info['annos']) for info in self.infos]
  459.  
  460.         if kwargs['eval_metric'] == 'kitti':
  461.             ap_result_str, ap_dict = kitti_eval(eval_det_annos, eval_gt_annos)
  462.         elif kwargs['eval_metric'] == 'waymo':
  463.             ap_result_str, ap_dict = waymo_eval(eval_det_annos, eval_gt_annos)
  464.         else:
  465.             raise NotImplementedError
  466.  
  467.         return ap_result_str, ap_dict
  468.  
  469.     def create_groundtruth_database(self, info_path, save_path, used_classes=None, split='train', sampled_interval=10,
  470.                                     processed_data_tag=None):
  471.  
  472.         use_sequence_data = self.dataset_cfg.get('SEQUENCE_CONFIG',
  473.                                                  None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED
  474.  
  475.         if use_sequence_data:
  476.             st_frame, ed_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0], \
  477.             self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[1]
  478.             self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0] = min(-4,
  479.                                                                     st_frame)  # at least we use 5 frames for generating gt database to support various sequence configs (<= 5 frames)
  480.             st_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0]
  481.             database_save_path = save_path / ('%s_gt_database_%s_sampled_%d_multiframe_%s_to_%s' % (
  482.             processed_data_tag, split, sampled_interval, st_frame, ed_frame))
  483.             db_info_save_path = save_path / ('%s_waymo_dbinfos_%s_sampled_%d_multiframe_%s_to_%s.pkl' % (
  484.             processed_data_tag, split, sampled_interval, st_frame, ed_frame))
  485.             db_data_save_path = save_path / ('%s_gt_database_%s_sampled_%d_multiframe_%s_to_%s_global.npy' % (
  486.             processed_data_tag, split, sampled_interval, st_frame, ed_frame))
  487.         else:
  488.             database_save_path = save_path / (
  489.                         '%s_gt_database_%s_sampled_%d' % (processed_data_tag, split, sampled_interval))
  490.             db_info_save_path = save_path / (
  491.                         '%s_waymo_dbinfos_%s_sampled_%d.pkl' % (processed_data_tag, split, sampled_interval))
  492.             db_data_save_path = save_path / (
  493.                         '%s_gt_database_%s_sampled_%d_global.npy' % (processed_data_tag, split, sampled_interval))
  494.  
  495.         database_save_path.mkdir(parents=True, exist_ok=True)
  496.         all_db_infos = {}
  497.         with open(info_path, 'rb') as f:
  498.             infos = pickle.load(f)
  499.  
  500.         point_offset_cnt = 0
  501.         stacked_gt_points = []
  502.         for k in tqdm(range(0, len(infos), sampled_interval)):
  503.             # print('gt_database sample: %d/%d' % (k + 1, len(infos)))
  504.             info = infos[k]
  505.  
  506.             pc_info = info['point_cloud']
  507.             sequence_name = pc_info['lidar_sequence']
  508.             sample_idx = pc_info['sample_idx']
  509.             points = self.get_lidar(sequence_name, sample_idx)
  510.  
  511.             if use_sequence_data:
  512.                 points, num_points_all, sample_idx_pre_list, _, _, _, _ = self.get_sequence_data(
  513.                     info, points, sequence_name, sample_idx, self.dataset_cfg.SEQUENCE_CONFIG
  514.                 )
  515.  
  516.             annos = info['annos']
  517.             names = annos['name']
  518.             difficulty = annos['difficulty']
  519.             gt_boxes = annos['gt_boxes_lidar']
  520.  
  521.             if k % 4 != 0 and len(names) > 0:
  522.                 mask = (names == 'Vehicle')
  523.                 names = names[~mask]
  524.                 difficulty = difficulty[~mask]
  525.                 gt_boxes = gt_boxes[~mask]
  526.  
  527.             if k % 2 != 0 and len(names) > 0:
  528.                 mask = (names == 'Pedestrian')
  529.                 names = names[~mask]
  530.                 difficulty = difficulty[~mask]
  531.                 gt_boxes = gt_boxes[~mask]
  532.  
  533.             num_obj = gt_boxes.shape[0]
  534.             if num_obj == 0:
  535.                 continue
  536.  
  537.             box_idxs_of_pts = roiaware_pool3d_utils.points_in_boxes_gpu(
  538.                 torch.from_numpy(points[:, 0:3]).unsqueeze(dim=0).float().cuda(),
  539.                 torch.from_numpy(gt_boxes[:, 0:7]).unsqueeze(dim=0).float().cuda()
  540.             ).long().squeeze(dim=0).cpu().numpy()
  541.  
  542.             for i in range(num_obj):
  543.                 filename = '%s_%04d_%s_%d.bin' % (sequence_name, sample_idx, names[i], i)
  544.                 filepath = database_save_path / filename
  545.                 gt_points = points[box_idxs_of_pts == i]
  546.                 gt_points[:, :3] -= gt_boxes[i, :3]
  547.  
  548.                 if (used_classes is None) or names[i] in used_classes:
  549.                     gt_points = gt_points.astype(np.float32)
  550.                     assert gt_points.dtype == np.float32
  551.                     with open(filepath, 'w') as f:
  552.                         gt_points.tofile(f)
  553.  
  554.                     db_path = str(filepath.relative_to(self.root_path))  # gt_database/xxxxx.bin
  555.                     db_info = {'name': names[i], 'path': db_path, 'sequence_name': sequence_name,
  556.                                'sample_idx': sample_idx, 'gt_idx': i, 'box3d_lidar': gt_boxes[i],
  557.                                'num_points_in_gt': gt_points.shape[0], 'difficulty': difficulty[i]}
  558.  
  559.                     # it will be used if you choose to use shared memory for gt sampling
  560.                     stacked_gt_points.append(gt_points)
  561.                     db_info['global_data_offset'] = [point_offset_cnt, point_offset_cnt + gt_points.shape[0]]
  562.                     point_offset_cnt += gt_points.shape[0]
  563.  
  564.                     if names[i] in all_db_infos:
  565.                         all_db_infos[names[i]].append(db_info)
  566.                     else:
  567.                         all_db_infos[names[i]] = [db_info]
  568.         for k, v in all_db_infos.items():
  569.             print('Database %s: %d' % (k, len(v)))
  570.  
  571.         with open(db_info_save_path, 'wb') as f:
  572.             pickle.dump(all_db_infos, f)
  573.  
  574.         # it will be used if you choose to use shared memory for gt sampling
  575.         stacked_gt_points = np.concatenate(stacked_gt_points, axis=0)
  576.         np.save(db_data_save_path, stacked_gt_points)
  577.  
  578.     def create_gt_database_of_single_scene(self, info_with_idx, database_save_path=None, use_sequence_data=False,
  579.                                            used_classes=None,
  580.                                            total_samples=0, use_cuda=False, crop_gt_with_tail=False):
  581.         info, info_idx = info_with_idx
  582.         print('gt_database sample: %d/%d' % (info_idx, total_samples))
  583.  
  584.         all_db_infos = {}
  585.         pc_info = info['point_cloud']
  586.         sequence_name = pc_info['lidar_sequence']
  587.         sample_idx = pc_info['sample_idx']
  588.         points = self.get_lidar(sequence_name, sample_idx)
  589.  
  590.         if use_sequence_data:
  591.             points, num_points_all, sample_idx_pre_list, _, _, _, _ = self.get_sequence_data(
  592.                 info, points, sequence_name, sample_idx, self.dataset_cfg.SEQUENCE_CONFIG
  593.             )
  594.  
  595.         annos = info['annos']
  596.         names = annos['name']
  597.         difficulty = annos['difficulty']
  598.         gt_boxes = annos['gt_boxes_lidar']
  599.  
  600.         if info_idx % 4 != 0 and len(names) > 0:
  601.             mask = (names == 'Vehicle')
  602.             names = names[~mask]
  603.             difficulty = difficulty[~mask]
  604.             gt_boxes = gt_boxes[~mask]
  605.  
  606.         if info_idx % 2 != 0 and len(names) > 0:
  607.             mask = (names == 'Pedestrian')
  608.             names = names[~mask]
  609.             difficulty = difficulty[~mask]
  610.             gt_boxes = gt_boxes[~mask]
  611.  
  612.         num_obj = gt_boxes.shape[0]
  613.         if num_obj == 0:
  614.             return {}
  615.  
  616.         if use_sequence_data and crop_gt_with_tail:
  617.             assert gt_boxes.shape[1] == 9
  618.             speed = gt_boxes[:, 7:9]
  619.             sequence_cfg = self.dataset_cfg.SEQUENCE_CONFIG
  620.             assert sequence_cfg.SAMPLE_OFFSET[1] == 0
  621.             assert sequence_cfg.SAMPLE_OFFSET[0] < 0
  622.             num_frames = sequence_cfg.SAMPLE_OFFSET[1] - sequence_cfg.SAMPLE_OFFSET[0] + 1
  623.             assert num_frames > 1
  624.             latest_center = gt_boxes[:, 0:2]
  625.             oldest_center = latest_center - speed * (num_frames - 1) * 0.1
  626.             new_center = (latest_center + oldest_center) * 0.5
  627.             new_length = gt_boxes[:, 3] + np.linalg.norm(latest_center - oldest_center, axis=-1)
  628.             gt_boxes_crop = gt_boxes.copy()
  629.             gt_boxes_crop[:, 0:2] = new_center
  630.             gt_boxes_crop[:, 3] = new_length
  631.  
  632.         else:
  633.             gt_boxes_crop = gt_boxes
  634.  
  635.         if use_cuda:
  636.             box_idxs_of_pts = roiaware_pool3d_utils.points_in_boxes_gpu(
  637.                 torch.from_numpy(points[:, 0:3]).unsqueeze(dim=0).float().cuda(),
  638.                 torch.from_numpy(gt_boxes_crop[:, 0:7]).unsqueeze(dim=0).float().cuda()
  639.             ).long().squeeze(dim=0).cpu().numpy()
  640.         else:
  641.             box_point_mask = roiaware_pool3d_utils.points_in_boxes_cpu(
  642.                 torch.from_numpy(points[:, 0:3]).float(),
  643.                 torch.from_numpy(gt_boxes_crop[:, 0:7]).float()
  644.             ).long().numpy()  # (num_boxes, num_points)
  645.  
  646.         for i in range(num_obj):
  647.             filename = '%s_%04d_%s_%d.bin' % (sequence_name, sample_idx, names[i], i)
  648.             filepath = database_save_path / filename
  649.             if use_cuda:
  650.                 gt_points = points[box_idxs_of_pts == i]
  651.             else:
  652.                 gt_points = points[box_point_mask[i] > 0]
  653.  
  654.             gt_points[:, :3] -= gt_boxes[i, :3]
  655.  
  656.             if (used_classes is None) or names[i] in used_classes:
  657.                 gt_points = gt_points.astype(np.float32)
  658.                 assert gt_points.dtype == np.float32
  659.                 with open(filepath, 'w') as f:
  660.                     gt_points.tofile(f)
  661.  
  662.                 db_path = str(filepath.relative_to(self.root_path))  # gt_database/xxxxx.bin
  663.                 db_info = {'name': names[i], 'path': db_path, 'sequence_name': sequence_name,
  664.                            'sample_idx': sample_idx, 'gt_idx': i, 'box3d_lidar': gt_boxes[i],
  665.                            'num_points_in_gt': gt_points.shape[0], 'difficulty': difficulty[i],
  666.                            'box3d_crop': gt_boxes_crop[i]}
  667.  
  668.                 if names[i] in all_db_infos:
  669.                     all_db_infos[names[i]].append(db_info)
  670.                 else:
  671.                     all_db_infos[names[i]] = [db_info]
  672.         return all_db_infos
  673.  
  674.     def create_groundtruth_database_parallel(self, info_path, save_path, used_classes=None, split='train',
  675.                                              sampled_interval=10,
  676.                                              processed_data_tag=None, num_workers=16, crop_gt_with_tail=False):
  677.         use_sequence_data = self.dataset_cfg.get('SEQUENCE_CONFIG',
  678.                                                  None) is not None and self.dataset_cfg.SEQUENCE_CONFIG.ENABLED
  679.         if use_sequence_data:
  680.             st_frame, ed_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0], \
  681.             self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[1]
  682.             self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0] = min(-4,
  683.                                                                     st_frame)  # at least we use 5 frames for generating gt database to support various sequence configs (<= 5 frames)
  684.             st_frame = self.dataset_cfg.SEQUENCE_CONFIG.SAMPLE_OFFSET[0]
  685.             database_save_path = save_path / ('%s_gt_database_%s_sampled_%d_multiframe_%s_to_%s_%sparallel' % (
  686.             processed_data_tag, split, sampled_interval, st_frame, ed_frame, 'tail_' if crop_gt_with_tail else ''))
  687.             db_info_save_path = save_path / ('%s_waymo_dbinfos_%s_sampled_%d_multiframe_%s_to_%s_%sparallel.pkl' % (
  688.             processed_data_tag, split, sampled_interval, st_frame, ed_frame, 'tail_' if crop_gt_with_tail else ''))
  689.         else:
  690.             database_save_path = save_path / (
  691.                         '%s_gt_database_%s_sampled_%d_parallel' % (processed_data_tag, split, sampled_interval))
  692.             db_info_save_path = save_path / (
  693.                         '%s_waymo_dbinfos_%s_sampled_%d_parallel.pkl' % (processed_data_tag, split, sampled_interval))
  694.  
  695.         database_save_path.mkdir(parents=True, exist_ok=True)
  696.  
  697.         with open(info_path, 'rb') as f:
  698.             infos = pickle.load(f)
  699.  
  700.         print(f'Number workers: {num_workers}')
  701.         create_gt_database_of_single_scene = partial(
  702.             self.create_gt_database_of_single_scene,
  703.             use_sequence_data=use_sequence_data, database_save_path=database_save_path,
  704.             used_classes=used_classes, total_samples=len(infos), use_cuda=False,
  705.             crop_gt_with_tail=crop_gt_with_tail
  706.         )
  707.         # create_gt_database_of_single_scene((infos[300], 0))
  708.         with multiprocessing.Pool(num_workers) as p:
  709.             all_db_infos_list = list(p.map(create_gt_database_of_single_scene, zip(infos, np.arange(len(infos)))))
  710.  
  711.         all_db_infos = {}
  712.  
  713.         for cur_db_infos in all_db_infos_list:
  714.             for key, val in cur_db_infos.items():
  715.                 if key not in all_db_infos:
  716.                     all_db_infos[key] = val
  717.                 else:
  718.                     all_db_infos[key].extend(val)
  719.  
  720.         for k, v in all_db_infos.items():
  721.             print('Database %s: %d' % (k, len(v)))
  722.  
  723.         with open(db_info_save_path, 'wb') as f:
  724.             pickle.dump(all_db_infos, f)
  725.  
  726.  
  727. def create_waymo_infos(dataset_cfg, class_names, data_path, save_path,
  728.                        raw_data_tag='raw_data', processed_data_tag='waymo_processed_data',
  729.                        workers=min(16, multiprocessing.cpu_count()), update_info_only=False):
  730.     dataset = WaymoDataset(
  731.         dataset_cfg=dataset_cfg, class_names=class_names, root_path=data_path,
  732.         training=False, logger=common_utils.create_logger()
  733.     )
  734.     train_split, val_split = 'train', 'val'
  735.  
  736.     train_filename = save_path / ('%s_infos_%s.pkl' % (processed_data_tag, train_split))
  737.     val_filename = save_path / ('%s_infos_%s.pkl' % (processed_data_tag, val_split))
  738.  
  739.     os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
  740.     print('---------------Start to generate data infos---------------')
  741.  
  742.     dataset.set_split(train_split)
  743.     waymo_infos_train = dataset.get_infos(
  744.         raw_data_path=data_path / raw_data_tag,
  745.         save_path=save_path / processed_data_tag, num_workers=workers, has_label=True,
  746.         sampled_interval=1, update_info_only=update_info_only
  747.     )
  748.     with open(train_filename, 'wb') as f:
  749.         pickle.dump(waymo_infos_train, f)
  750.     print('----------------Waymo info train file is saved to %s----------------' % train_filename)
  751.  
  752.     dataset.set_split(val_split)
  753.     waymo_infos_val = dataset.get_infos(
  754.         raw_data_path=data_path / raw_data_tag,
  755.         save_path=save_path / processed_data_tag, num_workers=workers, has_label=True,
  756.         sampled_interval=1, update_info_only=update_info_only
  757.     )
  758.     with open(val_filename, 'wb') as f:
  759.         pickle.dump(waymo_infos_val, f)
  760.     print('----------------Waymo info val file is saved to %s----------------' % val_filename)
  761.  
  762.     if update_info_only:
  763.         return
  764.  
  765.     print('---------------Start create groundtruth database for data augmentation---------------')
  766.     os.environ["CUDA_VISIBLE_DEVICES"] = "0"
  767.     dataset.set_split(train_split)
  768.     dataset.create_groundtruth_database(
  769.         info_path=train_filename, save_path=save_path, split='train', sampled_interval=1,
  770.         used_classes=['Vehicle', 'Pedestrian', 'Cyclist'], processed_data_tag=processed_data_tag
  771.     )
  772.     print('---------------Data preparation Done---------------')
  773.  
  774.  
  775. def create_waymo_gt_database(
  776.         dataset_cfg, class_names, data_path, save_path, processed_data_tag='waymo_processed_data',
  777.         workers=min(16, multiprocessing.cpu_count()), use_parallel=False, crop_gt_with_tail=False):
  778.     dataset = WaymoDataset(
  779.         dataset_cfg=dataset_cfg, class_names=class_names, root_path=data_path,
  780.         training=False, logger=common_utils.create_logger()
  781.     )
  782.     train_split = 'train'
  783.     train_filename = save_path / ('%s_infos_%s.pkl' % (processed_data_tag, train_split))
  784.  
  785.     print('---------------Start create groundtruth database for data augmentation---------------')
  786.     dataset.set_split(train_split)
  787.     # print("train_split:")
  788.     # print(train_split)
  789.     if use_parallel:
  790.         dataset.create_groundtruth_database_parallel(
  791.             info_path=train_filename, save_path=save_path, split='train', sampled_interval=1,
  792.             used_classes=['Vehicle', 'Pedestrian', 'Cyclist'], processed_data_tag=processed_data_tag,
  793.             num_workers=workers, crop_gt_with_tail=crop_gt_with_tail
  794.         )
  795.     else:
  796.         dataset.create_groundtruth_database(
  797.             info_path=train_filename, save_path=save_path, split='train', sampled_interval=1,
  798.             used_classes=['Vehicle', 'Pedestrian', 'Cyclist'], processed_data_tag=processed_data_tag
  799.         )
  800.     print('---------------Data preparation Done---------------')
  801.  
  802.  
  803. if __name__ == '__main__':
  804.     import argparse
  805.     import yaml
  806.     from easydict import EasyDict
  807.  
  808.     parser = argparse.ArgumentParser(description='arg parser')
  809.     parser.add_argument('--cfg_file', type=str, default=None, help='specify the config of dataset')
  810.     parser.add_argument('--func', type=str, default='create_waymo_infos', help='')
  811.     parser.add_argument('--processed_data_tag', type=str, default='waymo_processed_data_v0_5_0', help='')
  812.     parser.add_argument('--update_info_only', action='store_true', default=False, help='')
  813.     parser.add_argument('--use_parallel', action='store_true', default=False, help='')
  814.     parser.add_argument('--wo_crop_gt_with_tail', action='store_true', default=False, help='')
  815.     parser.add_argument('--data_path', default=None, help='')
  816.  
  817.     args = parser.parse_args()
  818.     if args.data_path is not None:
  819.         ROOT_DIR = (Path(args.data_path)).resolve()
  820.     else:
  821.         ROOT_DIR = (Path(__file__).resolve().parent / '../../../').resolve() / 'data' / 'waymo'
  822.     # ROOT_DIR = (Path(self.dataset_cfg.DATA_PATH)).resolve()
  823.     if args.func == 'create_waymo_infos':
  824.         try:
  825.             yaml_config = yaml.safe_load(open(args.cfg_file), Loader=yaml.FullLoader)
  826.         except:
  827.             yaml_config = yaml.safe_load(open(args.cfg_file))
  828.         dataset_cfg = EasyDict(yaml_config)
  829.         dataset_cfg.PROCESSED_DATA_TAG = args.processed_data_tag
  830.         create_waymo_infos(
  831.             dataset_cfg=dataset_cfg,
  832.             class_names=['Vehicle', 'Pedestrian', 'Cyclist'],
  833.             data_path=ROOT_DIR,
  834.             save_path=ROOT_DIR,
  835.             raw_data_tag='raw_data',
  836.             processed_data_tag=args.processed_data_tag,
  837.             update_info_only=args.update_info_only
  838.         )
  839.     elif args.func == 'create_waymo_gt_database':
  840.         try:
  841.             yaml_config = yaml.safe_load(open(args.cfg_file), Loader=yaml.FullLoader)
  842.         except:
  843.             yaml_config = yaml.safe_load(open(args.cfg_file))
  844.         dataset_cfg = EasyDict(yaml_config)
  845.         dataset_cfg.PROCESSED_DATA_TAG = args.processed_data_tag
  846.         create_waymo_gt_database(
  847.             dataset_cfg=dataset_cfg,
  848.             class_names=['Vehicle', 'Pedestrian', 'Cyclist'],
  849.             data_path=ROOT_DIR,
  850.             save_path=ROOT_DIR,
  851.             processed_data_tag=args.processed_data_tag,
  852.             use_parallel=args.use_parallel,
  853.             crop_gt_with_tail=not args.wo_crop_gt_with_tail
  854.         )
  855.     else:
  856.         raise NotImplementedError

 /OpenPCDet-master/pcdet/datasets/waymo/waymo_utils.py:

  1. # OpenPCDet PyTorch Dataloader and Evaluation Tools for Waymo Open Dataset
  2. # Reference https://github.com/open-mmlab/OpenPCDet
  3. # Written by Shaoshuai Shi, Chaoxu Guo
  4. # All Rights Reserved 2019-2020.
  5.  
  6.  
  7. import os
  8. import shutil
  9. import pickle
  10. import numpy as np
  11. from ...utils import common_utils
  12. import tensorflow as tf
  13. from waymo_open_dataset.utils import frame_utils, transform_utils, range_image_utils
  14. from waymo_open_dataset import dataset_pb2
  15.  
  16. try:
  17.     tf.enable_eager_execution()
  18. except:
  19.     pass
  20.  
  21. WAYMO_CLASSES = ['unknown', 'Vehicle', 'Pedestrian', 'Sign', 'Cyclist']
  22.  
  23.  
  24. def generate_labels(frame, pose):
  25.     obj_name, difficulty, dimensions, locations, heading_angles = [], [], [], [], []
  26.     tracking_difficulty, speeds, accelerations, obj_ids = [], [], [], []
  27.     num_points_in_gt = []
  28.     laser_labels = frame.laser_labels
  29.  
  30.     for i in range(len(laser_labels)):
  31.         box = laser_labels[i].box
  32.         class_ind = laser_labels[i].type
  33.         loc = [box.center_x, box.center_y, box.center_z]
  34.         heading_angles.append(box.heading)
  35.         obj_name.append(WAYMO_CLASSES[class_ind])
  36.         difficulty.append(laser_labels[i].detection_difficulty_level)
  37.         tracking_difficulty.append(laser_labels[i].tracking_difficulty_level)
  38.         dimensions.append([box.length, box.width, box.height])  # lwh in unified coordinate of OpenPCDet
  39.         locations.append(loc)
  40.         obj_ids.append(laser_labels[i].id)
  41.         num_points_in_gt.append(laser_labels[i].num_lidar_points_in_box)
  42.         speeds.append([laser_labels[i].metadata.speed_x, laser_labels[i].metadata.speed_y])
  43.         accelerations.append([laser_labels[i].metadata.accel_x, laser_labels[i].metadata.accel_y])
  44.  
  45.     annotations = {}
  46.     annotations['name'] = np.array(obj_name)
  47.     annotations['difficulty'] = np.array(difficulty)
  48.     annotations['dimensions'] = np.array(dimensions)
  49.     annotations['location'] = np.array(locations)
  50.     annotations['heading_angles'] = np.array(heading_angles)
  51.  
  52.     annotations['obj_ids'] = np.array(obj_ids)
  53.     annotations['tracking_difficulty'] = np.array(tracking_difficulty)
  54.     annotations['num_points_in_gt'] = np.array(num_points_in_gt)
  55.     annotations['speed_global'] = np.array(speeds)
  56.     annotations['accel_global'] = np.array(accelerations)
  57.  
  58.     annotations = common_utils.drop_info_with_name(annotations, name='unknown')
  59.     if annotations['name'].__len__() > 0:
  60.         global_speed = np.pad(annotations['speed_global'], ((0, 0), (0, 1)), mode='constant', constant_values=0)  # (N, 3)
  61.         speed = np.dot(global_speed, np.linalg.inv(pose[:3, :3].T))
  62.         speed = speed[:, :2]
  63.         
  64.         gt_boxes_lidar = np.concatenate([
  65.             annotations['location'], annotations['dimensions'], annotations['heading_angles'][..., np.newaxis], speed],
  66.             axis=1
  67.         )
  68.     else:
  69.         gt_boxes_lidar = np.zeros((0, 9))
  70.     annotations['gt_boxes_lidar'] = gt_boxes_lidar
  71.     return annotations
  72.  
  73.  
  74. def convert_range_image_to_point_cloud(frame, range_images, camera_projections, range_image_top_pose, ri_index=(0, 1)):
  75.     """
  76.     Modified from the codes of Waymo Open Dataset.
  77.     Convert range images to point cloud.
  78.     Args:
  79.         frame: open dataset frame
  80.         range_images: A dict of {laser_name, [range_image_first_return, range_image_second_return]}.
  81.         camera_projections: A dict of {laser_name,
  82.             [camera_projection_from_first_return, camera_projection_from_second_return]}.
  83.         range_image_top_pose: range image pixel pose for top lidar.
  84.         ri_index: 0 for the first return, 1 for the second return.
  86.     Returns:
  87.         points: {[N, 3]} list of 3d lidar points of length 5 (number of lidars).
  88.         cp_points: {[N, 6]} list of camera projections of length 5 (number of lidars).
  89.     """
  90.     calibrations = sorted(frame.context.laser_calibrations, key=lambda c: c.name)
  91.     points = []
  92.     cp_points = []
  93.     points_NLZ = []
  94.     points_intensity = []
  95.     points_elongation = []
  96.  
  97.     frame_pose = tf.convert_to_tensor(np.reshape(np.array(frame.pose.transform), [4, 4]))
  98.     # [H, W, 6]
  99.     range_image_top_pose_tensor = tf.reshape(
  100.         tf.convert_to_tensor(range_image_top_pose.data), range_image_top_pose.shape.dims
  101.     )
  102.     # [H, W, 3, 3]
  103.     range_image_top_pose_tensor_rotation = transform_utils.get_rotation_matrix(
  104.         range_image_top_pose_tensor[..., 0], range_image_top_pose_tensor[..., 1],
  105.         range_image_top_pose_tensor[..., 2])
  106.     range_image_top_pose_tensor_translation = range_image_top_pose_tensor[..., 3:]
  107.     range_image_top_pose_tensor = transform_utils.get_transform(
  108.         range_image_top_pose_tensor_rotation,
  109.         range_image_top_pose_tensor_translation)
  110.  
  111.     for c in calibrations:
  112.         points_single, cp_points_single, points_NLZ_single, points_intensity_single, points_elongation_single \
  113.             = [], [], [], [], []
  114.         for cur_ri_index in ri_index:
  115.             range_image = range_images[c.name][cur_ri_index]
  116.             if len(c.beam_inclinations) == 0:  # pylint: disable=g-explicit-length-test
  117.                 beam_inclinations = range_image_utils.compute_inclination(
  118.                     tf.constant([c.beam_inclination_min, c.beam_inclination_max]),
  119.                     height=range_image.shape.dims[0])
  120.             else:
  121.                 beam_inclinations = tf.constant(c.beam_inclinations)
  122.  
  123.             beam_inclinations = tf.reverse(beam_inclinations, axis=[-1])
  124.             extrinsic = np.reshape(np.array(c.extrinsic.transform), [4, 4])
  125.  
  126.             range_image_tensor = tf.reshape(
  127.                 tf.convert_to_tensor(range_image.data), range_image.shape.dims)
  128.             pixel_pose_local = None
  129.             frame_pose_local = None
  130.             if c.name == dataset_pb2.LaserName.TOP:
  131.                 pixel_pose_local = range_image_top_pose_tensor
  132.                 pixel_pose_local = tf.expand_dims(pixel_pose_local, axis=0)
  133.                 frame_pose_local = tf.expand_dims(frame_pose, axis=0)
  134.             range_image_mask = range_image_tensor[..., 0] > 0
  135.             range_image_NLZ = range_image_tensor[..., 3]
  136.             range_image_intensity = range_image_tensor[..., 1]
  137.             range_image_elongation = range_image_tensor[..., 2]
  138.             range_image_cartesian = range_image_utils.extract_point_cloud_from_range_image(
  139.                 tf.expand_dims(range_image_tensor[..., 0], axis=0),
  140.                 tf.expand_dims(extrinsic, axis=0),
  141.                 tf.expand_dims(tf.convert_to_tensor(beam_inclinations), axis=0),
  142.                 pixel_pose=pixel_pose_local,
  143.                 frame_pose=frame_pose_local)
  144.  
  145.             range_image_cartesian = tf.squeeze(range_image_cartesian, axis=0)
  146.             points_tensor = tf.gather_nd(range_image_cartesian,
  147.                                          tf.where(range_image_mask))
  148.             points_NLZ_tensor = tf.gather_nd(range_image_NLZ, tf.compat.v1.where(range_image_mask))
  149.             points_intensity_tensor = tf.gather_nd(range_image_intensity, tf.compat.v1.where(range_image_mask))
  150.             points_elongation_tensor = tf.gather_nd(range_image_elongation, tf.compat.v1.where(range_image_mask))
  151.             cp = camera_projections[c.name][0]
  152.             cp_tensor = tf.reshape(tf.convert_to_tensor(cp.data), cp.shape.dims)
  153.             cp_points_tensor = tf.gather_nd(cp_tensor, tf.where(range_image_mask))
  154.  
  155.             points_single.append(points_tensor.numpy())
  156.             cp_points_single.append(cp_points_tensor.numpy())
  157.             points_NLZ_single.append(points_NLZ_tensor.numpy())
  158.             points_intensity_single.append(points_intensity_tensor.numpy())
  159.             points_elongation_single.append(points_elongation_tensor.numpy())
  160.  
  161.         points.append(np.concatenate(points_single, axis=0))
  162.         cp_points.append(np.concatenate(cp_points_single, axis=0))
  163.         points_NLZ.append(np.concatenate(points_NLZ_single, axis=0))
  164.         points_intensity.append(np.concatenate(points_intensity_single, axis=0))
  165.         points_elongation.append(np.concatenate(points_elongation_single, axis=0))
  166.  
  167.     return points, cp_points, points_NLZ, points_intensity, points_elongation
  168.  
  169.  
  170. def save_lidar_points(frame, cur_save_path, use_two_returns=True):
  171.     ret_outputs = frame_utils.parse_range_image_and_camera_projection(frame)
  172.     if len(ret_outputs) == 4:
  173.         range_images, camera_projections, seg_labels, range_image_top_pose = ret_outputs
  174.     else:
  175.         assert len(ret_outputs) == 3
  176.         range_images, camera_projections, range_image_top_pose = ret_outputs
  177.  
  178.     points, cp_points, points_in_NLZ_flag, points_intensity, points_elongation = convert_range_image_to_point_cloud(
  179.         frame, range_images, camera_projections, range_image_top_pose, ri_index=(0, 1) if use_two_returns else (0,)
  180.     )
  181.  
  182.     # 3d points in vehicle frame.
  183.     points_all = np.concatenate(points, axis=0)
  184.     points_in_NLZ_flag = np.concatenate(points_in_NLZ_flag, axis=0).reshape(-1, 1)
  185.     points_intensity = np.concatenate(points_intensity, axis=0).reshape(-1, 1)
  186.     points_elongation = np.concatenate(points_elongation, axis=0).reshape(-1, 1)
  187.  
  188.     num_points_of_each_lidar = [point.shape[0] for point in points]
  189.     save_points = np.concatenate([
  190.         points_all, points_intensity, points_elongation, points_in_NLZ_flag
  191.     ], axis=-1).astype(np.float32)
  192.  
  193.     np.save(cur_save_path, save_points)
  194.     # print('saving to ', cur_save_path)
  195.     return num_points_of_each_lidar
  196.  
  197.  
  198. def process_single_sequence(sequence_file, save_path, sampled_interval, has_label=True, use_two_returns=True, update_info_only=False):
  199.     sequence_name = os.path.splitext(os.path.basename(sequence_file))[0]
  200.  
  201.     # print('Load record (sampled_interval=%d): %s' % (sampled_interval, sequence_name))
  202.     if not sequence_file.exists():
  203.         print('NotFoundError: %s' % sequence_file)
  204.         return []
  205.  
  206.     dataset = tf.data.TFRecordDataset(str(sequence_file), compression_type='')
  207.     cur_save_dir = save_path / sequence_name
  208.     cur_save_dir.mkdir(parents=True, exist_ok=True)
  209.     pkl_file = cur_save_dir / ('%s.pkl' % sequence_name)
  210.  
  211.     sequence_infos = []
  212.     if pkl_file.exists():
  213.         sequence_infos = pickle.load(open(pkl_file, 'rb'))
  214.         sequence_infos_old = None
  215.         if not update_info_only:
  216.             print('Skip sequence since it has been processed before: %s' % pkl_file)
  217.  
  218.             return sequence_infos
  219.         else:
  220.             sequence_infos_old = sequence_infos
  221.             sequence_infos = []
  222.         # shutil.move(pkl_file, pkl_file + '/1')
  223.     print("##########################sequence_file#############################")
  224.     print(sequence_file)
  225.     for cnt, data in enumerate(dataset):
  226.         if cnt % sampled_interval != 0:
  227.             continue
  228.         # print(sequence_name, cnt)
  229.         frame = dataset_pb2.Frame()
  230.         frame.ParseFromString(bytearray(data.numpy()))
  231.  
  232.         info = {}
  233.         pc_info = {'num_features': 5, 'lidar_sequence': sequence_name, 'sample_idx': cnt}
  234.         info['point_cloud'] = pc_info
  235.  
  236.         info['frame_id'] = sequence_name + ('_%03d' % cnt)
  237.         info['metadata'] = {
  238.             'context_name': frame.context.name,
  239.             'timestamp_micros': frame.timestamp_micros
  240.         }
  241.         image_info = {}
  242.         for j in range(5):
  243.             width = frame.context.camera_calibrations[j].width
  244.             height = frame.context.camera_calibrations[j].height
  245.             image_info.update({'image_shape_%d' % j: (height, width)})
  246.         info['image'] = image_info
  247.  
  248.         pose = np.array(frame.pose.transform, dtype=np.float32).reshape(4, 4)
  249.         info['pose'] = pose
  250.  
  251.         if has_label:
  252.             annotations = generate_labels(frame, pose=pose)
  253.             info['annos'] = annotations
  254.  
  255.         if update_info_only and sequence_infos_old is not None:
  256.             assert info['frame_id'] == sequence_infos_old[cnt]['frame_id']
  257.             num_points_of_each_lidar = sequence_infos_old[cnt]['num_points_of_each_lidar']
  258.         else:
  259.             num_points_of_each_lidar = save_lidar_points(
  260.                 frame, cur_save_dir / ('%04d.npy' % cnt), use_two_returns=use_two_returns
  261.             )
  262.         info['num_points_of_each_lidar'] = num_points_of_each_lidar
  263.  
  264.         sequence_infos.append(info)
  265.  
  266.     with open(pkl_file, 'wb') as f:
  267.         pickle.dump(sequence_infos, f)
  268.  
  269.     print('Infos are saved to (sampled_interval=%d): %s' % (sampled_interval, pkl_file))
  270.     return sequence_infos
  271.  
  272.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/325202
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号