diff --git a/OpenPVSG/models/mask2former/mask2former.py b/OpenPVSG/models/mask2former/mask2former.py new file mode 100644 index 0000000000000000000000000000000000000000..39c220dcbdc830c2daa720771500c61a0e5996b5 --- /dev/null +++ b/OpenPVSG/models/mask2former/mask2former.py @@ -0,0 +1,270 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import copy + +import mmcv +import numpy as np +from mmdet.utils import get_root_logger + +from mmdet.core import INSTANCE_OFFSET, bbox2result +from mmdet.core.visualization import imshow_det_bboxes +from mmdet.models.builder import DETECTORS, build_backbone, build_head, build_neck +from mmdet.models.detectors.single_stage import SingleStageDetector + + +@DETECTORS.register_module() +class Mask2FormerCustom(SingleStageDetector): + r"""Implementation of `Per-Pixel Classification is + NOT All You Need for Semantic Segmentation + `_.""" + + async def async_simple_test(self, img, img_metas, **kwargs): + raise NotImplementedError + + def __init__(self, + backbone, + neck=None, + panoptic_head=None, + panoptic_fusion_head=None, + train_cfg=None, + test_cfg=None, + init_cfg=None): + super(SingleStageDetector, self).__init__(init_cfg=init_cfg) + self.backbone = build_backbone(backbone) + if neck is not None: + self.neck = build_neck(neck) + + panoptic_head_ = copy.deepcopy(panoptic_head) + panoptic_head_.update(train_cfg=train_cfg) + panoptic_head_.update(test_cfg=test_cfg) + self.panoptic_head = build_head(panoptic_head_) + + panoptic_fusion_head_ = copy.deepcopy(panoptic_fusion_head) + panoptic_fusion_head_.update(test_cfg=test_cfg) + self.panoptic_fusion_head = build_head(panoptic_fusion_head_) + + self.num_things_classes = self.panoptic_head.num_things_classes + self.num_stuff_classes = self.panoptic_head.num_stuff_classes + self.num_classes = self.panoptic_head.num_classes + + self.train_cfg = train_cfg + self.test_cfg = test_cfg + + # BaseDetector.show_result default for instance segmentation + if self.num_stuff_classes > 0: + self.show_result = self._show_pan_result + + self.logger = get_root_logger() + self.logger.info("[Unified Video Segmentation] Using customized mask2former segmentor.") + + def forward_dummy(self, img, img_metas): + """Used for computing network flops. See + `mmdetection/tools/analysis_tools/get_flops.py` + + Args: + img (Tensor): of shape (N, C, H, W) encoding input images. + Typically these should be mean centered and std scaled. + img_metas (list[Dict]): list of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `mmdet/datasets/pipelines/formatting.py:Collect`. + """ + super(SingleStageDetector, self).forward_train(img, img_metas) + x = self.extract_feat(img) + outs = self.panoptic_head(x, img_metas) + return outs + + def forward_train(self, + img, + img_metas, + gt_bboxes, + gt_labels, + gt_masks, + gt_semantic_seg=None, + gt_bboxes_ignore=None, + **kargs): + """ + Args: + img (Tensor): of shape (N, C, H, W) encoding input images. + Typically these should be mean centered and std scaled. + img_metas (list[Dict]): list of image info dict where each dict + has: 'img_shape', 'scale_factor', 'flip', and may also contain + 'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'. + For details on the values of these keys see + `mmdet/datasets/pipelines/formatting.py:Collect`. + gt_bboxes (list[Tensor]): Ground truth bboxes for each image with + shape (num_gts, 4) in [tl_x, tl_y, br_x, br_y] format. + gt_labels (list[Tensor]): class indices corresponding to each box. + gt_masks (list[BitmapMasks]): true segmentation masks for each box + used if the architecture supports a segmentation task. + gt_semantic_seg (list[tensor]): semantic segmentation mask for + images for panoptic segmentation. + Defaults to None for instance segmentation. + gt_bboxes_ignore (list[Tensor]): specify which bounding + boxes can be ignored when computing the loss. + Defaults to None. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + # add batch_input_shape in img_metas + super(SingleStageDetector, self).forward_train(img, img_metas) + x = self.extract_feat(img) + # print("model input:", "labels:", len(gt_labels[0]), "masks:", len(gt_masks[0])) + losses = self.panoptic_head.forward_train(x, img_metas, gt_bboxes, + gt_labels, gt_masks, + gt_semantic_seg, + gt_bboxes_ignore) + + return losses + + def simple_test(self, imgs, img_metas, **kwargs): + """Test without augmentation. + + Args: + imgs (Tensor): A batch of images. + img_metas (list[dict]): List of image information. + + Returns: + list[dict[str, np.array | tuple[list]] | tuple[list]]: + Semantic segmentation results and panoptic segmentation \ + results of each image for panoptic segmentation, or formatted \ + bbox and mask results of each image for instance segmentation. + + .. code-block:: none + + [ + # panoptic segmentation + { + 'pan_results': np.array, # shape = [h, w] + 'ins_results': tuple[list], + # semantic segmentation results are not supported yet + 'sem_results': np.array + }, + ... + ] + + or + + .. code-block:: none + + [ + # instance segmentation + ( + bboxes, # list[np.array] + masks # list[list[np.array]] + ), + ... + ] + """ + feats = self.extract_feat(imgs) # after backbone + neck + mask_cls_results, mask_pred_results, query_feats= self.panoptic_head.simple_test_with_query( + feats, img_metas, **kwargs) # modify -- use simple_test_with_query to return que_fea with mask! + results = self.panoptic_fusion_head.simple_test_with_query( + mask_cls_results, mask_pred_results, query_feats, img_metas, **kwargs) + # import pdb; pdb.set_trace() + for i in range(len(results)): + if 'pan_results' in results[i]: + results[i]['pan_results'] = results[i]['pan_results'].detach( + ).cpu().numpy() + if 'query_feats' in results[i]: + for idx, query_feat_list in results[i]['query_feats'].items(): + results[i]['query_feats'][idx] = [x.detach().cpu().numpy() for x in query_feat_list] + + if 'ins_results' in results[i]: + labels_per_image, bboxes, mask_pred_binary = results[i][ + 'ins_results'] + bbox_results = bbox2result(bboxes, labels_per_image, + self.num_things_classes) + mask_results = [[] for _ in range(self.num_things_classes)] + for j, label in enumerate(labels_per_image): + mask = mask_pred_binary[j].detach().cpu().numpy() + mask_results[label].append(mask) + results[i]['ins_results'] = bbox_results, mask_results + + # assert 'sem_results' not in results[i], 'segmantic segmentation '\ + # 'results are not supported yet.' + + if self.num_stuff_classes == 0: + results = [res['ins_results'] for res in results] + + return results + + def aug_test(self, imgs, img_metas, **kwargs): + raise NotImplementedError + + def onnx_export(self, img, img_metas): + raise NotImplementedError + + def _show_pan_result(self, + img, + result, + score_thr=0.3, + bbox_color=(72, 101, 241), + text_color=(72, 101, 241), + mask_color=None, + thickness=2, + font_size=13, + win_name='', + show=False, + wait_time=0, + out_file=None): + """Draw `panoptic result` over `img`. + + Args: + img (str or Tensor): The image to be displayed. + result (dict): The results. + + score_thr (float, optional): Minimum score of bboxes to be shown. + Default: 0.3. + bbox_color (str or tuple(int) or :obj:`Color`):Color of bbox lines. + The tuple of color should be in BGR order. Default: 'green'. + text_color (str or tuple(int) or :obj:`Color`):Color of texts. + The tuple of color should be in BGR order. Default: 'green'. + mask_color (None or str or tuple(int) or :obj:`Color`): + Color of masks. The tuple of color should be in BGR order. + Default: None. + thickness (int): Thickness of lines. Default: 2. + font_size (int): Font size of texts. Default: 13. + win_name (str): The window name. Default: ''. + wait_time (float): Value of waitKey param. + Default: 0. + show (bool): Whether to show the image. + Default: False. + out_file (str or None): The filename to write the image. + Default: None. + + Returns: + img (Tensor): Only if not `show` or `out_file`. + """ + img = mmcv.imread(img) + img = img.copy() + pan_results = result['pan_results'] + # keep objects ahead + ids = np.unique(pan_results)[::-1] + legal_indices = ids != self.num_classes # for VOID label + ids = ids[legal_indices] + labels = np.array([id % INSTANCE_OFFSET for id in ids], dtype=np.int64) + segms = (pan_results[None] == ids[:, None, None]) + + # if out_file specified, do not show image in window + if out_file is not None: + show = False + # draw bounding boxes + img = imshow_det_bboxes( + img, + segms=segms, + labels=labels, + class_names=self.CLASSES, + bbox_color=bbox_color, + text_color=text_color, + mask_color=mask_color, + thickness=thickness, + font_size=font_size, + win_name=win_name, + show=show, + wait_time=wait_time, + out_file=out_file) + + if not (show or out_file): + return img diff --git a/OpenPVSG/models/mask2former/mask2former_fusion_head.py b/OpenPVSG/models/mask2former/mask2former_fusion_head.py new file mode 100644 index 0000000000000000000000000000000000000000..0f5a84e0385e6895db9c88f8862bc2a11f471493 --- /dev/null +++ b/OpenPVSG/models/mask2former/mask2former_fusion_head.py @@ -0,0 +1,404 @@ +# Copyright (c) OpenMMLab. All rights reserved. +from collections import defaultdict +from email.policy import default +import torch +import torch.nn.functional as F + +from mmdet.core.evaluation.panoptic_utils import INSTANCE_OFFSET +from mmdet.core.mask import mask2bbox +from mmdet.models.builder import HEADS +from mmdet.models.seg_heads.panoptic_fusion_heads.base_panoptic_fusion_head import BasePanopticFusionHead # add import from absolute path + + +@HEADS.register_module() +class MaskFormerFusionHeadCustom(BasePanopticFusionHead): + + def __init__(self, + num_things_classes=80, + num_stuff_classes=53, + test_cfg=None, + loss_panoptic=None, + init_cfg=None, + **kwargs): + super().__init__(num_things_classes, num_stuff_classes, test_cfg, + loss_panoptic, init_cfg, **kwargs) + + def forward_train(self, **kwargs): + """MaskFormerFusionHead has no training loss.""" + return dict() + + def panoptic_postprocess(self, mask_cls, mask_pred): + """Panoptic segmengation inference. + + Args: + mask_cls (Tensor): Classfication outputs of shape + (num_queries, cls_out_channels) for a image. + Note `cls_out_channels` should includes + background. + mask_pred (Tensor): Mask outputs of shape + (num_queries, h, w) for a image. + + Returns: + Tensor: Panoptic segment result of shape \ + (h, w), each element in Tensor means: \ + ``segment_id = _cls + instance_id * INSTANCE_OFFSET``. + """ + object_mask_thr = self.test_cfg.get('object_mask_thr', 0.8) + iou_thr = self.test_cfg.get('iou_thr', 0.8) + filter_low_score = self.test_cfg.get('filter_low_score', False) + + scores, labels = F.softmax(mask_cls, dim=-1).max(-1) + mask_pred = mask_pred.sigmoid() + + keep = labels.ne(self.num_classes) & (scores > object_mask_thr) + cur_scores = scores[keep] + cur_classes = labels[keep] + cur_masks = mask_pred[keep] + + cur_prob_masks = cur_scores.view(-1, 1, 1) * cur_masks + + h, w = cur_masks.shape[-2:] + panoptic_seg = torch.full((h, w), + self.num_classes, + dtype=torch.int32, + device=cur_masks.device) + if cur_masks.shape[0] == 0: + # We didn't detect any mask :( + pass + else: + cur_mask_ids = cur_prob_masks.argmax(0) + instance_id = 1 + for k in range(cur_classes.shape[0]): + pred_class = int(cur_classes[k].item()) + isthing = pred_class < self.num_things_classes + mask = cur_mask_ids == k + mask_area = mask.sum().item() + original_area = (cur_masks[k] >= 0.5).sum().item() + + if filter_low_score: + mask = mask & (cur_masks[k] >= 0.5) + + if mask_area > 0 and original_area > 0: + if mask_area / original_area < iou_thr: + continue + + if not isthing: + # different stuff regions of same class will be + # merged here, and stuff share the instance_id 0. + panoptic_seg[mask] = pred_class + else: + panoptic_seg[mask] = ( + pred_class + instance_id * INSTANCE_OFFSET) + instance_id += 1 + + return panoptic_seg + + def panoptic_postprocess_with_query(self, mask_cls, mask_pred, query_feats): + """Panoptic segmengation inference. + + Args: + mask_cls (Tensor): Classfication outputs of shape + (num_queries, cls_out_channels) for a image. + Note `cls_out_channels` should includes + background. + mask_pred (Tensor): Mask outputs of shape + (num_queries, h, w) for a image. + + Returns: + Tensor: Panoptic segment result of shape \ + (h, w), each element in Tensor means: \ + ``segment_id = _cls + instance_id * INSTANCE_OFFSET``. + """ + # import pdb; pdb.set_trace() + object_mask_thr = self.test_cfg.get('object_mask_thr', 0.8) + iou_thr = self.test_cfg.get('iou_thr', 0.8) + filter_low_score = self.test_cfg.get('filter_low_score', False) + + scores, labels = F.softmax(mask_cls, dim=-1).max(-1) + mask_pred = mask_pred.sigmoid() + + keep = labels.ne(self.num_classes) & (scores > object_mask_thr) + cur_scores = scores[keep] + cur_classes = labels[keep] + cur_masks = mask_pred[keep] + cur_query_feats = query_feats[keep] # filter query feats + + cur_prob_masks = cur_scores.view(-1, 1, 1) * cur_masks + + h, w = cur_masks.shape[-2:] + panoptic_seg = torch.full((h, w), + self.num_classes, + dtype=torch.int32, + device=cur_masks.device) + query_feat_dict = defaultdict(list) + + if cur_masks.shape[0] == 0: + # We didn't detect any mask :( + pass + else: + cur_mask_ids = cur_prob_masks.argmax(0) + instance_id = 1 + for k in range(cur_classes.shape[0]): + pred_class = int(cur_classes[k].item()) + query_feat_k = cur_query_feats[k] # shape - [1, 256] + isthing = pred_class < self.num_things_classes + mask = cur_mask_ids == k + mask_area = mask.sum().item() + original_area = (cur_masks[k] >= 0.5).sum().item() + + if filter_low_score: + mask = mask & (cur_masks[k] >= 0.5) + + if mask_area > 0 and original_area > 0: + if mask_area / original_area < iou_thr: + continue + + if not isthing: + # different stuff regions of same class will be + # merged here, and stuff share the instance_id 0. + if len(torch.unique(mask)) == 1 and torch.unique(mask).item() == False: + continue # for the case can reach this step but "mask = mask & (cur_masks[k] >= 0.5)" becomes all "False" when filtering low scores! + panoptic_seg[mask] = pred_class + query_feat_dict[pred_class].append(query_feat_k) + else: + if len(torch.unique(mask)) == 1 and torch.unique(mask).item() == False: + continue # for the case can reach this step but "mask = mask & (cur_masks[k] >= 0.5)" becomes all "False" when filtering low scores! + panoptic_seg[mask] = ( + pred_class + instance_id * INSTANCE_OFFSET) + query_feat_dict[pred_class + instance_id * INSTANCE_OFFSET].append(query_feat_k) + instance_id += 1 # update at last!!! + # import pdb; pdb.set_trace() + return panoptic_seg, query_feat_dict + + + def semantic_postprocess(self, mask_cls, mask_pred): + """Semantic segmengation postprocess. + + Args: + mask_cls (Tensor): Classfication outputs of shape + (num_queries, cls_out_channels) for a image. + Note `cls_out_channels` should includes + background. + mask_pred (Tensor): Mask outputs of shape + (num_queries, h, w) for a image. + + Returns: + Tensor: Semantic segment result of shape \ + (cls_out_channels, h, w). + """ + # TODO add semantic segmentation result + raise NotImplementedError + + def instance_postprocess(self, mask_cls, mask_pred): + """Instance segmengation postprocess. + + Args: + mask_cls (Tensor): Classfication outputs of shape + (num_queries, cls_out_channels) for a image. + Note `cls_out_channels` should includes + background. + mask_pred (Tensor): Mask outputs of shape + (num_queries, h, w) for a image. + + Returns: + tuple[Tensor]: Instance segmentation results. + + - labels_per_image (Tensor): Predicted labels,\ + shape (n, ). + - bboxes (Tensor): Bboxes and scores with shape (n, 5) of \ + positive region in binary mask, the last column is scores. + - mask_pred_binary (Tensor): Instance masks of \ + shape (n, h, w). + """ + max_per_image = self.test_cfg.get('max_per_image', 100) + num_queries = mask_cls.shape[0] + # shape (num_queries, num_class) + scores = F.softmax(mask_cls, dim=-1)[:, :-1] + # shape (num_queries * num_class, ) + labels = torch.arange(self.num_classes, device=mask_cls.device).\ + unsqueeze(0).repeat(num_queries, 1).flatten(0, 1) + scores_per_image, top_indices = scores.flatten(0, 1).topk( + max_per_image, sorted=False) + labels_per_image = labels[top_indices] + + query_indices = top_indices // self.num_classes + mask_pred = mask_pred[query_indices] + + # extract things + is_thing = labels_per_image < self.num_things_classes + scores_per_image = scores_per_image[is_thing] + labels_per_image = labels_per_image[is_thing] + mask_pred = mask_pred[is_thing] + + mask_pred_binary = (mask_pred > 0).float() + mask_scores_per_image = (mask_pred.sigmoid() * + mask_pred_binary).flatten(1).sum(1) / ( + mask_pred_binary.flatten(1).sum(1) + 1e-6) + det_scores = scores_per_image * mask_scores_per_image + mask_pred_binary = mask_pred_binary.bool() + bboxes = mask2bbox(mask_pred_binary) + bboxes = torch.cat([bboxes, det_scores[:, None]], dim=-1) + + return labels_per_image, bboxes, mask_pred_binary + + def simple_test(self, + mask_cls_results, + mask_pred_results, + img_metas, + rescale=False, + **kwargs): + """Test segment without test-time aumengtation. + + Only the output of last decoder layers was used. + + Args: + mask_cls_results (Tensor): Mask classification logits, + shape (batch_size, num_queries, cls_out_channels). + Note `cls_out_channels` should includes background. + mask_pred_results (Tensor): Mask logits, shape + (batch_size, num_queries, h, w). + img_metas (list[dict]): List of image information. + rescale (bool, optional): If True, return boxes in + original image space. Default False. + + Returns: + list[dict[str, Tensor | tuple[Tensor]]]: Semantic segmentation \ + results and panoptic segmentation results for each \ + image. + + .. code-block:: none + + [ + { + 'pan_results': Tensor, # shape = [h, w] + 'ins_results': tuple[Tensor], + # semantic segmentation results are not supported yet + 'sem_results': Tensor + }, + ... + ] + """ + panoptic_on = self.test_cfg.get('panoptic_on', True) + semantic_on = self.test_cfg.get('semantic_on', False) + instance_on = self.test_cfg.get('instance_on', False) + assert not semantic_on, 'segmantic segmentation '\ + 'results are not supported yet.' + + results = [] + for mask_cls_result, mask_pred_result, meta in zip( + mask_cls_results, mask_pred_results, img_metas): + # remove padding + img_height, img_width = meta['img_shape'][:2] + mask_pred_result = mask_pred_result[:, :img_height, :img_width] + + if rescale: + # return result in original resolution + ori_height, ori_width = meta['ori_shape'][:2] + mask_pred_result = F.interpolate( + mask_pred_result[:, None], + size=(ori_height, ori_width), + mode='bilinear', + align_corners=False)[:, 0] + + result = dict() + if panoptic_on: + pan_results = self.panoptic_postprocess( + mask_cls_result, mask_pred_result) + result['pan_results'] = pan_results + + if instance_on: + ins_results = self.instance_postprocess( + mask_cls_result, mask_pred_result) + result['ins_results'] = ins_results + + if semantic_on: + sem_results = self.semantic_postprocess( + mask_cls_result, mask_pred_result) + result['sem_results'] = sem_results + + results.append(result) + + return results + + + + def simple_test_with_query(self, + mask_cls_results, + mask_pred_results, + query_feats, # N query feats + img_metas, + rescale=False, + **kwargs): + """Test segment without test-time aumengtation. + + Only the output of last decoder layers was used. + + Args: + mask_cls_results (Tensor): Mask classification logits, + shape (batch_size, num_queries, cls_out_channels). + Note `cls_out_channels` should includes background. + mask_pred_results (Tensor): Mask logits, shape + (batch_size, num_queries, h, w). + img_metas (list[dict]): List of image information. + rescale (bool, optional): If True, return boxes in + original image space. Default False. + + Returns: + list[dict[str, Tensor | tuple[Tensor]]]: Semantic segmentation \ + results and panoptic segmentation results for each \ + image. + + .. code-block:: none + + [ + { + 'pan_results': Tensor, # shape = [h, w] + 'ins_results': tuple[Tensor], + # semantic segmentation results are not supported yet + 'sem_results': Tensor + }, + ... + ] + """ + panoptic_on = self.test_cfg.get('panoptic_on', True) + semantic_on = self.test_cfg.get('semantic_on', False) + instance_on = self.test_cfg.get('instance_on', False) + assert not semantic_on, 'segmantic segmentation '\ + 'results are not supported yet.' + + results = [] + for mask_cls_result, mask_pred_result, query_feat, meta in zip( + mask_cls_results, mask_pred_results, query_feats, img_metas): + # remove padding + img_height, img_width = meta['img_shape'][:2] + mask_pred_result = mask_pred_result[:, :img_height, :img_width] + + if rescale: + # return result in original resolution + ori_height, ori_width = meta['ori_shape'][:2] + mask_pred_result = F.interpolate( + mask_pred_result[:, None], + size=(ori_height, ori_width), + mode='bilinear', + align_corners=False)[:, 0] + + result = dict() + if panoptic_on: + pan_results, query_feat_dict = self.panoptic_postprocess_with_query( + mask_cls_result, mask_pred_result, query_feat) + result['pan_results'] = pan_results + result['query_feats'] = query_feat_dict + + if instance_on: + ins_results = self.instance_postprocess( + mask_cls_result, mask_pred_result) + result['ins_results'] = ins_results + + if semantic_on: + sem_results = self.semantic_postprocess( + mask_cls_result, mask_pred_result) + result['sem_results'] = sem_results + + results.append(result) + + return results diff --git a/OpenPVSG/models/mask2former/mask2former_head.py b/OpenPVSG/models/mask2former/mask2former_head.py new file mode 100644 index 0000000000000000000000000000000000000000..fccd50250c80eec6bc90c0cde1e8fb8474f4fcc6 --- /dev/null +++ b/OpenPVSG/models/mask2former/mask2former_head.py @@ -0,0 +1,681 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import copy + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import Conv2d, build_plugin_layer, caffe2_xavier_init +from mmcv.cnn.bricks.transformer import (build_positional_encoding, + build_transformer_layer_sequence) +from mmcv.ops import point_sample +from mmcv.runner import ModuleList, force_fp32 + +from mmdet.core import build_assigner, build_sampler, reduce_mean, multi_apply +from mmdet.models.utils import get_uncertain_point_coords_with_randomness +from mmdet.models.builder import HEADS, build_loss +from mmdet.models.dense_heads.anchor_free_head import AnchorFreeHead +from mmdet.models.dense_heads.maskformer_head import MaskFormerHead + + +@HEADS.register_module() +class Mask2FormerHeadCustom(MaskFormerHead): + """Implements the Mask2Former head. + + See `Masked-attention Mask Transformer for Universal Image + Segmentation `_ for details. + + Args: + in_channels (list[int]): Number of channels in the input feature map. + feat_channels (int): Number of channels for features. + out_channels (int): Number of channels for output. + num_things_classes (int): Number of things. + num_stuff_classes (int): Number of stuff. + num_queries (int): Number of query in Transformer decoder. + pixel_decoder (:obj:`mmcv.ConfigDict` | dict): Config for pixel + decoder. Defaults to None. + enforce_decoder_input_project (bool, optional): Whether to add + a layer to change the embed_dim of tranformer encoder in + pixel decoder to the embed_dim of transformer decoder. + Defaults to False. + transformer_decoder (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder. Defaults to None. + positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder position encoding. Defaults to None. + loss_cls (:obj:`mmcv.ConfigDict` | dict): Config of the classification + loss. Defaults to None. + loss_mask (:obj:`mmcv.ConfigDict` | dict): Config of the mask loss. + Defaults to None. + loss_dice (:obj:`mmcv.ConfigDict` | dict): Config of the dice loss. + Defaults to None. + train_cfg (:obj:`mmcv.ConfigDict` | dict): Training config of + Mask2Former head. + test_cfg (:obj:`mmcv.ConfigDict` | dict): Testing config of + Mask2Former head. + init_cfg (dict or list[dict], optional): Initialization config dict. + Defaults to None. + """ + + def __init__(self, + in_channels, + feat_channels, + out_channels, + num_things_classes=80, + num_stuff_classes=53, + num_queries=100, + num_transformer_feat_level=3, + pixel_decoder=None, + enforce_decoder_input_project=False, + transformer_decoder=None, + positional_encoding=None, + loss_cls=None, + loss_mask=None, + loss_dice=None, + train_cfg=None, + test_cfg=None, + init_cfg=None, + **kwargs): + super(AnchorFreeHead, self).__init__(init_cfg) + self.num_things_classes = num_things_classes + self.num_stuff_classes = num_stuff_classes + self.num_classes = self.num_things_classes + self.num_stuff_classes + self.num_queries = num_queries + self.num_transformer_feat_level = num_transformer_feat_level + self.num_heads = transformer_decoder.transformerlayers.\ + attn_cfgs.num_heads + self.num_transformer_decoder_layers = transformer_decoder.num_layers + assert pixel_decoder.encoder.transformerlayers.\ + attn_cfgs.num_levels == num_transformer_feat_level + pixel_decoder_ = copy.deepcopy(pixel_decoder) + pixel_decoder_.update( + in_channels=in_channels, + feat_channels=feat_channels, + out_channels=out_channels) + self.pixel_decoder = build_plugin_layer(pixel_decoder_)[1] + self.transformer_decoder = build_transformer_layer_sequence( + transformer_decoder) + self.decoder_embed_dims = self.transformer_decoder.embed_dims + + self.decoder_input_projs = ModuleList() + # from low resolution to high resolution + for _ in range(num_transformer_feat_level): + if (self.decoder_embed_dims != feat_channels + or enforce_decoder_input_project): + self.decoder_input_projs.append( + Conv2d( + feat_channels, self.decoder_embed_dims, kernel_size=1)) + else: + self.decoder_input_projs.append(nn.Identity()) + self.decoder_positional_encoding = build_positional_encoding( + positional_encoding) + self.query_embed = nn.Embedding(self.num_queries, feat_channels) + self.query_feat = nn.Embedding(self.num_queries, feat_channels) + # from low resolution to high resolution + self.level_embed = nn.Embedding(self.num_transformer_feat_level, + feat_channels) + + self.cls_embed = nn.Linear(feat_channels, self.num_classes + 1) + self.mask_embed = nn.Sequential( + nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True), + nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True), + nn.Linear(feat_channels, out_channels)) + + self.test_cfg = test_cfg + self.train_cfg = train_cfg + if train_cfg: + self.assigner = build_assigner(self.train_cfg.assigner) + self.sampler = build_sampler(self.train_cfg.sampler, context=self) + self.num_points = self.train_cfg.get('num_points', 12544) + self.oversample_ratio = self.train_cfg.get('oversample_ratio', 3.0) + self.importance_sample_ratio = self.train_cfg.get( + 'importance_sample_ratio', 0.75) + + self.class_weight = loss_cls.class_weight + self.loss_cls = build_loss(loss_cls) + self.loss_mask = build_loss(loss_mask) + self.loss_dice = build_loss(loss_dice) + + def init_weights(self): + for m in self.decoder_input_projs: + if isinstance(m, Conv2d): + caffe2_xavier_init(m, bias=0) + + self.pixel_decoder.init_weights() + + for p in self.transformer_decoder.parameters(): + if p.dim() > 1: + nn.init.xavier_normal_(p) + + def _get_target_single(self, cls_score, mask_pred, gt_labels, gt_masks, + img_metas): + """Compute classification and mask targets for one image. + + Args: + cls_score (Tensor): Mask score logits from a single decoder layer + for one image. Shape (num_queries, cls_out_channels). + mask_pred (Tensor): Mask logits for a single decoder layer for one + image. Shape (num_queries, h, w). + gt_labels (Tensor): Ground truth class indices for one image with + shape (num_gts, ). + gt_masks (Tensor): Ground truth mask for each image, each with + shape (num_gts, h, w). + img_metas (dict): Image information. + + Returns: + tuple[Tensor]: A tuple containing the following for one image. + + - labels (Tensor): Labels of each image. \ + shape (num_queries, ). + - label_weights (Tensor): Label weights of each image. \ + shape (num_queries, ). + - mask_targets (Tensor): Mask targets of each image. \ + shape (num_queries, h, w). + - mask_weights (Tensor): Mask weights of each image. \ + shape (num_queries, ). + - pos_inds (Tensor): Sampled positive indices for each \ + image. + - neg_inds (Tensor): Sampled negative indices for each \ + image. + """ + + # sample points + num_queries = cls_score.shape[0] + num_gts = gt_labels.shape[0] + + point_coords = torch.rand((1, self.num_points, 2), + device=cls_score.device) + # shape (num_queries, num_points) + mask_points_pred = point_sample( + mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1, + 1)).squeeze(1) + # shape (num_gts, num_points) + gt_points_masks = point_sample( + gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1, + 1)).squeeze(1) + + # assign and sample + assign_result = self.assigner.assign(cls_score, mask_points_pred, + gt_labels, gt_points_masks, + img_metas) + sampling_result = self.sampler.sample(assign_result, mask_pred, + gt_masks) + pos_inds = sampling_result.pos_inds + neg_inds = sampling_result.neg_inds + + # label target (thing or stuff labels) + labels = gt_labels.new_full((num_queries, ), + self.num_classes, + dtype=torch.long) + labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds] + label_weights = gt_labels.new_ones((num_queries, )) + + # mask target + mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds] + mask_weights = mask_pred.new_zeros((num_queries, )) + mask_weights[pos_inds] = 1.0 + + return (labels, label_weights, mask_targets, mask_weights, pos_inds, + neg_inds) + + def loss_single(self, cls_scores, mask_preds, gt_labels_list, + gt_masks_list, img_metas): + """Loss function for outputs from a single decoder layer. + + Args: + cls_scores (Tensor): Mask score logits from a single decoder layer + for all images. Shape (batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + mask_preds (Tensor): Mask logits for a pixel decoder for all + images. Shape (batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image, each with shape (num_gts, ). + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (num_gts, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[Tensor]: Loss components for outputs from a single \ + decoder layer. + """ + num_imgs = cls_scores.size(0) + cls_scores_list = [cls_scores[i] for i in range(num_imgs)] + mask_preds_list = [mask_preds[i] for i in range(num_imgs)] + (labels_list, label_weights_list, mask_targets_list, mask_weights_list, + num_total_pos, + num_total_neg) = self.get_targets(cls_scores_list, mask_preds_list, + gt_labels_list, gt_masks_list, + img_metas) + + # shape (batch_size, num_queries) + labels = torch.stack(labels_list, dim=0) + # shape (batch_size, num_queries) + label_weights = torch.stack(label_weights_list, dim=0) + # shape (num_total_gts, h, w) + mask_targets = torch.cat(mask_targets_list, dim=0) + # shape (batch_size, num_queries) + mask_weights = torch.stack(mask_weights_list, dim=0) + + # classification loss + # shape (batch_size * num_queries, ) + cls_scores = cls_scores.flatten(0, 1) + labels = labels.flatten(0, 1) + label_weights = label_weights.flatten(0, 1) + + class_weight = cls_scores.new_tensor(self.class_weight) + loss_cls = self.loss_cls( + cls_scores, + labels, + label_weights, + avg_factor=class_weight[labels].sum()) + + num_total_masks = reduce_mean(cls_scores.new_tensor([num_total_pos])) + num_total_masks = max(num_total_masks, 1) + + # extract positive ones + # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w) + mask_preds = mask_preds[mask_weights > 0] + + if mask_targets.shape[0] == 0: + # zero match + loss_dice = mask_preds.sum() + loss_mask = mask_preds.sum() + return loss_cls, loss_mask, loss_dice + + with torch.no_grad(): + points_coords = get_uncertain_point_coords_with_randomness( + mask_preds.unsqueeze(1), None, self.num_points, + self.oversample_ratio, self.importance_sample_ratio) + # shape (num_total_gts, h, w) -> (num_total_gts, num_points) + mask_point_targets = point_sample( + mask_targets.unsqueeze(1).float(), points_coords).squeeze(1) + # shape (num_queries, h, w) -> (num_queries, num_points) + mask_point_preds = point_sample( + mask_preds.unsqueeze(1), points_coords).squeeze(1) + + # dice loss + loss_dice = self.loss_dice( + mask_point_preds, mask_point_targets, avg_factor=num_total_masks) + + # mask loss + # shape (num_queries, num_points) -> (num_queries * num_points, ) + mask_point_preds = mask_point_preds.reshape(-1) + # shape (num_total_gts, num_points) -> (num_total_gts * num_points, ) + mask_point_targets = mask_point_targets.reshape(-1) + loss_mask = self.loss_mask( + mask_point_preds, + mask_point_targets, + avg_factor=num_total_masks * self.num_points) + + return loss_cls, loss_mask, loss_dice + + def get_targets(self, cls_scores_list, mask_preds_list, gt_labels_list, + gt_masks_list, img_metas): + """Compute classification and mask targets for all images for a decoder + layer. + + Args: + cls_scores_list (list[Tensor]): Mask score logits from a single + decoder layer for all images. Each with shape (num_queries, + cls_out_channels). + mask_preds_list (list[Tensor]): Mask logits from a single decoder + layer for all images. Each with shape (num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for all + images. Each with shape (n, ), n is the sum of number of stuff + type and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[list[Tensor]]: a tuple containing the following targets. + - labels_list (list[Tensor]): Labels of all images.\ + Each with shape (num_queries, ). + - label_weights_list (list[Tensor]): Label weights\ + of all images. Each with shape (num_queries, ). + - mask_targets_list (list[Tensor]): Mask targets of\ + all images. Each with shape (num_queries, h, w). + - mask_weights_list (list[Tensor]): Mask weights of\ + all images. Each with shape (num_queries, ). + - num_total_pos (int): Number of positive samples in\ + all images. + - num_total_neg (int): Number of negative samples in\ + all images. + """ + (labels_list, label_weights_list, mask_targets_list, mask_weights_list, + pos_inds_list, + neg_inds_list) = multi_apply(self._get_target_single, cls_scores_list, + mask_preds_list, gt_labels_list, + gt_masks_list, img_metas) + + num_total_pos = sum((inds.numel() for inds in pos_inds_list)) + num_total_neg = sum((inds.numel() for inds in neg_inds_list)) + return (labels_list, label_weights_list, mask_targets_list, + mask_weights_list, num_total_pos, num_total_neg) + + def forward_head(self, decoder_out, mask_feature, attn_mask_target_size): + """Forward for head part which is called after every decoder layer. + + Args: + decoder_out (Tensor): in shape (num_queries, batch_size, c). + mask_feature (Tensor): in shape (batch_size, c, h, w). + attn_mask_target_size (tuple[int, int]): target attention + mask size. + + Returns: + tuple: A tuple contain three elements. + + - cls_pred (Tensor): Classification scores in shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred (Tensor): Mask scores in shape \ + (batch_size, num_queries,h, w). + - attn_mask (Tensor): Attention mask in shape \ + (batch_size * num_heads, num_queries, h, w). + """ + decoder_out = self.transformer_decoder.post_norm(decoder_out) + decoder_out = decoder_out.transpose(0, 1) + # shape (num_queries, batch_size, c) + cls_pred = self.cls_embed(decoder_out) + # shape (num_queries, batch_size, c) + mask_embed = self.mask_embed(decoder_out) + # shape (num_queries, batch_size, h, w) + mask_pred = torch.einsum('bqc,bchw->bqhw', mask_embed, mask_feature) + attn_mask = F.interpolate( + mask_pred, + attn_mask_target_size, + mode='bilinear', + align_corners=False) + # shape (num_queries, batch_size, h, w) -> + # (batch_size * num_head, num_queries, h, w) + attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat( + (1, self.num_heads, 1, 1)).flatten(0, 1) + attn_mask = attn_mask.sigmoid() < 0.5 + attn_mask = attn_mask.detach() + + return cls_pred, mask_pred, attn_mask + + def forward(self, feats, img_metas, return_query=False): + """Forward function. + + Args: + feats (list[Tensor]): Multi scale Features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + + Returns: + tuple: A tuple contains two elements. + + - cls_pred_list (list[Tensor)]: Classification logits \ + for each decoder layer. Each is a 3D-tensor with shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred_list (list[Tensor]): Mask logits for each \ + decoder layer. Each with shape (batch_size, num_queries, \ + h, w). + """ + batch_size = len(img_metas) + mask_features, multi_scale_memorys = self.pixel_decoder(feats) + # multi_scale_memorys (from low resolution to high resolution) + decoder_inputs = [] + decoder_positional_encodings = [] + for i in range(self.num_transformer_feat_level): + decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i]) + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + decoder_input = decoder_input.flatten(2).permute(2, 0, 1) + level_embed = self.level_embed.weight[i].view(1, 1, -1) + decoder_input = decoder_input + level_embed + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + mask = decoder_input.new_zeros( + (batch_size, ) + multi_scale_memorys[i].shape[-2:], + dtype=torch.bool) + decoder_positional_encoding = self.decoder_positional_encoding( + mask) + decoder_positional_encoding = decoder_positional_encoding.flatten( + 2).permute(2, 0, 1) + decoder_inputs.append(decoder_input) + decoder_positional_encodings.append(decoder_positional_encoding) + # shape (num_queries, c) -> (num_queries, batch_size, c) + query_feat = self.query_feat.weight.unsqueeze(1).repeat( + (1, batch_size, 1)) + query_embed = self.query_embed.weight.unsqueeze(1).repeat( + (1, batch_size, 1)) + + cls_pred_list = [] + mask_pred_list = [] + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[0].shape[-2:]) + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + for i in range(self.num_transformer_decoder_layers): + level_idx = i % self.num_transformer_feat_level + # if a mask is all True(all background), then set it all False. + attn_mask[torch.where( + attn_mask.sum(-1) == attn_mask.shape[-1])] = False + + # cross_attn + self_attn + layer = self.transformer_decoder.layers[i] + attn_masks = [attn_mask, None] + query_feat = layer( + query=query_feat, + key=decoder_inputs[level_idx], + value=decoder_inputs[level_idx], + query_pos=query_embed, + key_pos=decoder_positional_encodings[level_idx], + attn_masks=attn_masks, + query_key_padding_mask=None, + # here we do not apply masking on padded region + key_padding_mask=None) + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[ + (i + 1) % self.num_transformer_feat_level].shape[-2:]) + + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + if return_query: + return cls_pred_list, mask_pred_list, query_feat + else: + return cls_pred_list, mask_pred_list + + def forward_train(self, + feats, + img_metas, + gt_bboxes, + gt_labels, + gt_masks, + gt_semantic_seg, + gt_bboxes_ignore=None): + """Forward function for training mode. + + Args: + feats (list[Tensor]): Multi-level features from the upstream + network, each is a 4D-tensor. + img_metas (list[Dict]): List of image information. + gt_bboxes (list[Tensor]): Each element is ground truth bboxes of + the image, shape (num_gts, 4). Not used here. + gt_labels (list[Tensor]): Each element is ground truth labels of + each box, shape (num_gts,). + gt_masks (list[BitmapMasks]): Each element is masks of instances + of a image, shape (num_gts, h, w). + gt_semantic_seg (list[tensor] | None): Each element is the ground + truth of semantic segmentation with the shape (N, H, W). + [0, num_thing_class - 1] means things, + [num_thing_class, num_class-1] means stuff, + 255 means VOID. It's None when training instance segmentation. + gt_bboxes_ignore (list[Tensor]): Ground truth bboxes to be + ignored. Defaults to None. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + # not consider ignoring bboxes + assert gt_bboxes_ignore is None + + # forward + all_cls_scores, all_mask_preds = self(feats, img_metas) + + # preprocess ground truth + gt_labels, gt_masks = self.preprocess_gt(gt_labels, gt_masks, + gt_semantic_seg, img_metas) + + # loss + losses = self.loss(all_cls_scores, all_mask_preds, gt_labels, gt_masks, + gt_semantic_seg, img_metas) + + return losses + + @force_fp32(apply_to=('all_cls_scores', 'all_mask_preds')) + def loss(self, all_cls_scores, all_mask_preds, gt_labels_list, + gt_masks_list, gt_semantic_seg, img_metas): + """Loss function. + + Args: + all_cls_scores (Tensor): Classification scores for all decoder + layers with shape (num_decoder, batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + all_mask_preds (Tensor): Mask scores for all decoder layers with + shape (num_decoder, batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image with shape (n, ). n is the sum of number of stuff type + and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image with + shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + dict[str, Tensor]: A dictionary of loss components. + """ + + num_dec_layers = len(all_cls_scores) + stuff_gt_labels = [] + stuff_gt_masks = [] + thing_gt_labels = [] + thing_gt_masks = [] + + for gt_labels, gt_masks in zip(gt_labels_list, gt_masks_list): + num_stuff = sum(torch.unique(gt_labels) >= self.num_things_classes) + stuff_gt_labels.append(gt_labels[-num_stuff:]) + stuff_gt_masks.append(gt_masks[-num_stuff:]) + thing_gt_labels.append(gt_labels[:-num_stuff]) + thing_gt_masks.append(gt_masks[:-num_stuff]) + + stuff_gt_labels_list = [stuff_gt_labels for _ in range(num_dec_layers)] + stuff_gt_masks_list = [stuff_gt_masks for _ in range(num_dec_layers)] + + thing_gt_labels_list = [thing_gt_labels for _ in range(num_dec_layers)] + thing_gt_masks_list = [thing_gt_masks for _ in range(num_dec_layers)] + + stuff_scores = [all_cls_score[:, -self.num_stuff_classes:, :] for all_cls_score in all_cls_scores] + stuff_mask_preds = [all_mask_pred[:, -self.num_stuff_classes:, :, :] for all_mask_pred in all_mask_preds ] + + thing_scores = [all_cls_score[:, :-self.num_stuff_classes, :] for all_cls_score in all_cls_scores] + thing_mask_preds = [all_mask_pred[:, :-self.num_stuff_classes, :, :] for all_mask_pred in all_mask_preds] + + img_metas_list = [img_metas for _ in range(num_dec_layers)] + + losses_cls_stuff, losses_mask_stuff, losses_dice_stuff = multi_apply( + self.loss_single, stuff_scores, stuff_mask_preds, + stuff_gt_labels_list, stuff_gt_masks_list, img_metas_list) + + losses_cls_thing, losses_mask_thing, losses_dice_thing = multi_apply( + self.loss_single, thing_scores, thing_mask_preds, + thing_gt_labels_list, thing_gt_masks_list, img_metas_list) + + loss_dict = dict() + + # loss from the last decoder layer + loss_dict['loss_cls'] = losses_cls_stuff[-1] + losses_cls_thing[-1] + loss_dict['loss_mask'] = losses_mask_stuff[-1] + losses_mask_thing[-1] + loss_dict['loss_dice'] = losses_dice_stuff[-1] + losses_dice_thing[-1] + + # loss from other decoder layers stuff + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip( + losses_cls_stuff[:-1], + losses_mask_stuff[:-1], + losses_dice_stuff[:-1]): + + loss_dict[f'd{num_dec_layer}.stuff_loss_cls'] = loss_cls_i + loss_dict[f'd{num_dec_layer}.stuff_loss_mask'] = loss_mask_i + loss_dict[f'd{num_dec_layer}.stuff_loss_dice'] = loss_dice_i + num_dec_layer += 1 + + # loss from other decoder layers thing + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip( + losses_mask_thing[:-1], + losses_mask_thing[:-1], + losses_mask_thing[:-1]): + loss_dict[f'd{num_dec_layer}.thing_loss_cls'] = loss_cls_i + loss_dict[f'd{num_dec_layer}.thing_loss_mask'] = loss_mask_i + loss_dict[f'd{num_dec_layer}.thing_loss_dice'] = loss_dice_i + num_dec_layer += 1 + + return loss_dict + + + def simple_test(self, feats, img_metas, **kwargs): + """Test without augmentaton. + + Args: + feats (list[Tensor]): Multi-level features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + + Returns: + tuple: A tuple contains two tensors. + + - mask_cls_results (Tensor): Mask classification logits,\ + shape (batch_size, num_queries, cls_out_channels). + Note `cls_out_channels` should includes background. + - mask_pred_results (Tensor): Mask logits, shape \ + (batch_size, num_queries, h, w). + """ + all_cls_scores, all_mask_preds = self(feats, img_metas) + mask_cls_results = all_cls_scores[-1] + mask_pred_results = all_mask_preds[-1] + + # upsample masks + img_shape = img_metas[0]['batch_input_shape'] + mask_pred_results = F.interpolate( + mask_pred_results, + size=(img_shape[0], img_shape[1]), + mode='bilinear', + align_corners=False) + + return mask_cls_results, mask_pred_results + + def simple_test_with_query(self, feats, img_metas, **kwargs): + """Test without augmentaton. + + Args: + feats (list[Tensor]): Multi-level features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + + Returns: + tuple: A tuple contains two tensors. + + - mask_cls_results (Tensor): Mask classification logits,\ + shape (batch_size, num_queries, cls_out_channels). + Note `cls_out_channels` should includes background. + - mask_pred_results (Tensor): Mask logits, shape \ + (batch_size, num_queries, h, w). + """ + all_cls_scores, all_mask_preds, query_feats = self.forward(feats, img_metas,return_query=True) + mask_cls_results = all_cls_scores[-1] + mask_pred_results = all_mask_preds[-1] + + query_feats = torch.unsqueeze(query_feats, dim=0) # expand dim + + # upsample masks + img_shape = img_metas[0]['batch_input_shape'] + mask_pred_results = F.interpolate( + mask_pred_results, + size=(img_shape[0], img_shape[1]), + mode='bilinear', + align_corners=False) + + return mask_cls_results, mask_pred_results, query_feats \ No newline at end of file diff --git a/OpenPVSG/models/mask2former/mask2former_head_focal.py b/OpenPVSG/models/mask2former/mask2former_head_focal.py new file mode 100644 index 0000000000000000000000000000000000000000..c525fdfb6253f482bbfea091098d58f6ce0fc896 --- /dev/null +++ b/OpenPVSG/models/mask2former/mask2former_head_focal.py @@ -0,0 +1,613 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import copy + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import Conv2d, build_plugin_layer, caffe2_xavier_init +from mmcv.cnn.bricks.transformer import (build_positional_encoding, + build_transformer_layer_sequence) +from mmcv.ops import point_sample +from mmcv.runner import ModuleList, force_fp32 + +from mmdet.core import build_assigner, build_sampler, reduce_mean, multi_apply +from mmdet.models.utils import get_uncertain_point_coords_with_randomness +from mmdet.models.builder import HEADS, build_loss +from mmdet.models.dense_heads.anchor_free_head import AnchorFreeHead +from mmdet.models.dense_heads.maskformer_head import MaskFormerHead + +@HEADS.register_module() +class Mask2FormerHeadFocal(MaskFormerHead): + """Implements the Mask2Former head. + + See `Masked-attention Mask Transformer for Universal Image + Segmentation `_ for details. + + Args: + in_channels (list[int]): Number of channels in the input feature map. + feat_channels (int): Number of channels for features. + out_channels (int): Number of channels for output. + num_things_classes (int): Number of things. + num_stuff_classes (int): Number of stuff. + num_queries (int): Number of query in Transformer decoder. + pixel_decoder (:obj:`mmcv.ConfigDict` | dict): Config for pixel + decoder. Defaults to None. + enforce_decoder_input_project (bool, optional): Whether to add + a layer to change the embed_dim of tranformer encoder in + pixel decoder to the embed_dim of transformer decoder. + Defaults to False. + transformer_decoder (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder. Defaults to None. + positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder position encoding. Defaults to None. + loss_cls (:obj:`mmcv.ConfigDict` | dict): Config of the classification + loss. Defaults to None. + loss_mask (:obj:`mmcv.ConfigDict` | dict): Config of the mask loss. + Defaults to None. + loss_dice (:obj:`mmcv.ConfigDict` | dict): Config of the dice loss. + Defaults to None. + train_cfg (:obj:`mmcv.ConfigDict` | dict): Training config of + Mask2Former head. + test_cfg (:obj:`mmcv.ConfigDict` | dict): Testing config of + Mask2Former head. + init_cfg (dict or list[dict], optional): Initialization config dict. + Defaults to None. + """ + + def __init__(self, + in_channels, + feat_channels, + out_channels, + num_things_classes=80, + num_stuff_classes=53, + num_queries=100, + num_transformer_feat_level=3, + pixel_decoder=None, + enforce_decoder_input_project=False, + transformer_decoder=None, + positional_encoding=None, + loss_cls=None, + loss_mask=None, + loss_dice=None, + train_cfg=None, + test_cfg=None, + init_cfg=None, + **kwargs): + super(AnchorFreeHead, self).__init__(init_cfg) + self.num_things_classes = num_things_classes + self.num_stuff_classes = num_stuff_classes + self.num_classes = self.num_things_classes + self.num_stuff_classes + self.num_queries = num_queries + self.num_transformer_feat_level = num_transformer_feat_level + self.num_heads = transformer_decoder.transformerlayers.\ + attn_cfgs.num_heads + self.num_transformer_decoder_layers = transformer_decoder.num_layers + assert pixel_decoder.encoder.transformerlayers.\ + attn_cfgs.num_levels == num_transformer_feat_level + pixel_decoder_ = copy.deepcopy(pixel_decoder) + pixel_decoder_.update( + in_channels=in_channels, + feat_channels=feat_channels, + out_channels=out_channels) + self.pixel_decoder = build_plugin_layer(pixel_decoder_)[1] + self.transformer_decoder = build_transformer_layer_sequence( + transformer_decoder) + self.decoder_embed_dims = self.transformer_decoder.embed_dims + + self.decoder_input_projs = ModuleList() + # from low resolution to high resolution + for _ in range(num_transformer_feat_level): + if (self.decoder_embed_dims != feat_channels + or enforce_decoder_input_project): + self.decoder_input_projs.append( + Conv2d( + feat_channels, self.decoder_embed_dims, kernel_size=1)) + else: + self.decoder_input_projs.append(nn.Identity()) + self.decoder_positional_encoding = build_positional_encoding( + positional_encoding) + self.query_embed = nn.Embedding(self.num_queries, feat_channels) + self.query_feat = nn.Embedding(self.num_queries, feat_channels) + # from low resolution to high resolution + self.level_embed = nn.Embedding(self.num_transformer_feat_level, + feat_channels) + + self.cls_embed = nn.Linear(feat_channels, self.num_classes) + + self.mask_embed = nn.Sequential( + nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True), + nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True), + nn.Linear(feat_channels, out_channels)) + + self.test_cfg = test_cfg + self.train_cfg = train_cfg + if train_cfg: + self.assigner = build_assigner(self.train_cfg.assigner) + self.sampler = build_sampler(self.train_cfg.sampler, context=self) + self.num_points = self.train_cfg.get('num_points', 12544) + self.oversample_ratio = self.train_cfg.get('oversample_ratio', 3.0) + self.importance_sample_ratio = self.train_cfg.get( + 'importance_sample_ratio', 0.75) + + self.loss_cls = build_loss(loss_cls) + self.loss_mask = build_loss(loss_mask) + self.loss_dice = build_loss(loss_dice) + + def init_weights(self): + for m in self.decoder_input_projs: + if isinstance(m, Conv2d): + caffe2_xavier_init(m, bias=0) + + self.pixel_decoder.init_weights() + + for p in self.transformer_decoder.parameters(): + if p.dim() > 1: + nn.init.xavier_normal_(p) + + def _get_target_single(self, cls_score, mask_pred, gt_labels, gt_masks, + img_metas): + """Compute classification and mask targets for one image. + + Args: + cls_score (Tensor): Mask score logits from a single decoder layer + for one image. Shape (num_queries, cls_out_channels). + mask_pred (Tensor): Mask logits for a single decoder layer for one + image. Shape (num_queries, h, w). + gt_labels (Tensor): Ground truth class indices for one image with + shape (num_gts, ). + gt_masks (Tensor): Ground truth mask for each image, each with + shape (num_gts, h, w). + img_metas (dict): Image information. + + Returns: + tuple[Tensor]: A tuple containing the following for one image. + + - labels (Tensor): Labels of each image. \ + shape (num_queries, ). + - label_weights (Tensor): Label weights of each image. \ + shape (num_queries, ). + - mask_targets (Tensor): Mask targets of each image. \ + shape (num_queries, h, w). + - mask_weights (Tensor): Mask weights of each image. \ + shape (num_queries, ). + - pos_inds (Tensor): Sampled positive indices for each \ + image. + - neg_inds (Tensor): Sampled negative indices for each \ + image. + """ + + # sample points + num_queries = cls_score.shape[0] + num_gts = gt_labels.shape[0] + + point_coords = torch.rand((1, self.num_points, 2), + device=cls_score.device) + # shape (num_queries, num_points) + mask_points_pred = point_sample( + mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1, + 1)).squeeze(1) + # shape (num_gts, num_points) + gt_points_masks = point_sample( + gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1, + 1)).squeeze(1) + + # assign and sample + assign_result = self.assigner.assign(cls_score, mask_points_pred, + gt_labels, gt_points_masks, + img_metas) + sampling_result = self.sampler.sample(assign_result, mask_pred, + gt_masks) + pos_inds = sampling_result.pos_inds + neg_inds = sampling_result.neg_inds + + # label target (thing or stuff labels) + labels = gt_labels.new_full((num_queries, ), + self.num_classes, + dtype=torch.long) + labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds] + label_weights = gt_labels.new_ones((num_queries, )) + + # mask target + mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds] + mask_weights = mask_pred.new_zeros((num_queries, )) + mask_weights[pos_inds] = 1.0 + + return (labels, label_weights, mask_targets, mask_weights, pos_inds, + neg_inds) + + def loss_single(self, cls_scores, mask_preds, gt_labels_list, + gt_masks_list, img_metas): + """Loss function for outputs from a single decoder layer. + + Args: + cls_scores (Tensor): Mask score logits from a single decoder layer + for all images. Shape (batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + mask_preds (Tensor): Mask logits for a pixel decoder for all + images. Shape (batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image, each with shape (num_gts, ). + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (num_gts, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[Tensor]: Loss components for outputs from a single \ + decoder layer. + """ + num_imgs = cls_scores.size(0) + cls_scores_list = [cls_scores[i] for i in range(num_imgs)] + mask_preds_list = [mask_preds[i] for i in range(num_imgs)] + (labels_list, label_weights_list, mask_targets_list, mask_weights_list, + num_total_pos, + num_total_neg) = self.get_targets(cls_scores_list, mask_preds_list, + gt_labels_list, gt_masks_list, + img_metas) + + # shape (batch_size, num_queries) + labels = torch.stack(labels_list, dim=0) + # shape (batch_size, num_queries) + label_weights = torch.stack(label_weights_list, dim=0) + # shape (num_total_gts, h, w) + mask_targets = torch.cat(mask_targets_list, dim=0) + # shape (batch_size, num_queries) + mask_weights = torch.stack(mask_weights_list, dim=0) + + # classification loss + # shape (batch_size * num_queries, ) + cls_scores = cls_scores.flatten(0, 1) + labels = labels.flatten(0, 1) + label_weights = label_weights.flatten(0, 1) + + num_total_masks = reduce_mean(cls_scores.new_tensor([num_total_pos])) + num_total_masks = max(num_total_masks, 1) + + # class_weight = cls_scores.new_tensor(self.class_weight) + loss_cls = self.loss_cls( + cls_scores, + labels, + label_weights, + avg_factor=num_total_masks + ) + + # extract positive ones + # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w) + mask_preds = mask_preds[mask_weights > 0] + + if mask_targets.shape[0] == 0: + # zero match + loss_dice = mask_preds.sum() + loss_mask = mask_preds.sum() + return loss_cls, loss_mask, loss_dice + + with torch.no_grad(): + points_coords = get_uncertain_point_coords_with_randomness( + mask_preds.unsqueeze(1), None, self.num_points, + self.oversample_ratio, self.importance_sample_ratio) + # shape (num_total_gts, h, w) -> (num_total_gts, num_points) + mask_point_targets = point_sample( + mask_targets.unsqueeze(1).float(), points_coords).squeeze(1) + # shape (num_queries, h, w) -> (num_queries, num_points) + mask_point_preds = point_sample( + mask_preds.unsqueeze(1), points_coords).squeeze(1) + + # dice loss + loss_dice = self.loss_dice( + mask_point_preds, mask_point_targets, avg_factor=num_total_masks) + + # mask loss + # shape (num_queries, num_points) -> (num_queries * num_points, ) + mask_point_preds = mask_point_preds.reshape(-1) + # shape (num_total_gts, num_points) -> (num_total_gts * num_points, ) + mask_point_targets = mask_point_targets.reshape(-1) + loss_mask = self.loss_mask( + mask_point_preds, + mask_point_targets, + avg_factor=num_total_masks * self.num_points) + + return loss_cls, loss_mask, loss_dice + + def get_targets(self, cls_scores_list, mask_preds_list, gt_labels_list, + gt_masks_list, img_metas): + """Compute classification and mask targets for all images for a decoder + layer. + + Args: + cls_scores_list (list[Tensor]): Mask score logits from a single + decoder layer for all images. Each with shape (num_queries, + cls_out_channels). + mask_preds_list (list[Tensor]): Mask logits from a single decoder + layer for all images. Each with shape (num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for all + images. Each with shape (n, ), n is the sum of number of stuff + type and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[list[Tensor]]: a tuple containing the following targets. + - labels_list (list[Tensor]): Labels of all images.\ + Each with shape (num_queries, ). + - label_weights_list (list[Tensor]): Label weights\ + of all images. Each with shape (num_queries, ). + - mask_targets_list (list[Tensor]): Mask targets of\ + all images. Each with shape (num_queries, h, w). + - mask_weights_list (list[Tensor]): Mask weights of\ + all images. Each with shape (num_queries, ). + - num_total_pos (int): Number of positive samples in\ + all images. + - num_total_neg (int): Number of negative samples in\ + all images. + """ + (labels_list, label_weights_list, mask_targets_list, mask_weights_list, + pos_inds_list, + neg_inds_list) = multi_apply(self._get_target_single, cls_scores_list, + mask_preds_list, gt_labels_list, + gt_masks_list, img_metas) + + num_total_pos = sum((inds.numel() for inds in pos_inds_list)) + num_total_neg = sum((inds.numel() for inds in neg_inds_list)) + return (labels_list, label_weights_list, mask_targets_list, + mask_weights_list, num_total_pos, num_total_neg) + + def forward_head(self, decoder_out, mask_feature, attn_mask_target_size): + """Forward for head part which is called after every decoder layer. + + Args: + decoder_out (Tensor): in shape (num_queries, batch_size, c). + mask_feature (Tensor): in shape (batch_size, c, h, w). + attn_mask_target_size (tuple[int, int]): target attention + mask size. + + Returns: + tuple: A tuple contain three elements. + + - cls_pred (Tensor): Classification scores in shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred (Tensor): Mask scores in shape \ + (batch_size, num_queries,h, w). + - attn_mask (Tensor): Attention mask in shape \ + (batch_size * num_heads, num_queries, h, w). + """ + decoder_out = self.transformer_decoder.post_norm(decoder_out) + decoder_out = decoder_out.transpose(0, 1) + # shape (num_queries, batch_size, c) + cls_pred = self.cls_embed(decoder_out) + # shape (num_queries, batch_size, c) + mask_embed = self.mask_embed(decoder_out) + # shape (num_queries, batch_size, h, w) + mask_pred = torch.einsum('bqc,bchw->bqhw', mask_embed, mask_feature) + attn_mask = F.interpolate( + mask_pred, + attn_mask_target_size, + mode='bilinear', + align_corners=False) + # shape (num_queries, batch_size, h, w) -> + # (batch_size * num_head, num_queries, h, w) + attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat( + (1, self.num_heads, 1, 1)).flatten(0, 1) + attn_mask = attn_mask.sigmoid() < 0.5 + attn_mask = attn_mask.detach() + + return cls_pred, mask_pred, attn_mask + + def forward(self, feats, img_metas): + """Forward function. + + Args: + feats (list[Tensor]): Multi scale Features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + + Returns: + tuple: A tuple contains two elements. + + - cls_pred_list (list[Tensor)]: Classification logits \ + for each decoder layer. Each is a 3D-tensor with shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred_list (list[Tensor]): Mask logits for each \ + decoder layer. Each with shape (batch_size, num_queries, \ + h, w). + """ + batch_size = len(img_metas) + mask_features, multi_scale_memorys = self.pixel_decoder(feats) + # multi_scale_memorys (from low resolution to high resolution) + decoder_inputs = [] + decoder_positional_encodings = [] + for i in range(self.num_transformer_feat_level): + decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i]) + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + decoder_input = decoder_input.flatten(2).permute(2, 0, 1) + level_embed = self.level_embed.weight[i].view(1, 1, -1) + decoder_input = decoder_input + level_embed + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + mask = decoder_input.new_zeros( + (batch_size, ) + multi_scale_memorys[i].shape[-2:], + dtype=torch.bool) + decoder_positional_encoding = self.decoder_positional_encoding( + mask) + decoder_positional_encoding = decoder_positional_encoding.flatten( + 2).permute(2, 0, 1) + decoder_inputs.append(decoder_input) + decoder_positional_encodings.append(decoder_positional_encoding) + # shape (num_queries, c) -> (num_queries, batch_size, c) + query_feat = self.query_feat.weight.unsqueeze(1).repeat( + (1, batch_size, 1)) + query_embed = self.query_embed.weight.unsqueeze(1).repeat( + (1, batch_size, 1)) + + cls_pred_list = [] + mask_pred_list = [] + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[0].shape[-2:]) + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + for i in range(self.num_transformer_decoder_layers): + level_idx = i % self.num_transformer_feat_level + # if a mask is all True(all background), then set it all False. + attn_mask[torch.where( + attn_mask.sum(-1) == attn_mask.shape[-1])] = False + + # cross_attn + self_attn + layer = self.transformer_decoder.layers[i] + attn_masks = [attn_mask, None] + query_feat = layer( + query=query_feat, + key=decoder_inputs[level_idx], + value=decoder_inputs[level_idx], + query_pos=query_embed, + key_pos=decoder_positional_encodings[level_idx], + attn_masks=attn_masks, + query_key_padding_mask=None, + # here we do not apply masking on padded region + key_padding_mask=None) + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[ + (i + 1) % self.num_transformer_feat_level].shape[-2:]) + + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + return cls_pred_list, mask_pred_list + + def forward_train(self, + feats, + img_metas, + gt_bboxes, + gt_labels, + gt_masks, + gt_semantic_seg, + gt_bboxes_ignore=None): + """Forward function for training mode. + + Args: + feats (list[Tensor]): Multi-level features from the upstream + network, each is a 4D-tensor. + img_metas (list[Dict]): List of image information. + gt_bboxes (list[Tensor]): Each element is ground truth bboxes of + the image, shape (num_gts, 4). Not used here. + gt_labels (list[Tensor]): Each element is ground truth labels of + each box, shape (num_gts,). + gt_masks (list[BitmapMasks]): Each element is masks of instances + of a image, shape (num_gts, h, w). + gt_semantic_seg (list[tensor] | None): Each element is the ground + truth of semantic segmentation with the shape (N, H, W). + [0, num_thing_class - 1] means things, + [num_thing_class, num_class-1] means stuff, + 255 means VOID. It's None when training instance segmentation. + gt_bboxes_ignore (list[Tensor]): Ground truth bboxes to be + ignored. Defaults to None. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + # not consider ignoring bboxes + assert gt_bboxes_ignore is None + + # forward + all_cls_scores, all_mask_preds = self(feats, img_metas) + + # preprocess ground truth + gt_labels, gt_masks = self.preprocess_gt(gt_labels, gt_masks, + gt_semantic_seg, img_metas) + + # loss + losses = self.loss(all_cls_scores, all_mask_preds, gt_labels, gt_masks, + gt_semantic_seg, img_metas) + + return losses + + @force_fp32(apply_to=('all_cls_scores', 'all_mask_preds')) + def loss(self, all_cls_scores, all_mask_preds, gt_labels_list, + gt_masks_list, gt_semantic_seg, img_metas): + """Loss function. + + Args: + all_cls_scores (Tensor): Classification scores for all decoder + layers with shape (num_decoder, batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + all_mask_preds (Tensor): Mask scores for all decoder layers with + shape (num_decoder, batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image with shape (n, ). n is the sum of number of stuff type + and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image with + shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + dict[str, Tensor]: A dictionary of loss components. + """ + + num_dec_layers = len(all_cls_scores) + stuff_gt_labels = [] + stuff_gt_masks = [] + thing_gt_labels = [] + thing_gt_masks = [] + + for gt_labels, gt_masks in zip(gt_labels_list, gt_masks_list): + num_stuff = sum(torch.unique(gt_labels) >= self.num_things_classes) + stuff_gt_labels.append(gt_labels[-num_stuff:]) + stuff_gt_masks.append(gt_masks[-num_stuff:]) + thing_gt_labels.append(gt_labels[:-num_stuff]) + thing_gt_masks.append(gt_masks[:-num_stuff]) + + stuff_gt_labels_list = [stuff_gt_labels for _ in range(num_dec_layers)] + stuff_gt_masks_list = [stuff_gt_masks for _ in range(num_dec_layers)] + + thing_gt_labels_list = [thing_gt_labels for _ in range(num_dec_layers)] + thing_gt_masks_list = [thing_gt_masks for _ in range(num_dec_layers)] + + stuff_scores = [all_cls_score[:, -self.num_stuff_classes:, :] for all_cls_score in all_cls_scores] + stuff_mask_preds = [all_mask_pred[:, -self.num_stuff_classes:, :, :] for all_mask_pred in all_mask_preds ] + + thing_scores = [all_cls_score[:, :-self.num_stuff_classes, :] for all_cls_score in all_cls_scores] + thing_mask_preds = [all_mask_pred[:, :-self.num_stuff_classes, :, :] for all_mask_pred in all_mask_preds] + + img_metas_list = [img_metas for _ in range(num_dec_layers)] + + losses_cls_stuff, losses_mask_stuff, losses_dice_stuff = multi_apply( + self.loss_single, stuff_scores, stuff_mask_preds, + stuff_gt_labels_list, stuff_gt_masks_list, img_metas_list) + + losses_cls_thing, losses_mask_thing, losses_dice_thing = multi_apply( + self.loss_single, thing_scores, thing_mask_preds, + thing_gt_labels_list, thing_gt_masks_list, img_metas_list) + + loss_dict = dict() + + # loss from the last decoder layer + loss_dict['loss_cls'] = losses_cls_stuff[-1] + losses_cls_thing[-1] + loss_dict['loss_mask'] = losses_mask_stuff[-1] + losses_mask_thing[-1] + loss_dict['loss_dice'] = losses_dice_stuff[-1] + losses_dice_thing[-1] + + # loss from other decoder layers stuff + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip( + losses_cls_stuff[:-1], + losses_mask_stuff[:-1], + losses_dice_stuff[:-1]): + + loss_dict[f'd{num_dec_layer}.stuff_loss_cls'] = loss_cls_i + loss_dict[f'd{num_dec_layer}.stuff_loss_mask'] = loss_mask_i + loss_dict[f'd{num_dec_layer}.stuff_loss_dice'] = loss_dice_i + num_dec_layer += 1 + + # loss from other decoder layers thing + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip( + losses_mask_thing[:-1], + losses_mask_thing[:-1], + losses_mask_thing[:-1]): + loss_dict[f'd{num_dec_layer}.thing_loss_cls'] = loss_cls_i + loss_dict[f'd{num_dec_layer}.thing_loss_mask'] = loss_mask_i + loss_dict[f'd{num_dec_layer}.thing_loss_dice'] = loss_dice_i + num_dec_layer += 1 + + return loss_dict diff --git a/OpenPVSG/models/mask2former/mask2former_head_split_focal.py b/OpenPVSG/models/mask2former/mask2former_head_split_focal.py new file mode 100644 index 0000000000000000000000000000000000000000..3ce50508cb1bad743be76dcdf7ca44696da93c65 --- /dev/null +++ b/OpenPVSG/models/mask2former/mask2former_head_split_focal.py @@ -0,0 +1,751 @@ +# Copyright (c) OpenMMLab. All rights reserved. +import copy + +import torch +import torch.nn as nn +import torch.nn.functional as F +from mmcv.cnn import Conv2d, build_plugin_layer, caffe2_xavier_init +from mmcv.cnn.bricks.transformer import (build_positional_encoding, + build_transformer_layer_sequence) +from mmcv.ops import point_sample +from mmcv.runner import ModuleList, force_fp32 + +from mmdet.core import build_assigner, build_sampler, reduce_mean, multi_apply +from mmdet.models.utils import get_uncertain_point_coords_with_randomness +from mmdet.models.builder import HEADS, build_loss +from mmdet.models.dense_heads.anchor_free_head import AnchorFreeHead +from mmdet.models.dense_heads.maskformer_head import MaskFormerHead + + +@HEADS.register_module() +class Mask2FormerHeadSplitFocal(MaskFormerHead): + """Implements the Mask2Former head. + + See `Masked-attention Mask Transformer for Universal Image + Segmentation `_ for details. + + Args: + in_channels (list[int]): Number of channels in the input feature map. + feat_channels (int): Number of channels for features. + out_channels (int): Number of channels for output. + num_things_classes (int): Number of things. + num_stuff_classes (int): Number of stuff. + num_queries (int): Number of query in Transformer decoder. + pixel_decoder (:obj:`mmcv.ConfigDict` | dict): Config for pixel + decoder. Defaults to None. + enforce_decoder_input_project (bool, optional): Whether to add + a layer to change the embed_dim of tranformer encoder in + pixel decoder to the embed_dim of transformer decoder. + Defaults to False. + transformer_decoder (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder. Defaults to None. + positional_encoding (:obj:`mmcv.ConfigDict` | dict): Config for + transformer decoder position encoding. Defaults to None. + loss_cls (:obj:`mmcv.ConfigDict` | dict): Config of the classification + loss. Defaults to None. + loss_mask (:obj:`mmcv.ConfigDict` | dict): Config of the mask loss. + Defaults to None. + loss_dice (:obj:`mmcv.ConfigDict` | dict): Config of the dice loss. + Defaults to None. + train_cfg (:obj:`mmcv.ConfigDict` | dict): Training config of + Mask2Former head. + test_cfg (:obj:`mmcv.ConfigDict` | dict): Testing config of + Mask2Former head. + init_cfg (dict or list[dict], optional): Initialization config dict. + Defaults to None. + """ + + def __init__(self, + in_channels, + feat_channels, + out_channels, + num_things_classes=80, + num_stuff_classes=53, + num_queries=100, + num_transformer_feat_level=3, + pixel_decoder=None, + enforce_decoder_input_project=False, + transformer_decoder=None, + positional_encoding=None, + thing_class_weight=None, + stuff_class_weight=None, + loss_cls=None, + loss_mask=None, + loss_dice=None, + train_cfg=None, + test_cfg=None, + init_cfg=None, + **kwargs): + super(AnchorFreeHead, self).__init__(init_cfg) + self.num_things_classes = num_things_classes + self.num_stuff_classes = num_stuff_classes + self.num_classes = self.num_things_classes + self.num_stuff_classes + self.num_queries = num_queries + self.num_transformer_feat_level = num_transformer_feat_level + self.num_heads = transformer_decoder.transformerlayers.\ + attn_cfgs.num_heads + self.num_transformer_decoder_layers = transformer_decoder.num_layers + assert pixel_decoder.encoder.transformerlayers.\ + attn_cfgs.num_levels == num_transformer_feat_level + pixel_decoder_ = copy.deepcopy(pixel_decoder) + pixel_decoder_.update( + in_channels=in_channels, + feat_channels=feat_channels, + out_channels=out_channels) + self.pixel_decoder = build_plugin_layer(pixel_decoder_)[1] + self.transformer_decoder = build_transformer_layer_sequence( + transformer_decoder) + self.decoder_embed_dims = self.transformer_decoder.embed_dims + + self.decoder_input_projs = ModuleList() + # from low resolution to high resolution + for _ in range(num_transformer_feat_level): + if (self.decoder_embed_dims != feat_channels + or enforce_decoder_input_project): + self.decoder_input_projs.append( + Conv2d( + feat_channels, self.decoder_embed_dims, kernel_size=1)) + else: + self.decoder_input_projs.append(nn.Identity()) + self.decoder_positional_encoding = build_positional_encoding( + positional_encoding) + self.query_embed = nn.Embedding(self.num_queries, feat_channels) + self.query_feat = nn.Embedding(self.num_queries, feat_channels) + # from low resolution to high resolution + self.level_embed = nn.Embedding(self.num_transformer_feat_level, + feat_channels) + # cls embed output + self.thing_embed = nn.Linear(feat_channels, self.num_things_classes) + self.stuff_embed = nn.Linear(feat_channels, self.num_stuff_classes) + + self.mask_embed = nn.Sequential( + nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True), + nn.Linear(feat_channels, feat_channels), nn.ReLU(inplace=True), + nn.Linear(feat_channels, out_channels)) + + self.test_cfg = test_cfg + self.train_cfg = train_cfg + + if train_cfg: + self.assigner = build_assigner(self.train_cfg.assigner) + self.sampler = build_sampler(self.train_cfg.sampler, context=self) + self.num_points = self.train_cfg.get('num_points', 12544) + self.oversample_ratio = self.train_cfg.get('oversample_ratio', 3.0) + self.importance_sample_ratio = self.train_cfg.get( + 'importance_sample_ratio', 0.75) + + self.thing_class_weight = thing_class_weight + self.stuff_class_weight = stuff_class_weight + + self.loss_cls = build_loss(loss_cls) + self.loss_mask = build_loss(loss_mask) + self.loss_dice = build_loss(loss_dice) + + def init_weights(self): + for m in self.decoder_input_projs: + if isinstance(m, Conv2d): + caffe2_xavier_init(m, bias=0) + + self.pixel_decoder.init_weights() + + for p in self.transformer_decoder.parameters(): + if p.dim() > 1: + nn.init.xavier_normal_(p) + + def _get_target_single(self, cls_score, mask_pred, gt_labels, gt_masks, + img_metas): + """Compute classification and mask targets for one image. + + Args: + cls_score (Tensor): Mask score logits from a single decoder layer + for one image. Shape (num_queries, cls_out_channels). + mask_pred (Tensor): Mask logits for a single decoder layer for one + image. Shape (num_queries, h, w). + gt_labels (Tensor): Ground truth class indices for one image with + shape (num_gts, ). + gt_masks (Tensor): Ground truth mask for each image, each with + shape (num_gts, h, w). + img_metas (dict): Image information. + + Returns: + tuple[Tensor]: A tuple containing the following for one image. + + - labels (Tensor): Labels of each image. \ + shape (num_queries, ). + - label_weights (Tensor): Label weights of each image. \ + shape (num_queries, ). + - mask_targets (Tensor): Mask targets of each image. \ + shape (num_queries, h, w). + - mask_weights (Tensor): Mask weights of each image. \ + shape (num_queries, ). + - pos_inds (Tensor): Sampled positive indices for each \ + image. + - neg_inds (Tensor): Sampled negative indices for each \ + image. + """ + + # sample points + num_queries = cls_score.shape[0] + num_gts = gt_labels.shape[0] + + point_coords = torch.rand((1, self.num_points, 2), + device=cls_score.device) + + # shape (num_queries, num_points) + mask_points_pred = point_sample( + mask_pred.unsqueeze(1), point_coords.repeat(num_queries, 1, + 1)).squeeze(1) + # shape (num_gts, num_points) + gt_points_masks = point_sample( + gt_masks.unsqueeze(1).float(), point_coords.repeat(num_gts, 1, + 1)).squeeze(1) + + # assign and sample + assign_result = self.assigner.assign(cls_score, mask_points_pred, + gt_labels, gt_points_masks, + img_metas) + sampling_result = self.sampler.sample(assign_result, mask_pred, + gt_masks) + pos_inds = sampling_result.pos_inds + neg_inds = sampling_result.neg_inds + + if num_queries > self.num_stuff_classes: + label_default = self.num_things_classes + else: + label_default = self.num_stuff_classes + + # label target (thing or stuff labels) + labels = gt_labels.new_full((num_queries, ), + label_default, + dtype=torch.long) + + labels[pos_inds] = gt_labels[sampling_result.pos_assigned_gt_inds] + label_weights = gt_labels.new_ones((num_queries, )) + + # mask target + mask_targets = gt_masks[sampling_result.pos_assigned_gt_inds] + mask_weights = mask_pred.new_zeros((num_queries, )) + mask_weights[pos_inds] = 1.0 + + return (labels, label_weights, mask_targets, mask_weights, pos_inds, + neg_inds) + + def loss_single(self, cls_scores, mask_preds, gt_labels_list, + gt_masks_list, img_metas, is_thing_list): + """Loss function for outputs from a single decoder layer. + + Args: + cls_scores (Tensor): Mask score logits from a single decoder layer + for all images. Shape (batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + mask_preds (Tensor): Mask logits for a pixel decoder for all + images. Shape (batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image, each with shape (num_gts, ). + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (num_gts, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[Tensor]: Loss components for outputs from a single \ + decoder layer. + """ + num_imgs = cls_scores.size(0) + cls_scores_list = [cls_scores[i] for i in range(num_imgs)] + mask_preds_list = [mask_preds[i] for i in range(num_imgs)] + (labels_list, label_weights_list, mask_targets_list, mask_weights_list, + num_total_pos, + num_total_neg) = self.get_targets(cls_scores_list, mask_preds_list, + gt_labels_list, gt_masks_list, + img_metas) + + # shape (batch_size, num_queries) + labels = torch.stack(labels_list, dim=0) + # shape (batch_size, num_queries) + label_weights = torch.stack(label_weights_list, dim=0) + # shape (num_total_gts, h, w) + mask_targets = torch.cat(mask_targets_list, dim=0) + # shape (batch_size, num_queries) + mask_weights = torch.stack(mask_weights_list, dim=0) + + # classification loss + # shape (batch_size * num_queries, ) + cls_scores = cls_scores.flatten(0, 1) + labels = labels.flatten(0, 1) + label_weights = label_weights.flatten(0, 1) + + # class_weight = cls_scores.new_tensor(self.class_weight) + if is_thing_list: + class_weight = cls_scores.new_tensor(self.thing_class_weight) + else: + class_weight = cls_scores.new_tensor(self.stuff_class_weight) + + loss_cls = self.loss_cls( + cls_scores, + labels, + label_weights, + avg_factor=class_weight[labels].sum() + ) + + num_total_masks = reduce_mean(cls_scores.new_tensor([num_total_pos])) + num_total_masks = max(num_total_masks, 1) + + # extract positive ones + # shape (batch_size, num_queries, h, w) -> (num_total_gts, h, w) + mask_preds = mask_preds[mask_weights > 0] + + if mask_targets.shape[0] == 0: + # zero match + loss_dice = mask_preds.sum() + loss_mask = mask_preds.sum() + return loss_cls, loss_mask, loss_dice + + with torch.no_grad(): + points_coords = get_uncertain_point_coords_with_randomness( + mask_preds.unsqueeze(1), None, self.num_points, + self.oversample_ratio, self.importance_sample_ratio) + # shape (num_total_gts, h, w) -> (num_total_gts, num_points) + mask_point_targets = point_sample( + mask_targets.unsqueeze(1).float(), points_coords).squeeze(1) + # shape (num_queries, h, w) -> (num_queries, num_points) + mask_point_preds = point_sample( + mask_preds.unsqueeze(1), points_coords).squeeze(1) + + # dice loss + loss_dice = self.loss_dice( + mask_point_preds, mask_point_targets, avg_factor=num_total_masks) + + # mask loss + # shape (num_queries, num_points) -> (num_queries * num_points, ) + mask_point_preds = mask_point_preds.reshape(-1) + # shape (num_total_gts, num_points) -> (num_total_gts * num_points, ) + mask_point_targets = mask_point_targets.reshape(-1) + loss_mask = self.loss_mask( + mask_point_preds, + mask_point_targets, + avg_factor=num_total_masks * self.num_points) + + return loss_cls, loss_mask, loss_dice + + def get_targets(self, cls_scores_list, mask_preds_list, gt_labels_list, + gt_masks_list, img_metas): + """Compute classification and mask targets for all images for a decoder + layer. + + Args: + cls_scores_list (list[Tensor]): Mask score logits from a single + decoder layer for all images. Each with shape (num_queries, + cls_out_channels). + mask_preds_list (list[Tensor]): Mask logits from a single decoder + layer for all images. Each with shape (num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for all + images. Each with shape (n, ), n is the sum of number of stuff + type and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image, + each with shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + tuple[list[Tensor]]: a tuple containing the following targets. + - labels_list (list[Tensor]): Labels of all images.\ + Each with shape (num_queries, ). + - label_weights_list (list[Tensor]): Label weights\ + of all images. Each with shape (num_queries, ). + - mask_targets_list (list[Tensor]): Mask targets of\ + all images. Each with shape (num_queries, h, w). + - mask_weights_list (list[Tensor]): Mask weights of\ + all images. Each with shape (num_queries, ). + - num_total_pos (int): Number of positive samples in\ + all images. + - num_total_neg (int): Number of negative samples in\ + all images. + """ + (labels_list, label_weights_list, mask_targets_list, mask_weights_list, + pos_inds_list, + neg_inds_list) = multi_apply(self._get_target_single, cls_scores_list, + mask_preds_list, gt_labels_list, + gt_masks_list, img_metas) + + num_total_pos = sum((inds.numel() for inds in pos_inds_list)) + num_total_neg = sum((inds.numel() for inds in neg_inds_list)) + return (labels_list, label_weights_list, mask_targets_list, + mask_weights_list, num_total_pos, num_total_neg) + + def forward_head(self, decoder_out, mask_feature, attn_mask_target_size): + """Forward for head part which is called after every decoder layer. + + Args: + decoder_out (Tensor): in shape (num_queries, batch_size, c). + mask_feature (Tensor): in shape (batch_size, c, h, w). + attn_mask_target_size (tuple[int, int]): target attention + mask size. + + Returns: + tuple: A tuple contain three elements. + + - cls_pred (Tensor): Classification scores in shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred (Tensor): Mask scores in shape \ + (batch_size, num_queries,h, w). + - attn_mask (Tensor): Attention mask in shape \ + (batch_size * num_heads, num_queries, h, w). + """ + decoder_out = self.transformer_decoder.post_norm(decoder_out) + decoder_out = decoder_out.transpose(0, 1) + # shape (num_queries, batch_size, c) -> (b, n, c) + # cls_pred = self.cls_embed(decoder_out) + + th_cls_pred = self.thing_embed(decoder_out[:, :-self.num_stuff_classes]) + st_cls_pred = self.stuff_embed(decoder_out[:, -self.num_stuff_classes:]) + + # (N_{th}, b, c_{th}) (N_{st}, b, c_{stuff}) + cls_pred = [th_cls_pred, st_cls_pred] + + # shape (num_queries, batch_size, c) + mask_embed = self.mask_embed(decoder_out) + + # shape (num_queries, batch_size, h, w) + mask_pred = torch.einsum('bqc,bchw -> bqhw', mask_embed, mask_feature) + attn_mask = F.interpolate( + mask_pred, + attn_mask_target_size, + mode='bilinear', + align_corners=False) + + # shape (num_queries, batch_size, h, w) -> + # (batch_size * num_head, num_queries, h, w) + attn_mask = attn_mask.flatten(2).unsqueeze(1).repeat( + (1, self.num_heads, 1, 1)).flatten(0, 1) + attn_mask = attn_mask.sigmoid() < 0.5 + + attn_mask = attn_mask.detach() + + return cls_pred, mask_pred, attn_mask + + def forward(self, feats, img_metas): + """Forward function. + + Args: + feats (list[Tensor]): Multi scale Features from the + upstream network, each is a 4D-tensor. + img_metas (list[dict]): List of image information. + + Returns: + tuple: A tuple contains two elements. + + - cls_pred_list (list[Tensor)]: Classification logits \ + for each decoder layer. Each is a 3D-tensor with shape \ + (batch_size, num_queries, cls_out_channels). \ + Note `cls_out_channels` should includes background. + - mask_pred_list (list[Tensor]): Mask logits for each \ + decoder layer. Each with shape (batch_size, num_queries, \ + h, w). + """ + batch_size = len(img_metas) + mask_features, multi_scale_memorys = self.pixel_decoder(feats) + # multi_scale_memorys (from low resolution to high resolution) + decoder_inputs = [] + decoder_positional_encodings = [] + for i in range(self.num_transformer_feat_level): + decoder_input = self.decoder_input_projs[i](multi_scale_memorys[i]) + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + decoder_input = decoder_input.flatten(2).permute(2, 0, 1) + level_embed = self.level_embed.weight[i].view(1, 1, -1) + decoder_input = decoder_input + level_embed + # shape (batch_size, c, h, w) -> (h*w, batch_size, c) + mask = decoder_input.new_zeros( + (batch_size, ) + multi_scale_memorys[i].shape[-2:], + dtype=torch.bool) + decoder_positional_encoding = self.decoder_positional_encoding( + mask) + decoder_positional_encoding = decoder_positional_encoding.flatten( + 2).permute(2, 0, 1) + decoder_inputs.append(decoder_input) + decoder_positional_encodings.append(decoder_positional_encoding) + # shape (num_queries, c) -> (num_queries, batch_size, c) + query_feat = self.query_feat.weight.unsqueeze(1).repeat( + (1, batch_size, 1)) + query_embed = self.query_embed.weight.unsqueeze(1).repeat( + (1, batch_size, 1)) + + cls_pred_list = [] + mask_pred_list = [] + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[0].shape[-2:]) + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + for i in range(self.num_transformer_decoder_layers): + level_idx = i % self.num_transformer_feat_level + # if a mask is all True(all background), then set it all False. + attn_mask[torch.where( + attn_mask.sum(-1) == attn_mask.shape[-1])] = False + + # cross_attn + self_attn + layer = self.transformer_decoder.layers[i] + attn_masks = [attn_mask, None] + query_feat = layer( + query=query_feat, + key=decoder_inputs[level_idx], + value=decoder_inputs[level_idx], + query_pos=query_embed, + key_pos=decoder_positional_encodings[level_idx], + attn_masks=attn_masks, + query_key_padding_mask=None, + # here we do not apply masking on padded region + key_padding_mask=None) + cls_pred, mask_pred, attn_mask = self.forward_head( + query_feat, mask_features, multi_scale_memorys[ + (i + 1) % self.num_transformer_feat_level].shape[-2:]) + + cls_pred_list.append(cls_pred) + mask_pred_list.append(mask_pred) + + return cls_pred_list, mask_pred_list + + def forward_train(self, + feats, + img_metas, + gt_bboxes, + gt_labels, + gt_masks, + gt_semantic_seg, + gt_bboxes_ignore=None): + """Forward function for training mode. + + Args: + feats (list[Tensor]): Multi-level features from the upstream + network, each is a 4D-tensor. + img_metas (list[Dict]): List of image information. + gt_bboxes (list[Tensor]): Each element is ground truth bboxes of + the image, shape (num_gts, 4). Not used here. + gt_labels (list[Tensor]): Each element is ground truth labels of + each box, shape (num_gts,). + gt_masks (list[BitmapMasks]): Each element is masks of instances + of a image, shape (num_gts, h, w). + gt_semantic_seg (list[tensor] | None): Each element is the ground + truth of semantic segmentation with the shape (N, H, W). + [0, num_thing_class - 1] means things, + [num_thing_class, num_class-1] means stuff, + 255 means VOID. It's None when training instance segmentation. + gt_bboxes_ignore (list[Tensor]): Ground truth bboxes to be + ignored. Defaults to None. + + Returns: + dict[str, Tensor]: a dictionary of loss components + """ + # not consider ignoring bboxes + assert gt_bboxes_ignore is None + + # forward + all_cls_scores, all_mask_preds = self(feats, img_metas) + + # preprocess ground truth + gt_labels, gt_masks = self.preprocess_gt(gt_labels, gt_masks, + gt_semantic_seg, img_metas) + + # loss + losses = self.loss(all_cls_scores, all_mask_preds, gt_labels, gt_masks, + gt_semantic_seg, img_metas) + + return losses + + @force_fp32(apply_to=('all_cls_scores', 'all_mask_preds')) + def loss(self, all_cls_scores, all_mask_preds, gt_labels_list, + gt_masks_list, gt_semantic_seg, img_metas): + """Loss function. + + Args: + all_cls_scores (Tensor): Classification scores for all decoder + layers with shape (num_decoder, batch_size, num_queries, + cls_out_channels). Note `cls_out_channels` should includes + background. + all_mask_preds (Tensor): Mask scores for all decoder layers with + shape (num_decoder, batch_size, num_queries, h, w). + gt_labels_list (list[Tensor]): Ground truth class indices for each + image with shape (n, ). n is the sum of number of stuff type + and number of instance in a image. + gt_masks_list (list[Tensor]): Ground truth mask for each image with + shape (n, h, w). + img_metas (list[dict]): List of image meta information. + + Returns: + dict[str, Tensor]: A dictionary of loss components. + """ + + num_dec_layers = len(all_cls_scores) + stuff_gt_labels = [] + stuff_gt_masks = [] + thing_gt_labels = [] + thing_gt_masks = [] + + for gt_labels, gt_masks in zip(gt_labels_list, gt_masks_list): + num_stuff = sum(torch.unique(gt_labels) >= self.num_things_classes) + stuff_gt_labels.append(gt_labels[-num_stuff:]) + stuff_gt_masks.append(gt_masks[-num_stuff:]) + thing_gt_labels.append(gt_labels[:-num_stuff]) + thing_gt_masks.append(gt_masks[:-num_stuff]) + + stuff_gt_labels_list = [stuff_gt_labels for _ in range(num_dec_layers)] + stuff_gt_masks_list = [stuff_gt_masks for _ in range(num_dec_layers)] + + thing_gt_labels_list = [thing_gt_labels for _ in range(num_dec_layers)] + thing_gt_masks_list = [thing_gt_masks for _ in range(num_dec_layers)] + + stuff_scores = [all_cls_score[1] for all_cls_score in all_cls_scores] + stuff_mask_preds = [all_mask_pred[:, -self.num_stuff_classes:, :, :] for all_mask_pred in all_mask_preds ] + + thing_scores = [all_cls_score[0] for all_cls_score in all_cls_scores] + thing_mask_preds = [all_mask_pred[:, :-self.num_stuff_classes, :, :] for all_mask_pred in all_mask_preds] + + img_metas_list = [img_metas for _ in range(num_dec_layers)] + is_thing = [True for _ in range(num_dec_layers) ] + not_thing = [False for _ in range(num_dec_layers)] + + losses_cls_stuff, losses_mask_stuff, losses_dice_stuff = multi_apply( + self.loss_single, stuff_scores, stuff_mask_preds, + stuff_gt_labels_list, stuff_gt_masks_list, img_metas_list, not_thing) + + losses_cls_thing, losses_mask_thing, losses_dice_thing = multi_apply( + self.loss_single, thing_scores, thing_mask_preds, + thing_gt_labels_list, thing_gt_masks_list, img_metas_list, is_thing) + + loss_dict = dict() + + # loss from the last decoder layer + loss_dict['loss_cls'] = losses_cls_stuff[-1] + losses_cls_thing[-1] + loss_dict['loss_mask'] = losses_mask_stuff[-1] + losses_mask_thing[-1] + loss_dict['loss_dice'] = losses_dice_stuff[-1] + losses_dice_thing[-1] + + # loss from other decoder layers stuff + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip( + losses_cls_stuff[:-1], + losses_mask_stuff[:-1], + losses_dice_stuff[:-1]): + + loss_dict[f'd{num_dec_layer}.stuff_loss_cls'] = loss_cls_i + loss_dict[f'd{num_dec_layer}.stuff_loss_mask'] = loss_mask_i + loss_dict[f'd{num_dec_layer}.stuff_loss_dice'] = loss_dice_i + num_dec_layer += 1 + + # loss from other decoder layers thing + num_dec_layer = 0 + for loss_cls_i, loss_mask_i, loss_dice_i in zip( + losses_mask_thing[:-1], + losses_mask_thing[:-1], + losses_mask_thing[:-1]): + loss_dict[f'd{num_dec_layer}.thing_loss_cls'] = loss_cls_i + loss_dict[f'd{num_dec_layer}.thing_loss_mask'] = loss_mask_i + loss_dict[f'd{num_dec_layer}.thing_loss_dice'] = loss_dice_i + num_dec_layer += 1 + + return loss_dict + + + def preprocess_gt(self, gt_labels_list, gt_masks_list, gt_semantic_segs, + img_metas): + """Preprocess the ground truth for all images. + + Args: + gt_labels_list (list[Tensor]): Each is ground truth + labels of each bbox, with shape (num_gts, ). + gt_masks_list (list[BitmapMasks]): Each is ground truth + masks of each instances of a image, shape + (num_gts, h, w). + gt_semantic_seg (Tensor | None): Ground truth of semantic + segmentation with the shape (batch_size, n, h, w). + [0, num_thing_class - 1] means things, + [num_thing_class, num_class-1] means stuff, + 255 means VOID. It's None when training instance segmentation. + img_metas (list[dict]): List of image meta information. + + Returns: + tuple: a tuple containing the following targets. + - labels (list[Tensor]): Ground truth class indices\ + for all images. Each with shape (n, ), n is the sum of\ + number of stuff type and number of instance in a image. + - masks (list[Tensor]): Ground truth mask for each\ + image, each with shape (n, h, w). + """ + num_things_list = [self.num_things_classes] * len(gt_labels_list) + num_stuff_list = [self.num_stuff_classes] * len(gt_labels_list) + if gt_semantic_segs is None: + gt_semantic_segs = [None] * len(gt_labels_list) + + targets = multi_apply(preprocess_panoptic_gt_split_th_st, gt_labels_list, + gt_masks_list, gt_semantic_segs, num_things_list, + num_stuff_list, img_metas) + labels, masks = targets + return labels, masks + + +def preprocess_panoptic_gt_split_th_st(gt_labels, gt_masks, gt_semantic_seg, num_things, + num_stuff, img_metas): + """Preprocess the ground truth for a image. + + Args: + gt_labels (Tensor): Ground truth labels of each bbox, + with shape (num_gts, ). + gt_masks (BitmapMasks): Ground truth masks of each instances + of a image, shape (num_gts, h, w). + gt_semantic_seg (Tensor | None): Ground truth of semantic + segmentation with the shape (1, h, w). + [0, num_thing_class - 1] means things, + [num_thing_class, num_class-1] means stuff, + 255 means VOID. It's None when training instance segmentation. + img_metas (dict): List of image meta information. + + Returns: + tuple: a tuple containing the following targets. + + - labels (Tensor): Ground truth class indices for a + image, with shape (n, ), n is the sum of number + of stuff type and number of instance in a image. + - masks (Tensor): Ground truth mask for a image, with + shape (n, h, w). Contains stuff and things when training + panoptic segmentation, and things only when training + instance segmentation. + """ + num_classes = num_things + num_stuff + + things_masks = gt_masks.pad(img_metas['pad_shape'][:2], pad_val=0)\ + .to_tensor(dtype=torch.bool, device=gt_labels.device) + + if gt_semantic_seg is None: + masks = things_masks.long() + return gt_labels, masks + + things_labels = gt_labels + gt_semantic_seg = gt_semantic_seg.squeeze(0) + + semantic_labels = torch.unique( + gt_semantic_seg, + sorted=False, + return_inverse=False, + return_counts=False) + + stuff_masks_list = [] + stuff_labels_list = [] + for label in semantic_labels: + if label < num_things or label >= num_classes: + continue + stuff_mask = gt_semantic_seg == label + stuff_masks_list.append(stuff_mask) + # new stuff label: 0 - N_{stuff} -1 + stuff_labels_list.append(label - num_things) + + if len(stuff_masks_list) > 0: + stuff_masks = torch.stack(stuff_masks_list, dim=0) + stuff_labels = torch.stack(stuff_labels_list, dim=0) + labels = torch.cat([things_labels, stuff_labels], dim=0) + masks = torch.cat([things_masks, stuff_masks], dim=0) + else: + labels = things_labels + masks = things_masks + + masks = masks.long() + + return labels, masks \ No newline at end of file diff --git a/OpenPVSG/models/unitrack/core/__init__.py b/OpenPVSG/models/unitrack/core/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/OpenPVSG/models/unitrack/core/association/__init__.py b/OpenPVSG/models/unitrack/core/association/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/OpenPVSG/models/unitrack/core/association/matching.py b/OpenPVSG/models/unitrack/core/association/matching.py new file mode 100644 index 0000000000000000000000000000000000000000..c64a3e279b3a51a593f7233017580fa0bc55c1f6 --- /dev/null +++ b/OpenPVSG/models/unitrack/core/association/matching.py @@ -0,0 +1,258 @@ +import torch +import torch.nn.functional as F +import numpy as np +import scipy +from scipy.spatial.distance import cdist +import lap + +from cython_bbox import bbox_overlaps as bbox_ious +from ..motion import kalman_filter + + +def merge_matches(m1, m2, shape): + O,P,Q = shape + m1 = np.asarray(m1) + m2 = np.asarray(m2) + + M1 = scipy.sparse.coo_matrix((np.ones(len(m1)), (m1[:, 0], m1[:, 1])), shape=(O, P)) + M2 = scipy.sparse.coo_matrix((np.ones(len(m2)), (m2[:, 0], m2[:, 1])), shape=(P, Q)) + + mask = M1*M2 + match = mask.nonzero() + match = list(zip(match[0], match[1])) + unmatched_O = tuple(set(range(O)) - set([i for i, j in match])) + unmatched_Q = tuple(set(range(Q)) - set([j for i, j in match])) + + return match, unmatched_O, unmatched_Q + + +def linear_assignment(cost_matrix, thresh): + if cost_matrix.size == 0: + return np.empty((0, 2), dtype=int), tuple(range(cost_matrix.shape[0])), tuple(range(cost_matrix.shape[1])) + matches, unmatched_a, unmatched_b = [], [], [] + cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh) + for ix, mx in enumerate(x): + if mx >= 0: + matches.append([ix, mx]) + unmatched_a = np.where(x < 0)[0] + unmatched_b = np.where(y < 0)[0] + matches = np.asarray(matches) + return matches, unmatched_a, unmatched_b + + +def ious(atlbrs, btlbrs): + """ + Compute cost based on IoU + :type atlbrs: list[tlbr] | np.ndarray + :type atlbrs: list[tlbr] | np.ndarray + + :rtype ious np.ndarray + """ + ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=np.float) + if ious.size == 0: + return ious + + ious = bbox_ious( + np.ascontiguousarray(atlbrs, dtype=np.float), + np.ascontiguousarray(btlbrs, dtype=np.float) + ) + + return ious + + +def iou_distance(atracks, btracks): + """ + Compute cost based on IoU + :type atracks: list[STrack] + :type btracks: list[STrack] + + :rtype cost_matrix np.ndarray + """ + + if (len(atracks)>0 and isinstance(atracks[0], np.ndarray)) or (len(btracks) > 0 and isinstance(btracks[0], np.ndarray)): + atlbrs = atracks + btlbrs = btracks + else: + atlbrs = [track.tlbr for track in atracks] + btlbrs = [track.tlbr for track in btracks] + _ious = ious(atlbrs, btlbrs) + cost_matrix = 1 - _ious + + return cost_matrix + +def embedding_distance(tracks, detections, metric='cosine'): + """ + :param tracks: list[STrack] + :param detections: list[BaseTrack] + :param metric: + :return: cost_matrix np.ndarray + """ + + cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float) + if cost_matrix.size == 0: + return cost_matrix + det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float) + track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float) + cost_matrix = np.maximum(0.0, cdist(track_features, det_features)) # Nomalized features + return cost_matrix + + +def fuse_motion(kf, cost_matrix, tracks, detections, only_position=False, lambda_=0.98, gate=True): + if cost_matrix.size == 0: + return cost_matrix + gating_dim = 2 if only_position else 4 + gating_threshold = kalman_filter.chi2inv95[gating_dim] + measurements = np.asarray([det.to_xyah() for det in detections]) + for row, track in enumerate(tracks): + gating_distance = kf.gating_distance( + track.mean, track.covariance, measurements, only_position, metric='maha') + if gate: + cost_matrix[row, gating_distance > gating_threshold] = np.inf + cost_matrix[row] = lambda_ * cost_matrix[row] + (1-lambda_)* gating_distance + return cost_matrix + + +def center_emb_distance(tracks, detections, metric='cosine'): + """ + :param tracks: list[STrack] + :param detections: list[BaseTrack] + :param metric: + :return: cost_matrix np.ndarray + """ + + cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float) + if cost_matrix.size == 0: + return cost_matrix + det_features = torch.stack([track.curr_feat.squeeze() for track in detections]) + track_features = torch.stack([track.smooth_feat.squeeze() for track in tracks]) + normed_det = F.normalize(det_features) + normed_track = F.normalize(track_features) + cost_matrix = torch.mm(normed_track, normed_det.T) + cost_matrix = 1 - cost_matrix.detach().cpu().numpy() + return cost_matrix + +def recons_distance(tracks, detections, tmp=100): + """ + :param tracks: list[STrack] + :param detections: list[BaseTrack] + :param metric: + :return: cost_matrix np.ndarray + """ + + cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float) + if cost_matrix.size == 0: + return cost_matrix + det_features_ = torch.stack([track.curr_feat.squeeze() for track in detections]) + track_features_ = torch.stack([track.smooth_feat for track in tracks]) + det_features = F.normalize(det_features_, dim=1) + track_features = F.normalize(track_features_, dim=1) + + ndet, ndim, nw, nh = det_features.shape + ntrk, _, _, _ = track_features.shape + fdet = det_features.permute(0,2,3,1).reshape(-1, ndim).cuda() # ndet*nw*nh, ndim + ftrk = track_features.permute(0,2,3,1).reshape(-1, ndim).cuda() # ntrk*nw*nh, ndim + + aff = torch.mm(ftrk, fdet.transpose(0,1)) # ntrk*nw*nh, ndet*nw*nh + aff_td = F.softmax(tmp*aff, dim=1) + aff_dt = F.softmax(tmp*aff, dim=0).transpose(0,1) + + recons_ftrk = torch.einsum('tds,dsm->tdm', aff_td.view(ntrk*nw*nh, ndet, nw*nh), + fdet.view(ndet, nw*nh, ndim)) # ntrk*nw*nh, ndet, ndim + recons_fdet = torch.einsum('dts,tsm->dtm', aff_dt.view(ndet*nw*nh, ntrk, nw*nh), + ftrk.view(ntrk, nw*nh, ndim)) # ndet*nw*nh, ntrk, ndim + + res_ftrk = (recons_ftrk.permute(0,2,1) - ftrk.unsqueeze(-1)).view(ntrk, nw*nh*ndim, ndet) + res_fdet = (recons_fdet.permute(0,2,1) - fdet.unsqueeze(-1)).view(ndet, nw*nh*ndim, ntrk) + + cost_matrix = (torch.abs(res_ftrk).mean(1) + torch.abs(res_fdet).mean(1).transpose(0,1)) * 0.5 + cost_matrix = cost_matrix / cost_matrix.max(1)[0].unsqueeze(-1) + #pdb.set_trace() + cost_matrix = cost_matrix.cpu().numpy() + return cost_matrix + + +def get_track_feat(tracks, feat_flag='curr'): + if feat_flag == 'curr': + feat_list = [track.curr_feat.squeeze(0) for track in tracks] + elif feat_flag == 'smooth': + feat_list = [track.smooth_feat.squeeze(0) for track in tracks] + else: + raise NotImplementedError + + n = len(tracks) + fdim = feat_list[0].shape[0] + fdim_num = len(feat_list[0].shape) + if fdim_num > 2: + feat_list = [f.view(fdim,-1) for f in feat_list] + numels = [f.shape[1] for f in feat_list] + + ret = torch.zeros(n, fdim, np.max(numels)).to(feat_list[0].device) + for i, f in enumerate(feat_list): + ret[i, :, :numels[i]] = f + return ret + +def reconsdot_distance(tracks, detections, tmp=100): + """ + :param tracks: list[STrack] + :param detections: list[BaseTrack] + :param metric: + :return: cost_matrix np.ndarray + """ + cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float) + if cost_matrix.size == 0: + return cost_matrix, None + det_features_ = get_track_feat(detections) + track_features_ = get_track_feat(tracks, feat_flag='curr') + + det_features = F.normalize(det_features_, dim=1) + track_features = F.normalize(track_features_, dim=1) + + ndet, ndim, nsd = det_features.shape + ntrk, _, nst = track_features.shape + + fdet = det_features.permute(0, 2, 1).reshape(-1, ndim) + ftrk = track_features.permute(0, 2, 1).reshape(-1, ndim) + + aff = torch.mm(ftrk, fdet.transpose(0, 1)) + aff_td = F.softmax(tmp*aff, dim=1) + aff_dt = F.softmax(tmp*aff, dim=0).transpose(0, 1) + + recons_ftrk = torch.einsum('tds,dsm->tdm', aff_td.view(ntrk*nst, ndet, nsd), + fdet.view(ndet, nsd, ndim)) + recons_fdet = torch.einsum('dts,tsm->dtm', aff_dt.view(ndet*nsd, ntrk, nst), + ftrk.view(ntrk, nst, ndim)) + + recons_ftrk = recons_ftrk.permute(0, 2, 1).reshape((ntrk, nst*ndim, ndet)) + recons_ftrk_norm = F.normalize(recons_ftrk, dim=1) + recons_fdet = recons_fdet.permute(0, 2, 1).view(ndet, nsd*ndim, ntrk) + recons_fdet_norm = F.normalize(recons_fdet, dim=1) + + dot_td = torch.einsum('tad,ta->td', recons_ftrk_norm, + F.normalize(ftrk.reshape(ntrk, nst*ndim), dim=1)) + dot_dt = torch.einsum('dat,da->dt', recons_fdet_norm, + F.normalize(fdet.reshape(ndet, nsd*ndim), dim=1)) + + cost_matrix = 1 - 0.5 * (dot_td + dot_dt.transpose(0, 1)) + cost_matrix = cost_matrix.detach().cpu().numpy() + + return cost_matrix, None + + +def category_gate(cost_matrix, tracks, detections): + """ + :param tracks: list[STrack] + :param detections: list[BaseTrack] + :param metric: + :return: cost_matrix np.ndarray + """ + if cost_matrix.size == 0: + return cost_matrix + + det_categories = np.array([d.category for d in detections]) + trk_categories = np.array([t.category for t in tracks]) + + cost_matrix = cost_matrix + np.abs( + det_categories[None, :] - trk_categories[:, None]) + return cost_matrix + + diff --git a/OpenPVSG/models/unitrack/core/motion/kalman_filter.py b/OpenPVSG/models/unitrack/core/motion/kalman_filter.py new file mode 100644 index 0000000000000000000000000000000000000000..e63d8c7e22d2a8e890be1d37050945708198df14 --- /dev/null +++ b/OpenPVSG/models/unitrack/core/motion/kalman_filter.py @@ -0,0 +1,277 @@ +# vim: expandtab:ts=4:sw=4 +import numpy as np +import scipy.linalg + + +""" +Table for the 0.95 quantile of the chi-square distribution with N degrees of +freedom (contains values for N=1, ..., 9). Taken from MATLAB/Octave's chi2inv +function and used as Mahalanobis gating threshold. +""" +chi2inv95 = { + 1: 3.8415, + 2: 5.9915, + 3: 7.8147, + 4: 9.4877, + 5: 11.070, + 6: 12.592, + 7: 14.067, + 8: 15.507, + 9: 16.919} + + +class KalmanFilter(object): + """ + A simple Kalman filter for tracking bounding boxes in image space. + + The 8-dimensional state space + + x, y, a, h, vx, vy, va, vh + + contains the bounding box center position (x, y), aspect ratio a, height h, + and their respective velocities. + + Object motion follows a constant velocity model. The bounding box location + (x, y, a, h) is taken as direct observation of the state space (linear + observation model). + + """ + + def __init__(self): + ndim, dt = 4, 1. + + # Create Kalman filter model matrices. + self._motion_mat = np.eye(2 * ndim, 2 * ndim) + for i in range(ndim): + self._motion_mat[i, ndim + i] = dt + self._update_mat = np.eye(ndim, 2 * ndim) + + # Motion and observation uncertainty are chosen relative to the current + # state estimate. These weights control the amount of uncertainty in + # the model. This is a bit hacky. + self._std_weight_position = 1. / 20 + self._std_weight_velocity = 1. / 160 + + def initiate(self, measurement): + """Create track from unassociated measurement. + + Parameters + ---------- + measurement : ndarray + Bounding box coordinates (x, y, a, h) with center position (x, y), + aspect ratio a, and height h. + + Returns + ------- + (ndarray, ndarray) + Returns the mean vector (8 dimensional) and covariance matrix (8x8 + dimensional) of the new track. Unobserved velocities are initialized + to 0 mean. + + """ + mean_pos = measurement + mean_vel = np.zeros_like(mean_pos) + mean = np.r_[mean_pos, mean_vel] + + std = [ + 2 * self._std_weight_position * measurement[3], + 2 * self._std_weight_position * measurement[3], + 1e-2, + 2 * self._std_weight_position * measurement[3], + 10 * self._std_weight_velocity * measurement[3], + 10 * self._std_weight_velocity * measurement[3], + 1e-5, + 10 * self._std_weight_velocity * measurement[3]] + covariance = np.diag(np.square(std)) + return mean, covariance + + def predict(self, mean, covariance): + """Run Kalman filter prediction step. + + Parameters + ---------- + mean : ndarray + The 8 dimensional mean vector of the object state at the previous + time step. + covariance : ndarray + The 8x8 dimensional covariance matrix of the object state at the + previous time step. + + Returns + ------- + (ndarray, ndarray) + Returns the mean vector and covariance matrix of the predicted + state. Unobserved velocities are initialized to 0 mean. + + """ + std_pos = [ + self._std_weight_position * mean[3], + self._std_weight_position * mean[3], + 1e-2, + self._std_weight_position * mean[3]] + std_vel = [ + self._std_weight_velocity * mean[3], + self._std_weight_velocity * mean[3], + 1e-5, + self._std_weight_velocity * mean[3]] + motion_cov = np.diag(np.square(np.r_[std_pos, std_vel])) + + mean = np.dot(mean, self._motion_mat.T) + covariance = np.linalg.multi_dot(( + self._motion_mat, covariance, self._motion_mat.T)) + motion_cov + + return mean, covariance + + def project(self, mean, covariance): + """Project state distribution to measurement space. + + Parameters + ---------- + mean : ndarray + The state's mean vector (8 dimensional array). + covariance : ndarray + The state's covariance matrix (8x8 dimensional). + + Returns + ------- + (ndarray, ndarray) + Returns the projected mean and covariance matrix of the given state + estimate. + + """ + std = [ + self._std_weight_position * mean[3], + self._std_weight_position * mean[3], + 1e-1, + self._std_weight_position * mean[3]] + innovation_cov = np.diag(np.square(std)) + + mean = np.dot(self._update_mat, mean) + covariance = np.linalg.multi_dot(( + self._update_mat, covariance, self._update_mat.T)) + return mean, covariance + innovation_cov + + def multi_predict(self, mean, covariance): + """Run Kalman filter prediction step (Vectorized version). + + Parameters + ---------- + mean : ndarray + The Nx8 dimensional mean matrix of the object states at the previous + time step. + covariance : ndarray + The Nx8x8 dimensional covariance matrics of the object states at the + previous time step. + + Returns + ------- + (ndarray, ndarray) + Returns the mean vector and covariance matrix of the predicted + state. Unobserved velocities are initialized to 0 mean. + + """ + std_pos = [ + self._std_weight_position * mean[:, 3], + self._std_weight_position * mean[:, 3], + 1e-2 * np.ones_like(mean[:, 3]), + self._std_weight_position * mean[:, 3]] + std_vel = [ + self._std_weight_velocity * mean[:, 3], + self._std_weight_velocity * mean[:, 3], + 1e-5 * np.ones_like(mean[:, 3]), + self._std_weight_velocity * mean[:, 3]] + sqr = np.square(np.r_[std_pos, std_vel]).T + + motion_cov = [] + for i in range(len(mean)): + motion_cov.append(np.diag(sqr[i])) + motion_cov = np.asarray(motion_cov) + + mean = np.dot(mean, self._motion_mat.T) + left = np.dot(self._motion_mat, covariance).transpose((1,0,2)) + covariance = np.dot(left, self._motion_mat.T) + motion_cov + + return mean, covariance + + def update(self, mean, covariance, measurement): + """Run Kalman filter correction step. + + Parameters + ---------- + mean : ndarray + The predicted state's mean vector (8 dimensional). + covariance : ndarray + The state's covariance matrix (8x8 dimensional). + measurement : ndarray + The 4 dimensional measurement vector (x, y, a, h), where (x, y) + is the center position, a the aspect ratio, and h the height of the + bounding box. + + Returns + ------- + (ndarray, ndarray) + Returns the measurement-corrected state distribution. + + """ + projected_mean, projected_cov = self.project(mean, covariance) + + chol_factor, lower = scipy.linalg.cho_factor( + projected_cov, lower=True, check_finite=False) + kalman_gain = scipy.linalg.cho_solve( + (chol_factor, lower), np.dot(covariance, self._update_mat.T).T, + check_finite=False).T + innovation = measurement - projected_mean + + new_mean = mean + np.dot(innovation, kalman_gain.T) + new_covariance = covariance - np.linalg.multi_dot(( + kalman_gain, projected_cov, kalman_gain.T)) + return new_mean, new_covariance + + def gating_distance(self, mean, covariance, measurements, + only_position=False, metric='maha'): + """Compute gating distance between state distribution and measurements. + + A suitable distance threshold can be obtained from `chi2inv95`. If + `only_position` is False, the chi-square distribution has 4 degrees of + freedom, otherwise 2. + + Parameters + ---------- + mean : ndarray + Mean vector over the state distribution (8 dimensional). + covariance : ndarray + Covariance of the state distribution (8x8 dimensional). + measurements : ndarray + An Nx4 dimensional matrix of N measurements, each in + format (x, y, a, h) where (x, y) is the bounding box center + position, a the aspect ratio, and h the height. + only_position : Optional[bool] + If True, distance computation is done with respect to the bounding + box center position only. + + Returns + ------- + ndarray + Returns an array of length N, where the i-th element contains the + squared Mahalanobis distance between (mean, covariance) and + `measurements[i]`. + + """ + mean, covariance = self.project(mean, covariance) + if only_position: + mean, covariance = mean[:2], covariance[:2, :2] + measurements = measurements[:, :2] + + d = measurements - mean + if metric == 'gaussian': + return np.sum(d * d, axis=1) + elif metric == 'maha': + cholesky_factor = np.linalg.cholesky(covariance) + z = scipy.linalg.solve_triangular( + cholesky_factor, d.T, lower=True, check_finite=False, + overwrite_b=True) + squared_maha = np.sum(z * z, axis=0) + return squared_maha + else: + raise ValueError('invalid distance metric') + diff --git a/OpenPVSG/models/unitrack/core/propagation/__init__.py b/OpenPVSG/models/unitrack/core/propagation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..307e4332f614b8083c9000a0699c032830189e34 --- /dev/null +++ b/OpenPVSG/models/unitrack/core/propagation/__init__.py @@ -0,0 +1,24 @@ +################################################################### +# File Name: __init__.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Mon Jan 18 15:57:34 2021 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + +from .propagate_box import propagate_box +from .propagate_mask import propagate_mask +from .propagate_pose import propagate_pose + +def propagate(temp_feats, obs, img, model, format='box'): + if format == 'box': + return propagate_box(temp_feats, obs, img, model) + elif format == 'mask': + return propagate_box(temp_feats, obs, img, model) + elif format == 'pose': + return propagate_pose(temp_feats, obs, img, model) + else: + raise ValueError('Observation format not supported.') diff --git a/OpenPVSG/models/unitrack/core/propagation/propagate_box.py b/OpenPVSG/models/unitrack/core/propagation/propagate_box.py new file mode 100644 index 0000000000000000000000000000000000000000..5e6f61fe08eea09298d305541720b4aa2618c856 --- /dev/null +++ b/OpenPVSG/models/unitrack/core/propagation/propagate_box.py @@ -0,0 +1,13 @@ +################################################################### +# File Name: propagate_box.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Mon Jan 18 16:01:46 2021 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + +def propagate_box(temp_feats, box, img, model): + pass diff --git a/OpenPVSG/models/unitrack/core/propagation/propagate_mask.py b/OpenPVSG/models/unitrack/core/propagation/propagate_mask.py new file mode 100644 index 0000000000000000000000000000000000000000..df1cad1a7c46f675b059c45a764e0ca8762096b6 --- /dev/null +++ b/OpenPVSG/models/unitrack/core/propagation/propagate_mask.py @@ -0,0 +1,13 @@ +################################################################### +# File Name: propagate_box.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Mon Jan 18 16:01:46 2021 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + +def propagate_mask(temp_feats, mask, img, model): + pass diff --git a/OpenPVSG/models/unitrack/core/propagation/propagate_pose.py b/OpenPVSG/models/unitrack/core/propagation/propagate_pose.py new file mode 100644 index 0000000000000000000000000000000000000000..13d43a7faf21c9101be08b40e3ce8d9672b4899f --- /dev/null +++ b/OpenPVSG/models/unitrack/core/propagation/propagate_pose.py @@ -0,0 +1,13 @@ +################################################################### +# File Name: propagate_box.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Mon Jan 18 16:01:46 2021 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + +def propagate_pose(temp_feats, pose, img, model): + pass diff --git a/OpenPVSG/models/unitrack/data/__init__.py b/OpenPVSG/models/unitrack/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f7364da2eaadf3cc790ad51ac110eeba9af9bc3a --- /dev/null +++ b/OpenPVSG/models/unitrack/data/__init__.py @@ -0,0 +1,2 @@ +from .single_video import LoadOutputsFromMask2Former +from .query_feat_tracklet import QueryFeatTube diff --git a/OpenPVSG/models/unitrack/data/query_feat_tracklet.py b/OpenPVSG/models/unitrack/data/query_feat_tracklet.py new file mode 100644 index 0000000000000000000000000000000000000000..c7144a3f332c35271826d3f52d4cf33cc004cc24 --- /dev/null +++ b/OpenPVSG/models/unitrack/data/query_feat_tracklet.py @@ -0,0 +1,38 @@ +import numpy as np +from collections import deque + + +class QueryFeatTube(object): + def __init__(self, start_frame_id, track_id, query_feat): + self.track_id = track_id + self.start_frame_id = start_frame_id + self.end_frame_id = start_frame_id + self.len = 1 + qf_tube = self._init_previous_tube() + qf_tube.append(query_feat) + self.qf_tube = qf_tube + + def __repr__(self): + return 'QFT_{}_({}_{})'.format(self.track_id, self.start_frame_id, + self.end_frame_id) + + def _init_previous_tube(self): + # called when a new detection is found - fill previous position with "None" + qf_tube = [None for i in range(self.start_frame_id - 1)] + return qf_tube + + def update(self, query_feat, cur_frame_id): + if self.end_frame_id < cur_frame_id: + self.qf_tube.extend( + [None for i in range(cur_frame_id - self.end_frame_id - 1)]) + self.qf_tube.append(query_feat) + self.end_frame_id = cur_frame_id + self.len += 1 + + def complete_empty_postfix(self, last_frame_idx): + if len(self.qf_tube) == last_frame_idx + 1: + return self + self.qf_tube.extend( + [None for i in range(last_frame_idx + 1 - self.end_frame_id)]) + # self.end_frame_id = last_frame_idx + 1 + return self diff --git a/OpenPVSG/models/unitrack/data/single_video.py b/OpenPVSG/models/unitrack/data/single_video.py new file mode 100644 index 0000000000000000000000000000000000000000..af67c9c8bbbebe6ad2296b9ba0d80d12c45deb70 --- /dev/null +++ b/OpenPVSG/models/unitrack/data/single_video.py @@ -0,0 +1,102 @@ +import numpy as np +from pathlib import Path +import torch +import cv2 +from torchvision.transforms import transforms as T + +from mmdet.core import INSTANCE_OFFSET + + +class LoadOutputsFromMask2Former: + """Process outputs of all images of a singel video from mask2former to + inputs of unitracker. + + Modification from LoadImagesAndMaskObsMOTS: get_data + """ + def __init__( + self, + data_cfg, # data_cfg = data.test (in data base config) + outputs, + tracker_cfg, # add cfg! (follow unitrack opt) + classes): + data_root = Path(data_cfg.data_root) + video_name = data_cfg.video_name + if video_name.startswith('P'): + data_source = 'epic_kitchen' + elif video_name.split('_')[0].isdigit() and len( + video_name.split('_')[0]) == 4: + data_source = 'vidor' + else: + data_source = 'ego4d' + + video_folder = data_root / data_source / 'frames' / video_name + self.num_classes = len(classes) + self.img_files = sorted( + [str(x) for x in (video_folder.rglob('*.png'))]) + self.transforms = T.Compose([ + T.ToTensor(), + T.Normalize(tracker_cfg.common.im_mean, tracker_cfg.common.im_std) + ]) + + pan_masks_all_images = [] + query_feat_dicts_all_images = [] + for frame_output in outputs: + pan_masks_all_images.append(frame_output['pan_results']) + query_feat_dicts_all_images.append(frame_output['query_feats']) + self.pan_masks_all_images = pan_masks_all_images + self.query_feat_dicts_all_images = query_feat_dicts_all_images + + def _get_binary_masks_and_query_feats( + self, pan_mask, query_feat_dict): # for single frame all objects + object_ids = list(np.unique(pan_mask)) + if self.num_classes in object_ids: + object_ids.remove(self.num_classes) + if len( + object_ids + ) == 0: # deal with the case that no mask was detected from mask2former!!!! + return np.array([]), [] + assert len(list(query_feat_dict.keys())) == len( + object_ids), 'Masks and query feats should match!' + + binary_masks = [] + query_feats = [] + for object_id in object_ids: + # binary masks + obj_binary_mask = (pan_mask == object_id).astype(np.int) + binary_masks.append(obj_binary_mask) + # cls ids + cls_id = object_id % INSTANCE_OFFSET + # query feat list (map masks order) + query_feats.append( + dict(query_feat=self._unify_query_feat_dim( + query_feat_dict[object_id]), + cls_id=cls_id)) # zip the two things together + + return np.stack( + binary_masks + ), query_feats # obs should be numpy array ! not tensor + + def _unify_query_feat_dim(self, query_feat_list): + if len(query_feat_list) == 1: + return query_feat_list[0].squeeze() # squeeze (1,256) to (256,) + else: # get average for stuff + query_feat_list = [x.squeeze() for x in query_feat_list] + query_feat_stack = np.stack(query_feat_list) + return query_feat_stack.mean(axis=0) + + def __getitem__(self, idx): + img_ori = cv2.imread(self.img_files[idx]) + if img_ori is None: + raise ValueError('File corrupt {}'.format(self.img_files[idx])) + # process img: copy from unitrack-video.py + h, w, _ = img_ori.shape + img = img_ori + img = img / 255. + img = np.ascontiguousarray(img[:, :, ::-1]) # BGR to RGB + if self.transforms is not None: + img = self.transforms(img) + # process masks and get cls_id + labels, query_feats = self._get_binary_masks_and_query_feats( + self.pan_masks_all_images[idx], + self.query_feat_dicts_all_images[idx]) + return img, labels, img_ori, (h, w), query_feats diff --git a/OpenPVSG/models/unitrack/data/video.py b/OpenPVSG/models/unitrack/data/video.py new file mode 100644 index 0000000000000000000000000000000000000000..9863417c5489f4d9b59be42c9cbfe59c604fce11 --- /dev/null +++ b/OpenPVSG/models/unitrack/data/video.py @@ -0,0 +1,414 @@ +import os +import pdb +import glob +import json +import os.path as osp + +import cv2 +import numpy as np + +import pycocotools.mask as mask_utils +from utils.box import xyxy2xywh + +from torchvision.transforms import transforms as T + + +class LoadImages: # for inference + def __init__(self, path, img_size=(1088, 608)): + if os.path.isdir(path): + image_format = ['.jpg', '.jpeg', '.png', '.tif'] + self.files = sorted(glob.glob('%s/*.*' % path)) + self.files = list( + filter( + lambda x: os.path.splitext(x)[1].lower() in image_format, + self.files)) + elif os.path.isfile(path): + self.files = [path] + + self.nF = len(self.files) # number of image files + self.width = img_size[0] + self.height = img_size[1] + self.count = 0 + + assert self.nF > 0, 'No images found in ' + path + + def __iter__(self): + self.count = -1 + return self + + def __next__(self): + self.count += 1 + if self.count == self.nF: + raise StopIteration + img_path = self.files[self.count] + + # Read image + img0 = cv2.imread(img_path) # BGR + assert img0 is not None, 'Failed to load ' + img_path + + # Padded resize + img, _, _, _ = letterbox(img0, height=self.height, width=self.width) + + # Normalize RGB + img = img[:, :, ::-1].transpose(2, 0, 1) + img = np.ascontiguousarray(img, dtype=np.float32) + img /= 255.0 + + return img_path, img, img0 + + def __getitem__(self, idx): + idx = idx % self.nF + img_path = self.files[idx] + + # Read image + img0 = cv2.imread(img_path) # BGR + assert img0 is not None, 'Failed to load ' + img_path + + # Padded resize + img, _, _, _ = letterbox(img0, height=self.height, width=self.width) + + # Normalize RGB + img = img[:, :, ::-1].transpose(2, 0, 1) + img = np.ascontiguousarray(img, dtype=np.float32) + img /= 255.0 + + return img_path, img, img0 + + def __len__(self): + return self.nF # number of files + + +class LoadVideo: # for inference + def __init__(self, path, img_size=(1088, 608)): + self.cap = cv2.VideoCapture(path) + self.frame_rate = int(round(self.cap.get(cv2.CAP_PROP_FPS))) + self.vw = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH)) + self.vh = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) + self.vn = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT)) + + self.width = img_size[0] + self.height = img_size[1] + self.count = 0 + + self.w, self.h = self.get_size(self.vw, self.vh, self.width, + self.height) + print('Lenth of the video: {:d} frames'.format(self.vn)) + + def get_size(self, vw, vh, dw, dh): + wa, ha = float(dw) / vw, float(dh) / vh + a = min(wa, ha) + return int(vw * a), int(vh * a) + + def __iter__(self): + self.count = -1 + return self + + def __next__(self): + self.count += 1 + if self.count == len(self): + raise StopIteration + # Read image + res, img0 = self.cap.read() # BGR + assert img0 is not None, 'Failed to load frame {:d}'.format(self.count) + img0 = cv2.resize(img0, (self.w, self.h)) + + # Padded resize + img, _, _, _ = letterbox(img0, height=self.height, width=self.width) + + # Normalize RGB + img = img[:, :, ::-1] + img = np.ascontiguousarray(img, dtype=np.float32) + + return self.count, img, img0 + + def __len__(self): + return self.vn # number of files + + +class LoadImagesAndObs: + def __init__(self, path, opt): + obid = opt.obid + img_size = getattr(opt, 'img_size', None) + if os.path.isdir(path): + image_format = ['.jpg', '.jpeg', '.png', '.tif'] + self.img_files = sorted(glob.glob('%s/*.*' % path)) + self.img_files = list( + filter( + lambda x: os.path.splitext(x)[1].lower() in image_format, + self.img_files)) + elif os.path.isfile(path): + self.img_files = [ + path, + ] + + # self.label_files = [x.replace('images', osp.join('obs', obid)).replace( + # '.png', '.txt').replace('.jpg', '.txt') for x in self.img_files] + self.label_files = [ + x.replace('images', + osp.join('obs', obid)).replace('.png', '.txt').replace( + '.jpg', '.txt').replace('train', + 'obs/COSTA_st/train') + for x in self.img_files + ] + + self.nF = len(self.img_files) # number of image files + self.transforms = T.Compose( + [T.ToTensor(), T.Normalize(opt.im_mean, opt.im_std)]) + self.use_lab = getattr(opt, 'use_lab', False) + if not img_size is None: + self.width = img_size[0] + self.height = img_size[1] + + def __getitem__(self, files_index): + img_path = self.img_files[files_index] + label_path = self.label_files[files_index] + return self.get_data(img_path, label_path) + + def get_data(self, img_path, label_path): + height = self.height + width = self.width + img_ori = cv2.imread(img_path) # BGR + if img_ori is None: + raise ValueError('File corrupt {}'.format(img_path)) + + h, w, _ = img_ori.shape + img, ratio, padw, padh = letterbox(img_ori, height=height, width=width) + + # Load labels + if os.path.isfile(label_path): + labels0 = np.loadtxt(label_path, dtype=np.float32).reshape(-1, 5) + # Normalized xywh to pixel xyxy format + labels = labels0.copy() + labels[:, + 0] = ratio * w * (labels0[:, 0] - labels0[:, 2] / 2) + padw + labels[:, + 1] = ratio * h * (labels0[:, 1] - labels0[:, 3] / 2) + padh + labels[:, + 2] = ratio * w * (labels0[:, 0] + labels0[:, 2] / 2) + padw + labels[:, + 3] = ratio * h * (labels0[:, 1] + labels0[:, 3] / 2) + padh + else: + labels = np.array([]) + nL = len(labels) + if nL > 0: + # convert xyxy to xywh + labels[:, 0:4] = xyxy2xywh(labels[:, 0:4].copy()) + labels[:, 0] /= width + labels[:, 1] /= height + labels[:, 2] /= width + labels[:, 3] /= height + + if self.use_lab: + img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) + img = np.array([ + img[:, :, 0], + ] * 3) + img = img.transpose(1, 2, 0) + img = img / 255. + img = np.ascontiguousarray(img[:, :, ::-1]) # BGR to RGB + if self.transforms is not None: + img = self.transforms(img) + + return img, labels, img_ori, (h, w) + + def __len__(self): + return self.nF # number of batches + + +class LoadImagesAndObsTAO: + def __init__(self, root, video_meta, obs, opt): + self.dataroot = root + self.img_ind = [x['id'] for x in video_meta] + self.img_files = [x['file_name'] for x in video_meta] + self.img_files = [osp.join(root, 'frames', x) for x in self.img_files] + self.obs = [obs.get(x, []) for x in self.img_ind] + self.use_lab = getattr(opt, 'use_lab', False) + self.transforms = T.Compose( + [T.ToTensor(), T.Normalize(opt.im_mean, opt.im_std)]) + + def __getitem__(self, index): + img_ori = cv2.imread(self.img_files[index]) + if img_ori is None: + raise ValueError('File corrupt {}'.format(img_path)) + + h, w, _ = img_ori.shape + img = img_ori + if self.use_lab: + img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) + img = np.array([ + img[:, :, 0], + ] * 3) + img = img.transpose(1, 2, 0) + img = img / 255. + img = np.ascontiguousarray(img[:, :, ::-1]) # BGR to RGB + if self.transforms is not None: + img = self.transforms(img) + + obs = self.obs[index] + if len(obs) == 0: + labels = np.array([[0, 0, 1, 1, -1, -1]]) + else: + boxes = np.array([x.get('bbox', [0, 0, 1, 1]) for x in obs]) + scores = np.array([x.get('score', 0) for x in obs])[:, None] + cat_ids = np.array([x.get('category_id', -1) for x in obs])[:, + None] + labels = np.concatenate([boxes, scores, cat_ids], axis=1) + if len(labels) > 0: + # From tlwh to xywh: (x,y) is the box center + labels[:, 0] = labels[:, 0] + labels[:, 2] / 2 + labels[:, 1] = labels[:, 1] + labels[:, 3] / 2 + labels[:, 0] /= w + labels[:, 1] /= h + labels[:, 2] /= w + labels[:, 3] /= h + + return img, labels, img_ori, (h, w) + + def __len__(self): + return len(self.img_files) + + +class LoadImagesAndMaskObsVIS: + def __init__(self, path, info, obs, opt): + self.dataroot = path + self.nF = info['length'] + self.img_files = [osp.join(path, p) for p in info['file_names']] + self.obsbyobj = obs + self.transforms = T.Compose( + [T.ToTensor(), T.Normalize(opt.im_mean, opt.im_std)]) + self.use_lab = getattr(opt, 'use_lab', False) + + def __getitem__(self, idx): + img_ori = cv2.imread(self.img_files[idx]) + if img_ori is None: + raise ValueError('File corrupt {}'.format(img_path)) + + h, w, _ = img_ori.shape + img = img_ori + if self.use_lab: + img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) + img = np.array([ + img[:, :, 0], + ] * 3) + img = img.transpose(1, 2, 0) + img = img / 255. + img = np.ascontiguousarray(img[:, :, ::-1]) # BGR to RGB + if self.transforms is not None: + img = self.transforms(img) + + labels = list() + for obj in self.obsbyobj: + RLE = obj['segmentations'][idx] + if RLE: labels.append(mask_utils.decode(RLE)) + else: labels.append(np.zeros((h, w), dtype=np.uint8)) + labels = np.stack(labels) + + return img, labels, img_ori, (h, w) + + def __len__(self): + return self.nF + + +class LoadImagesAndMaskObsMOTS(LoadImagesAndObs): + def __init__(self, path, opt): + super(LoadImagesAndMaskObsMOTS, self).__init__(path, opt) + + def get_data(self, img_path, label_path): + img_ori = cv2.imread(img_path) # BGR + if img_ori is None: + raise ValueError('File corrupt {}'.format(img_path)) + h, w, _ = img_ori.shape + + img = img_ori + if self.use_lab: + img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) + img = np.array([ + img[:, :, 0], + ] * 3) + img = img.transpose(1, 2, 0) + img = img / 255. + img = np.ascontiguousarray( + img[:, :, ::-1]) # BGR to RGB eg. (1080, 1920, 3) + if self.transforms is not None: + img = self.transforms(img) + + # Load labels + labels = [] + if os.path.isfile(label_path): + with open(label_path, 'r') as f: + for line in f: + labels.append(line.strip().split()) + nL = len(labels) + if nL > 0: + labels = [{'size':(int(h),int(w)), 'counts':m} for \ + _, _,cid,h,w,m in labels if cid=='2'] + labels = [mask_utils.decode(rle) for rle in labels] + labels = np.stack(labels) + return img, labels, img_ori, (h, w) + + +class LoadImagesAndPoseObs(LoadImagesAndObs): + def __init__(self, obs_jpath, opt): + fjson = open(obs_jpath, 'r') + self.infoj = json.load(fjson)['annolist'] + self.dataroot = opt.data_root + self.nF = len(self.infoj) + self.img_files = [ + osp.join(opt.data_root, p['image'][0]['name']) for p in self.infoj + ] + self.transforms = T.Compose( + [T.ToTensor(), T.Normalize(opt.im_mean, opt.im_std)]) + self.use_lab = getattr(opt, 'use_lab', False) + + def __getitem__(self, idx): + img_ori = cv2.imread(self.img_files[idx]) + if img_ori is None: + raise ValueError('File corrupt {}'.format(img_path)) + + h, w, _ = img_ori.shape + img = img_ori + + if self.use_lab: + img = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) + img = np.array([ + img[:, :, 0], + ] * 3) + img = img.transpose(1, 2, 0) + + img = img / 255. + img = np.ascontiguousarray(img[:, :, ::-1]) # BGR to RGB + if self.transforms is not None: + img = self.transforms(img) + + info_label = self.infoj[idx]['annorect'] + nobj = len(info_label) + labels = list() + labels = [l['annopoints'][0]['point'] for l in info_label] + + return img, labels, img_ori, (h, w) + + +def letterbox( + img, + height=608, + width=1088, + color=(127.5, 127.5, + 127.5)): # resize a rectangular image to a padded rectangular + shape = img.shape[:2] # shape = [height, width] + ratio = min(float(height) / shape[0], float(width) / shape[1]) + new_shape = (round(shape[1] * ratio), round(shape[0] * ratio) + ) # new_shape = [width, height] + dw = (width - new_shape[0]) / 2 # width padding + dh = (height - new_shape[1]) / 2 # height padding + top, bottom = round(dh - 0.1), round(dh + 0.1) + left, right = round(dw - 0.1), round(dw + 0.1) + img = cv2.resize(img, new_shape, + interpolation=cv2.INTER_AREA) # resized, no border + img = cv2.copyMakeBorder(img, + top, + bottom, + left, + right, + cv2.BORDER_CONSTANT, + value=color) # padded rectangular + return img, ratio, dw, dh diff --git a/OpenPVSG/models/unitrack/eval/mots/Evaluator.py b/OpenPVSG/models/unitrack/eval/mots/Evaluator.py new file mode 100644 index 0000000000000000000000000000000000000000..2c49a0d4e7c5c31d2bbb78f29282fec9b242ac99 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/Evaluator.py @@ -0,0 +1,229 @@ +import pdb +import sys, os +sys.path.append(os.getcwd()) +import argparse + +import traceback +import time +import pickle +import pandas as pd +import glob +from os import path +import numpy as np + + + +class Evaluator(object): + """ The `Evaluator` class runs evaluation per sequence and computes the overall performance on the benchmark""" + def __init__(self): + pass + + def run(self, benchmark_name = None , gt_dir = None, res_dir = None, save_pkl = None, eval_mode = "train", seqmaps_dir = "seqmaps"): + """ + Params + ----- + benchmark_name: Name of benchmark, e.g. MOT17 + gt_dir: directory of folders with gt data, including the c-files with sequences + res_dir: directory with result files + .txt + .txt + ... + .txt + eval_mode: + seqmaps_dir: + seq_file: File name of file containing sequences, e.g. 'c10-train.txt' + save_pkl: path to output directory for final results + """ + + start_time = time.time() + + self.benchmark_gt_dir = gt_dir + self.seq_file = "{}-{}.txt".format(benchmark_name, eval_mode) + + res_dir = res_dir + self.benchmark_name = benchmark_name + self.seqmaps_dir = seqmaps_dir + + self.mode = eval_mode + + self.datadir = os.path.join(gt_dir, self.mode) + + # getting names of sequences to evaluate + error_traceback = "" + assert self.mode in ["train", "test", "all"], "mode: %s not valid " %s + + print("Evaluating Benchmark: %s" % self.benchmark_name) + + # ====================================================== + # Handle evaluation + # ====================================================== + + + + # load list of all sequences + self.sequences = os.listdir(self.datadir) + + self.gtfiles = [] + self.tsfiles = [] + for seq in self.sequences: + gtf = os.path.join(self.benchmark_gt_dir, self.mode ,seq, 'gt/gt.txt') + if path.exists(gtf): self.gtfiles.append(gtf) + else: raise Exception("Ground Truth %s missing" % gtf) + tsf = os.path.join( res_dir, "%s.txt" % seq) + if path.exists(gtf): self.tsfiles.append(tsf) + else: raise Exception("Result file %s missing" % tsf) + + + print('Found {} ground truth files and {} test files.'.format(len(self.gtfiles), len(self.tsfiles))) + print( self.tsfiles) + + self.MULTIPROCESSING = False + MAX_NR_CORES = 10 + # set number of core for mutliprocessing + if self.MULTIPROCESSING: self.NR_CORES = np.minimum( MAX_NR_CORES, len(self.tsfiles)) + try: + + """ run evaluation """ + results = self.eval() + + # calculate overall results + results_attributes = self.Overall_Results.metrics.keys() + + for attr in results_attributes: + """ accumulate evaluation values over all sequences """ + try: + self.Overall_Results.__dict__[attr] = sum(obj.__dict__[attr] for obj in self.results) + except: + pass + cache_attributes = self.Overall_Results.cache_dict.keys() + for attr in cache_attributes: + """ accumulate cache values over all sequences """ + try: + self.Overall_Results.__dict__[attr] = self.Overall_Results.cache_dict[attr]['func']([obj.__dict__[attr] for obj in self.results]) + except: + pass + print("evaluation successful") + + + # Compute clearmot metrics for overall and all sequences + for res in self.results: + res.compute_clearmot() + self.Overall_Results.compute_clearmot() + + + self.accumulate_df(type = "mail") + self.failed = False + error = None + + + except Exception as e: + print(str(traceback.format_exc())) + print ("
Evaluation failed!
") + + error_traceback+= str(traceback.format_exc()) + self.failed = True + self.summary = None + + end_time=time.time() + + self.duration = (end_time - start_time)/60. + + + + # ====================================================== + # Collect evaluation errors + # ====================================================== + if self.failed: + + startExc = error_traceback.split("") + error_traceback = [m.split("")[0] for m in startExc[1:]] + + error = "" + + for err in error_traceback: + error+="Error: %s" % err + + + print( "Error Message", error) + self.error = error + print("ERROR %s" % error) + + + print ("Evaluation Finished") + print("Your Results") + print(self.render_summary()) + # save results if path set + if save_pkl: + + + self.Overall_Results.save_dict(os.path.join( save_pkl, "%s-%s-overall.pkl" % (self.benchmark_name, self.mode))) + for res in self.results: + res.save_dict(os.path.join( save_pkl, "%s-%s-%s.pkl" % (self.benchmark_name, self.mode, res.seqName))) + print("Successfully save results") + + return self.Overall_Results, self.results + def eval(self): + raise NotImplementedError + + + def accumulate_df(self, type = None): + """ create accumulated dataframe with all sequences """ + for k, res in enumerate(self.results): + res.to_dataframe(display_name = True, type = type ) + if k == 0: summary = res.df + else: summary = summary.append(res.df) + summary = summary.sort_index() + + + self.Overall_Results.to_dataframe(display_name = True, type = type ) + + self.summary = summary.append(self.Overall_Results.df) + + + + def render_summary( self, buf = None): + """Render metrics summary to console friendly tabular output. + + Params + ------ + summary : pd.DataFrame + Dataframe containing summaries in rows. + + Kwargs + ------ + buf : StringIO-like, optional + Buffer to write to + formatters : dict, optional + Dicionary defining custom formatters for individual metrics. + I.e `{'mota': '{:.2%}'.format}`. You can get preset formatters + from MetricsHost.formatters + namemap : dict, optional + Dictionary defining new metric names for display. I.e + `{'num_false_positives': 'FP'}`. + + Returns + ------- + string + Formatted string + """ + + output = self.summary.to_string( + buf=buf, + formatters=self.Overall_Results.formatters, + justify = "left" + ) + + return output +def run_metrics( metricObject, args ): + """ Runs metric for individual sequences + Params: + ----- + metricObject: metricObject that has computer_compute_metrics_per_sequence function + args: dictionary with args for evaluation function + """ + metricObject.compute_metrics_per_sequence(**args) + return metricObject + + +if __name__ == "__main__": + Evaluator() diff --git a/OpenPVSG/models/unitrack/eval/mots/LICENSE b/OpenPVSG/models/unitrack/eval/mots/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7a6ba382833f2a507cbb9c3dd1827dfa926ac1e6 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 Visual Computing Institute + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/OpenPVSG/models/unitrack/eval/mots/MOTSVisualization.py b/OpenPVSG/models/unitrack/eval/mots/MOTSVisualization.py new file mode 100644 index 0000000000000000000000000000000000000000..c351418a1350dccae392b54323596584b23adfea --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/MOTSVisualization.py @@ -0,0 +1,75 @@ +import sys +from Visualize import Visualizer +from mots_common.io import load_sequences, load_seqmap, load_txt +import pycocotools.mask as rletools +import glob +import os +import cv2 +import colorsys +import numpy as np + +def apply_mask(image, mask, color, alpha=0.5): + """ + Apply the given mask to the image. + """ + for c in range(3): + image[:, :, c] = np.where(mask == 1, image[:, :, c] * (1 - alpha) + alpha * color[c],image[:, :, c]) + return image + + +class MOTSVisualizer(Visualizer): + + def load(self, FilePath): + return load_txt(FilePath) + + + + def drawResults(self, im = None, t = 0): + self.draw_boxes = False + + + for obj in self.resFile[t]: + + color = self.colors[obj.track_id % len(self.colors)] + + color = tuple([int(c*255) for c in color]) + + + if obj.class_id == 1: + category_name = "Car" + elif obj.class_id == 2: + category_name = "Ped" + else: + category_name = "Ignore" + color = (0.7*255, 0.7*255, 0.7*255) + + if obj.class_id == 1 or obj.class_id == 2: # Don't show boxes or ids for ignore regions + x, y, w, h = rletools.toBbox(obj.mask) + + pt1=(int(x),int(y)) + pt2=(int(x+w),int(y+h)) + + category_name += ":" + str(obj.track_id) + cv2.putText(im, category_name, (int(x + 0.5 * w), int( y + 0.5 * h)), cv2.FONT_HERSHEY_TRIPLEX,self.imScale,color,thickness =2) + if self.draw_boxes: + cv2.rectangle(im,pt1,pt2,color,2) + + + binary_mask = rletools.decode(obj.mask) + + im = apply_mask(im, binary_mask, color) + return im + +if __name__ == "__main__": + visualizer = MOTSVisualizer( + seqName = "MOTS20-11", + FilePath ="data/MOTS/train/MOTS20-11/gt/gt.txt", + image_dir = "data/MOTS/train/MOTS20-11/img1", + mode = "gt", + output_dir = "vid") + + visualizer.generateVideo( + displayTime = True, + displayName = "seg", + showOccluder = True, + fps = 25 ) diff --git a/OpenPVSG/models/unitrack/eval/mots/MOTS_metrics.py b/OpenPVSG/models/unitrack/eval/mots/MOTS_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..6b72ab726c89ab63ba87868d08e178218fe3c2aa --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/MOTS_metrics.py @@ -0,0 +1,573 @@ +import math +from collections import defaultdict +import pycocotools.mask as rletools +from mots_common.io import SegmentedObject +from mots_common.io import load_seqmap, load_sequences, load_txt +from Metrics import Metrics +import os, sys +import numpy as np +from scipy.optimize import linear_sum_assignment as linear_assignment + +# we only consider pedestrians +IGNORE_CLASS = 10 +CLASS_ID = 2 + + + +def mask_iou(a, b, criterion="union"): + is_crowd = criterion != "union" + return rletools.iou([a.mask], [b.mask], [is_crowd])[0][0] + + + + +class MOTSMetrics(Metrics): + def __init__(self, seqName = None): + super().__init__() + if seqName: + self.seqName = seqName + else: self.seqName = 0 + # Evaluation metrics + + self.register(name = "sMOTSA", formatter='{:.2f}'.format) + self.register(name = "MOTSA", formatter='{:.2f}'.format) + self.register(name = "MOTSP", formatter='{:.2f}'.format) + self.register(name = "MOTSAL", formatter='{:.2f}'.format, write_mail = False) + self.register(name = "MODSA", formatter='{:.2f}'.format, write_mail = False) + self.register(name = "MODSP", formatter='{:.2f}'.format, write_mail = False) + + + self.register(name = "IDF1", formatter='{:.2f}'.format) + self.register(name = "IDTP", formatter='{:.2f}'.format, write_mail = False) + + + self.register(name = "MT", formatter='{:.0f}'.format) + self.register(name = "PT", formatter='{:.0f}'.format, write_mail = False ) + self.register(name = "ML", formatter='{:.0f}'.format) + + self.register(name = "MTR", formatter='{:.2f}'.format) + self.register(name = "PTR", formatter='{:.2f}'.format) + self.register(name = "MLR", formatter='{:.2f}'.format) + + + self.register(name = "n_gt_trajectories", display_name = "GT",formatter='{:.0f}'.format, write_mail = True) + + self.register(name = "tp", display_name="TP", formatter='{:.0f}'.format) # number of true positives + self.register(name = "fp", display_name="FP", formatter='{:.0f}'.format) # number of false positives + self.register(name = "fn", display_name="FN", formatter='{:.0f}'.format) # number of false negatives + + self.register(name = "recall", display_name="Rcll", formatter='{:.2f}'.format) + self.register(name = "precision", display_name="Prcn", formatter='{:.2f}'.format) + + self.register(name = "F1", display_name="F1", formatter='{:.2f}'.format, write_mail = False) + self.register(name = "FAR", formatter='{:.2f}'.format, write_mail = False) + self.register(name = "total_cost", display_name="COST", formatter='{:.0f}'.format, write_mail = False) + self.register(name = "fragments", display_name="FM", formatter='{:.0f}'.format) + self.register(name = "fragments_rel", display_name="FMR", formatter='{:.2f}'.format) + self.register(name = "id_switches", display_name="IDSW", formatter='{:.0f}'.format) + + self.register(name = "id_switches_rel", display_name="IDSWR", formatter='{:.1f}'.format) + + self.register(name = "n_tr_trajectories", display_name = "TR", formatter='{:.0f}'.format, write_mail = False) + self.register(name = "total_num_frames", display_name="TOTAL_NUM", formatter='{:.0f}'.format, write_mail = False) + + + self.register(name = "n_gt", display_name = "GT_OBJ", formatter='{:.0f}'.format, write_mail = False) # number of ground truth detections + self.register(name = "n_tr", display_name = "TR_OBJ", formatter='{:.0f}'.format, write_mail = False) # number of tracker detections minus ignored tracker detections + self.register(name = "n_itr",display_name="IGNORED", formatter='{:.0f}'.format, write_mail = False) # number of ignored tracker detections + self.register(name = "id_n_tr", display_name = "ID_TR_OBJ", formatter='{:.0f}'.format, write_mail = False) + self.register(name = "nbox_gt", display_name = "NBOX_GT", formatter='{:.0f}'.format, write_mail = False) + + + + + + def compute_clearmot(self): + # precision/recall etc. + if (self.fp + self.tp) == 0 or (self.tp + self.fn) == 0: + self.recall = 0. + self.precision = 0. + else: + self.recall = self.tp / float(self.tp + self.fn) * 100. + self.precision = self.tp / float(self.fp + self.tp) * 100. + if (self.recall + self.precision) == 0: + self.F1 = 0. + else: + self.F1 = (2. * (self.precision * self.recall) / (self.precision + self.recall) ) * 100. + if self.total_num_frames == 0: + self.FAR = "n/a" + else: + self.FAR = (self.fp / float(self.total_num_frames) ) + # compute CLEARMOT + if self.n_gt == 0: + self.MOTSA = -float("inf") + self.MODSA = -float("inf") + self.sMOTSA = -float("inf") + else: + self.MOTSA = (1 - (self.fn + self.fp + self.id_switches) / float(self.n_gt) ) * 100. + self.MODSA = (1 - (self.fn + self.fp) / float(self.n_gt)) * 100. + self.sMOTSA = ((self.total_cost - self.fp - self.id_switches) / float(self.n_gt)) * 100. + if self.tp == 0: + self.MOTSP = float("inf") + else: + self.MOTSP = self.total_cost / float(self.tp) * 100. + if self.n_gt != 0: + if self.id_switches == 0: + self.MOTSAL = (1 - (self.fn + self.fp + self.id_switches) / float(self.n_gt)) * 100. + else: + self.MOTSAL = (1 - (self.fn + self.fp + math.log10(self.id_switches)) / float( + self.n_gt))*100. + else: + self.MOTSAL = -float("inf") + + if self.total_num_frames == 0: + self.MODSP = "n/a" + else: + self.MODSP = self.MODSP / float(self.total_num_frames) * 100. + + + + + if self.n_gt_trajectories == 0: + self.MTR = 0. + self.PTR = 0. + self.MLR = 0. + else: + self.MTR = self.MT * 100. / float(self.n_gt_trajectories) + self.PTR = self.PT * 100. / float(self.n_gt_trajectories) + self.MLR = self.ML * 100. / float(self.n_gt_trajectories) + + + # calculate relative IDSW and FM + + if self.recall != 0: + self.id_switches_rel = self.id_switches/self.recall*100 + self.fragments_rel = self.fragments/self.recall* 100 + + else: + self.id_switches_rel = float("inf") + self.fragments_rel = float("inf") + + + + + # IDF1 + if self.n_gt_trajectories == 0: + self.IDF1 = 0. + else: + self.IDF1 = (2 * self.IDTP) / (self.nbox_gt + self.id_n_tr) * 100. + return self + + + + + # go through all frames and associate ground truth and tracker results + + def compute_metrics_per_sequence(self, sequence, pred_file, gt_file, gtDataDir, benchmark_name, + ignore_class = IGNORE_CLASS, class_id = CLASS_ID, overlap_function = mask_iou): + + gt_seq = load_txt(gt_file) + results_seq = load_txt(pred_file) + + + # load information about sequence + import configparser + config = configparser.ConfigParser() + + + config.read(os.path.join(gtDataDir, "seqinfo.ini")) + + max_frames = int(config['Sequence']["seqlength"]) + + self.total_num_frames = max_frames + 1 + + seq_trajectories = defaultdict(list) + + # To count number of track ids + gt_track_ids = set() + tr_track_ids = set() + + # Statistics over the current sequence + seqtp = 0 + seqfn = 0 + seqfp = 0 + seqitr = 0 + + n_gts = 0 + n_trs = 0 + + frame_to_ignore_region = {} + + # Iterate over frames in this sequence + for f in range(max_frames + 1): + g = [] + dc = [] + t = [] + + if f in gt_seq: + for obj in gt_seq[f]: + if obj.class_id == ignore_class: + dc.append(obj) + elif obj.class_id == class_id: + g.append(obj) + gt_track_ids.add(obj.track_id) + if f in results_seq: + for obj in results_seq[f]: + if obj.class_id == class_id: + t.append(obj) + tr_track_ids.add(obj.track_id) + + # Handle ignore regions as one large ignore region + dc = SegmentedObject(mask=rletools.merge([d.mask for d in dc], intersect=False), + class_id=ignore_class, track_id=ignore_class) + frame_to_ignore_region[f] = dc + + tracks_valid = [False for _ in range(len(t))] + + # counting total number of ground truth and tracker objects + self.n_gt += len(g) + self.n_tr += len(t) + + n_gts += len(g) + n_trs += len(t) + + # tmp variables for sanity checks and MODSP computation + tmptp = 0 + tmpfp = 0 + tmpfn = 0 + tmpc = 0 # this will sum up the overlaps for all true positives + tmpcs = [0] * len(g) # this will save the overlaps for all true positives + # the reason is that some true positives might be ignored + # later such that the corrsponding overlaps can + # be subtracted from tmpc for MODSP computation + + # To associate, simply take for each ground truth the (unique!) detection with IoU>0.5 if it exists + + # all ground truth trajectories are initially not associated + # extend groundtruth trajectories lists (merge lists) + for gg in g: + seq_trajectories[gg.track_id].append(-1) + num_associations = 0 + for row, gg in enumerate(g): + for col, tt in enumerate(t): + c = overlap_function(gg, tt) + if c > 0.5: + tracks_valid[col] = True + self.total_cost += c + tmpc += c + tmpcs[row] = c + seq_trajectories[g[row].track_id][-1] = t[col].track_id + + # true positives are only valid associations + self.tp += 1 + tmptp += 1 + + num_associations += 1 + + # associate tracker and DontCare areas + # ignore tracker in neighboring classes + nignoredtracker = 0 # number of ignored tracker detections + + for i, tt in enumerate(t): + overlap = overlap_function(tt, dc, "a") + if overlap > 0.5 and not tracks_valid[i]: + nignoredtracker += 1 + + # count the number of ignored tracker objects + self.n_itr += nignoredtracker + + # false negatives = non-associated gt instances + # + tmpfn += len(g) - num_associations + self.fn += len(g) - num_associations + + # false positives = tracker instances - associated tracker instances + # mismatches (mme_t) + tmpfp += len(t) - tmptp - nignoredtracker + self.fp += len(t) - tmptp - nignoredtracker + # tmpfp = len(t) - tmptp - nignoredtp # == len(t) - (tp - ignoredtp) - ignoredtp + # self.fp += len(t) - tmptp - nignoredtp + + # update sequence data + seqtp += tmptp + seqfp += tmpfp + seqfn += tmpfn + seqitr += nignoredtracker + + # sanity checks + # - the number of true positives minues ignored true positives + # should be greater or equal to 0 + # - the number of false negatives should be greater or equal to 0 + # - the number of false positives needs to be greater or equal to 0 + # otherwise ignored detections might be counted double + # - the number of counted true positives (plus ignored ones) + # and the number of counted false negatives (plus ignored ones) + # should match the total number of ground truth objects + # - the number of counted true positives (plus ignored ones) + # and the number of counted false positives + # plus the number of ignored tracker detections should + # match the total number of tracker detections + if tmptp < 0: + print(tmptp) + raise NameError("Something went wrong! TP is negative") + if tmpfn < 0: + print(tmpfn, len(g), num_associations) + raise NameError("Something went wrong! FN is negative") + if tmpfp < 0: + print(tmpfp, len(t), tmptp, nignoredtracker) + raise NameError("Something went wrong! FP is negative") + if tmptp + tmpfn != len(g): + print("seqname", seq_name) + print("frame ", f) + print("TP ", tmptp) + print("FN ", tmpfn) + print("FP ", tmpfp) + print("nGT ", len(g)) + print("nAss ", num_associations) + raise NameError("Something went wrong! nGroundtruth is not TP+FN") + if tmptp + tmpfp + nignoredtracker != len(t): + print(seq_name, f, len(t), tmptp, tmpfp) + print(num_associations) + raise NameError("Something went wrong! nTracker is not TP+FP") + + # compute MODSP + MODSP_f = 1 + if tmptp != 0: + MODSP_f = tmpc / float(tmptp) + self.MODSP += MODSP_f + + assert len(seq_trajectories) == len(gt_track_ids) + self.n_gt_trajectories = len(gt_track_ids) + self.n_tr_trajectories = len(tr_track_ids) + + # compute MT/PT/ML, fragments, idswitches for all groundtruth trajectories + if len(seq_trajectories) != 0: + for g in seq_trajectories.values(): + # all frames of this gt trajectory are not assigned to any detections + if all([this == -1 for this in g]): + self.ML += 1 + continue + # compute tracked frames in trajectory + last_id = g[0] + # first detection (necessary to be in gt_trajectories) is always tracked + tracked = 1 if g[0] >= 0 else 0 + for f in range(1, len(g)): + if last_id != g[f] and last_id != -1 and g[f] != -1: + self.id_switches += 1 + if f < len(g) - 1 and g[f - 1] != g[f] and last_id != -1 and g[f] != -1 and g[f + 1] != -1: + self.fragments += 1 + if g[f] != -1: + tracked += 1 + last_id = g[f] + # handle last frame; tracked state is handled in for loop (g[f]!=-1) + if len(g) > 1 and g[f - 1] != g[f] and last_id != -1 and g[f] != -1: + self.fragments += 1 + + # compute MT/PT/ML + tracking_ratio = tracked / float(len(g)) + if tracking_ratio > 0.8: + self.MT += 1 + elif tracking_ratio < 0.2: + self.ML += 1 + else: # 0.2 <= tracking_ratio <= 0.8 + self.PT += 1 + + # compute IDF1 + idf1, idtp, nbox_gt, id_n_tr = compute_idf1_and_idtp_for_sequence(gt_seq, results_seq, gt_track_ids, tr_track_ids, frame_to_ignore_region) + self.IDTP = idtp + #self.id_ign = id_ign + self.id_n_tr = id_n_tr + self.nbox_gt = nbox_gt + + return self + + + +### IDF1 stuff +### code below adapted from https://github.com/shenh10/mot_evaluation/blob/5dd51e5cb7b45992774ea150e4386aa0b02b586f/utils/measurements.py +def compute_idf1_and_idtp_for_sequence(frame_to_gt, frame_to_pred, gt_ids, st_ids, frame_to_ignore_region): + frame_to_can_be_ignored = {} + for t in frame_to_pred.keys(): + preds_t = frame_to_pred[t] + pred_masks_t = [p.mask for p in preds_t] + ignore_region_t = frame_to_ignore_region[t].mask + overlap = np.squeeze(rletools.iou(pred_masks_t, [ignore_region_t], [1]), axis=1) + frame_to_can_be_ignored[t] = overlap > 0.5 + + gt_ids = sorted(gt_ids) + st_ids = sorted(st_ids) + groundtruth = [[] for _ in gt_ids] + prediction = [[] for _ in st_ids] + for t, gts_t in frame_to_gt.items(): + for gt_t in gts_t: + if gt_t.track_id in gt_ids: + groundtruth[gt_ids.index(gt_t.track_id)].append((t, gt_t)) + for t in frame_to_pred.keys(): + preds_t = frame_to_pred[t] + can_be_ignored_t = frame_to_can_be_ignored[t] + assert len(preds_t) == len(can_be_ignored_t) + for pred_t, ign_t in zip(preds_t, can_be_ignored_t): + if pred_t.track_id in st_ids: + prediction[st_ids.index(pred_t.track_id)].append((t, pred_t, ign_t)) + for gt in groundtruth: + gt.sort(key=lambda x: x[0]) + for pred in prediction: + pred.sort(key=lambda x: x[0]) + + n_gt = len(gt_ids) + n_st = len(st_ids) + cost = np.zeros((n_gt + n_st, n_st + n_gt), dtype=float) + cost[n_gt:, :n_st] = sys.maxsize # float('inf') + cost[:n_gt, n_st:] = sys.maxsize # float('inf') + + fp = np.zeros(cost.shape) + fn = np.zeros(cost.shape) + ign = np.zeros(cost.shape) + # cost matrix of all trajectory pairs + cost_block, fp_block, fn_block, ign_block = cost_between_gt_pred(groundtruth, prediction) + cost[:n_gt, :n_st] = cost_block + fp[:n_gt, :n_st] = fp_block + fn[:n_gt, :n_st] = fn_block + ign[:n_gt, :n_st] = ign_block + + # computed trajectory match no groundtruth trajectory, FP + for i in range(n_st): + #cost[i + n_gt, i] = prediction[i].shape[0] + #fp[i + n_gt, i] = prediction[i].shape[0] + # don't count fp in case of ignore region + fps = sum([~x[2] for x in prediction[i]]) + ig = sum([x[2] for x in prediction[i]]) + cost[i + n_gt, i] = fps + fp[i + n_gt, i] = fps + ign[i + n_gt, i] = ig + + # groundtruth trajectory match no computed trajectory, FN + for i in range(n_gt): + #cost[i, i + n_st] = groundtruth[i].shape[0] + #fn[i, i + n_st] = groundtruth[i].shape[0] + cost[i, i + n_st] = len(groundtruth[i]) + fn[i, i + n_st] = len(groundtruth[i]) + # TODO: add error handling here? + matched_indices = linear_assignment(cost) + #nbox_gt = sum([groundtruth[i].shape[0] for i in range(n_gt)]) + #nbox_st = sum([prediction[i].shape[0] for i in range(n_st)]) + nbox_gt = sum([len(groundtruth[i]) for i in range(n_gt)]) + + nbox_st = sum([len(prediction[i]) for i in range(n_st)]) + + #IDFP = 0 + IDFN = 0 + id_ign = 0 + for matched in zip(*matched_indices): + #IDFP += fp[matched[0], matched[1]] + IDFN += fn[matched[0], matched[1]] + # exclude detections which are not matched and ignored from total count + id_ign += ign[matched[0], matched[1]] + id_n_tr = nbox_st - id_ign + + IDTP = nbox_gt - IDFN + + IDF1 = 2 * IDTP / (nbox_gt + id_n_tr) + + return IDF1, IDTP, nbox_gt, id_n_tr + + + + +def cost_between_gt_pred(groundtruth, prediction): + n_gt = len(groundtruth) + n_st = len(prediction) + cost = np.zeros((n_gt, n_st), dtype=float) + fp = np.zeros((n_gt, n_st), dtype=float) + fn = np.zeros((n_gt, n_st), dtype=float) + ign = np.zeros((n_gt, n_st), dtype=float) + for i in range(n_gt): + for j in range(n_st): + fp[i, j], fn[i, j], ign[i, j] = cost_between_trajectories(groundtruth[i], prediction[j]) + cost[i, j] = fp[i, j] + fn[i, j] + return cost, fp, fn, ign + + +def cost_between_trajectories(traj1, traj2): + #[npoints1, dim1] = traj1.shape + #[npoints2, dim2] = traj2.shape + npoints1 = len(traj1) + npoints2 = len(traj2) + # find start and end frame of each trajectories + #start1 = traj1[0, 0] + #end1 = traj1[-1, 0] + #start2 = traj2[0, 0] + #end2 = traj2[-1, 0] + times1 = [x[0] for x in traj1] + times2 = [x[0] for x in traj2] + start1 = min(times1) + start2 = min(times2) + end1 = max(times1) + end2 = max(times2) + + ign = [traj2[i][2] for i in range(npoints2)] + + # check frame overlap + #has_overlap = max(start1, start2) < min(end1, end2) + # careful, changed this to <=, but I think now it's right + has_overlap = max(start1, start2) <= min(end1, end2) + if not has_overlap: + fn = npoints1 + #fp = npoints2 + # disregard detections which can be ignored + fp = sum([~x for x in ign]) + ig = sum(ign) + return fp, fn, ig + + # gt trajectory mapping to st, check gt missed + matched_pos1 = corresponding_frame(times1, npoints1, times2, npoints2) + # st trajectory mapping to gt, check computed one false alarms + matched_pos2 = corresponding_frame(times2, npoints2, times1, npoints1) + overlap1 = compute_overlap(traj1, traj2, matched_pos1) + overlap2 = compute_overlap(traj2, traj1, matched_pos2) + # FN + fn = sum([1 for i in range(npoints1) if overlap1[i] < 0.5]) + # FP + # don't count false positive in case of ignore region + unmatched = [overlap2[i] < 0.5 for i in range(npoints2)] + #fp = sum([1 for i in range(npoints2) if overlap2[i] < 0.5 and not traj2[i][2]]) + fp = sum([1 for i in range(npoints2) if unmatched[i] and not ign[i]]) + ig = sum([1 for i in range(npoints2) if unmatched[i] and ign[i]]) + return fp, fn, ig + + +def corresponding_frame(traj1, len1, traj2, len2): + """ + Find the matching position in traj2 regarding to traj1 + Assume both trajectories in ascending frame ID + """ + p1, p2 = 0, 0 + loc = -1 * np.ones((len1,), dtype=int) + while p1 < len1 and p2 < len2: + if traj1[p1] < traj2[p2]: + loc[p1] = -1 + p1 += 1 + elif traj1[p1] == traj2[p2]: + loc[p1] = p2 + p1 += 1 + p2 += 1 + else: + p2 += 1 + return loc + + +def compute_overlap(traj1, traj2, matched_pos): + """ + Compute the loss hit in traj2 regarding to traj1 + """ + overlap = np.zeros((len(matched_pos),), dtype=float) + for i in range(len(matched_pos)): + if matched_pos[i] == -1: + continue + else: + mask1 = traj1[i][1].mask + mask2 = traj2[matched_pos[i]][1].mask + iou = rletools.iou([mask1], [mask2], [False])[0][0] + overlap[i] = iou + return overlap + diff --git a/OpenPVSG/models/unitrack/eval/mots/Metrics.py b/OpenPVSG/models/unitrack/eval/mots/Metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..f020744f8f5aceff783c02857a84ebc7a434500f --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/Metrics.py @@ -0,0 +1,149 @@ +from __future__ import division +from collections import OrderedDict, Iterable +import pandas as pd +import numpy as np +import pickle + +class Metrics(object): + def __init__(self): + self.metrics = OrderedDict() + self.cache_dict = OrderedDict() + + + def register(self, name=None, value=None, formatter=None, + display_name=None, write_db = True, write_mail = True): + """Register a new metric. + Params + ------ + name: str + Name of the metric. Name is used for computation and set as attribute. + display_name: str or None + Disoplay name of variable written in db and mail + value: + formatter: + Formatter to present value of metric. E.g. `'{:.2f}'.format` + write_db: boolean, default = True + Write value into db + write_mail: boolean, default = True + Write metric in result mail to user + """ + assert not name is None, 'No name specified'.format(name) + + if not value: + value = 0 + + self.__setattr__( name, value) + + if not display_name: display_name = name + self.metrics[name] = { + 'name' : name, + 'write_db' : write_db, + 'formatter' : formatter, + 'write_mail' : write_mail, + 'display_name' : display_name + } + + def cache(self, name=None, value=None, func=None): + assert not name is None, 'No name specified'.format(name) + + + self.__setattr__( name, value) + + + self.cache_dict[name] = { + 'name' : name, + 'func' : func + } + + + + def __call__(self, name): + return self.metrics[name] + + @property + def names(self): + """Returns the name identifiers of all registered metrics.""" + return [v['name'] for v in self.metrics.values()] + + @property + def display_names(self): + """Returns the display name identifiers of all registered metrics.""" + return [v['display_name'] for v in self.metrics.values()] + + + @property + def formatters(self): + """Returns the formatters for all metrics that have associated formatters.""" + return dict([(v['display_name'], v['formatter']) for k, v in self.metrics.items() if not v['formatter'] is None]) + + #@property + def val_dict(self, display_name = False, object = "metrics"): + """Returns dictionary of all registered values of object name or display_name as key. + Params + ------ + + display_name: boolean, default = False + If True, display_name of keys in dict. (default names) + object: "cache" or "metrics", default = "metrics" + """ + if display_name: key_string = "display_name" + else: key_string = "name" + print("object dict: ", object) + val_dict = dict([(self.__getattribute__(object)[key][key_string], self.__getattribute__(key)) for key in self.__getattribute__(object).keys() ]) + return val_dict + + def val_db(self, display_name = True): + """Returns dictionary of all registered values metrics to write in db.""" + if display_name: key_string = "display_name" + else: key_string = "name" + val_dict = dict([(self.metrics[key][key_string], self.__getattribute__(key)) for key in self.metrics.keys() if self.metrics[key]["write_db"] ]) + return val_dict + + + def val_mail(self, display_name = True): + """Returns dictionary of all registered values metrics to write in mail.""" + if display_name: key_string = "display_name" + else: key_string = "name" + val_dict = dict([(self.metrics[key][key_string], self.__getattribute__(key)) for key in self.metrics.keys() if self.metrics[key]["write_mail"] ]) + return val_dict + + + def to_dataframe(self, display_name = False, type = None): + """Returns pandas dataframe of all registered values metrics. """ + if type=="mail": + self.df = pd.DataFrame(self.val_mail(display_name = display_name), index=[self.seqName]) + else: + self.df = pd.DataFrame(self.val_dict(display_name = display_name), index=[self.seqName]) + def update_values(self, value_dict = None): + """Updates registered metrics with new values in value_dict. """ + if value_dict: + for key, value in value_dict.items() : + if hasattr(self, key): + self.__setattr__(key, value) + + + def print_type(self, object = "metrics"): + """Prints variable type of registered metrics or caches. """ + print( "OBJECT " , object) + val_dict = self.val_dict(object = object) + for key, item in val_dict.items() : + print("%s: %s; Shape: %s" %(key, type(item), np.shape(item))) + + def print_results(self): + """Prints metrics. """ + result_dict = self.val_dict() + for key, item in result_dict.items(): + print(key) + print("%s: %s" %(key, self.metrics[key]["formatter"](item))) + + + def save_dict(self, path): + """Save value dict to path as pickle file.""" + with open(path, 'wb') as handle: + pickle.dump(self.__dict__, handle, protocol=pickle.HIGHEST_PROTOCOL) + + + def compute_metrics_per_sequence(self): + raise NotImplementedError + + diff --git a/OpenPVSG/models/unitrack/eval/mots/README.md b/OpenPVSG/models/unitrack/eval/mots/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b984473c0bbbf22dded3af4ca4fad87a1eaba0ce --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/README.md @@ -0,0 +1,97 @@ +# MOTS +![MOTS_PIC](https://motchallenge.net/sequenceVideos/MOTS20-11-gt.jpg) + +## Requirements +* Python 3.6.9 +* install [requirements.txt](requirements.txt) + +## Usage +1) Run +``` +python MOTS/evalMOTS.py +``` + + + +## Evaluation +To run the evaluation for your method please adjust the file ```MOTS/evalMOTS.py``` using the following arguments: + +```benchmark_name```: Name of the benchmark, e.g. MOTS +```gt_dir```: Directory containing ground truth files in ```//gt/gt.txt``` +```res_dir```: The folder containing the tracking results. Each one should be saved in a separate .txt file with the name of the respective sequence (see ./res/data) +```save_pkl```: path to output directory for final results (pickle) (default: False) +```eval_mode```: Mode of evaluation out of ```["train", "test", "all"]``` (default : "train") + +``` +eval.run( + benchmark_name = benchmark_name, + seq_file = seq_file, + gt_dir = gt_dir, + res_dir = res_dir + ) +``` +## Visualization +To visualize your results or the annotations run + +python MOTS/MOTSVisualization.py + + +Inside the script adjust the following values for the ```MOTSVisualizer``` class: + +```seqName```: Name of the sequence +```FilePath```: Data file +```image_dir```: Directory containing images +```mode```: Video mode. Options: ```None``` for method results, ```raw``` for data video only, and ```gt``` for annotations +```output_dir```: Directory for created video and thumbnail images + +Additionally, adjust the following values for the ```generateVideo``` function: + +```displayTime```: If true, display frame number (default false) +```displayName```: Name of the method +```showOccluder```: If true, show occluder of gt data +```fps```: Frame rate + +``` +visualizer = MOTSVisualizer(seqName, FilePath, image_dir, mode, output_dir ) +visualizer.generateVideo(displayTime, displayName, showOccluder, fps ) +``` + +## Data Format + +Each line of an annotation txt file is structured like this (where rle means run-length encoding from COCO): +``` +time_frame id class_id img_height img_width rle +``` +An example line from a txt file: +``` +52 1005 1 375 1242 WSV:2d;1O10000O10000O1O100O100O1O100O1000000000000000O100O102N5K00O1O1N2O110OO2O001O1NTga3 +``` +Meaning: +
time frame 52 +
object id 1005 (meaning class id is 1, i.e. car and instance id is 5) +
class id 1 +
image height 375 +
image width 1242 +
rle WSV:2d;1O10000O10000O1O100O100O1O100O1000000000000000O100O...1O1N

+ +image height, image width, and rle can be used together to decode a mask using [cocotools](https://github.com/cocodataset/cocoapi). + +## Citation +If you work with the code and the benchmark, please cite: + +``` +@inproceedings{Voigtlaender19CVPR_MOTS, + author = {Paul Voigtlaender and Michael Krause and Aljo\u{s}a O\u{s}ep and Jonathon Luiten and Berin Balachandar Gnana Sekar and Andreas Geiger and Bastian Leibe}, + title = {{MOTS}: Multi-Object Tracking and Segmentation}, + booktitle = {CVPR}, + year = {2019}, +} +``` + +## License +MIT License + +## Contact +If you find a problem in the code, please open an issue. + +For general questions, please contact Paul Voigtlaender (voigtlaender@vision.rwth-aachen.de) or Michael Krause (michael.krause@rwth-aachen.de) diff --git a/OpenPVSG/models/unitrack/eval/mots/Visualize.py b/OpenPVSG/models/unitrack/eval/mots/Visualize.py new file mode 100644 index 0000000000000000000000000000000000000000..e35cd81346f511049447c94c31b076136c4417f0 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/Visualize.py @@ -0,0 +1,139 @@ + +import cv2 +import numpy as np +import os, sys +import glob +import colorsys +import traceback + + +class Visualizer(object): + def __init__(self, + seqName = None, + mode = None, + FilePath = None, + output_dir = None, + image_dir = None, + metaInfoDir = None + + ): + + assert mode in [None, "raw", "gt"], "Not valid mode. Value has to be None, 'raw', or 'gt'" + + self.seqName = seqName + self.mode = mode + self.image_dir= image_dir + self.output_dir = output_dir + self.FilePath = FilePath + self.metaInfoDir = metaInfoDir + + # adapted from https://github.com/matterport/Mask_RCNN/blob/master/mrcnn/visualize.py + @property + def generate_colors(self): + """ + Generate random colors. + To get visually distinct colors, generate them in HSV space then + convert to RGB. + """ + N = 30 + brightness = 0.7 + hsv = [(i / N, 1, brightness) for i in range(N)] + colors = list(map(lambda c: colorsys.hsv_to_rgb(*c), hsv)) + perm = [15, 13, 25, 12, 19, 8, 22, 24, 29, 17, 28, 20, 2, 27, 11, 26, 21, 4, 3, 18, 9, 5, 14, 1, 16, 0, 23, 7, 6, 10] + colors = [colors[idx] for idx in perm] + return colors + def generateVideo(self, + outputName = None, + extensions = [], + displayTime = False, + displayName = False, + showOccluder = False, + fps = 25): + + self.showOccluder = showOccluder + + if outputName == None: + outputName = self.seqName + + + if not self.mode == "raw": + #load File + self.resFile = self.load(self.FilePath) + + # get images Folder + # check if image folder exists + if not os.path.isdir(self.image_dir): + print ("imgFolder does not exist") + sys.exit() + + + imgFile = "000001.jpg" + img = os.path.join(self.image_dir,imgFile) + print("image file" , img) + im = cv2.imread(img,1) + height, width, c = im.shape + + self.imScale = 1 + if width > 800: + self.imScale = .5 + width = int(width*self.imScale) + height = int(height*self.imScale) + + # video extension + extension = ".mp4" + if self.mode: + self.outputNameNoExt = os.path.join(self.output_dir, "%s-%s" % (outputName, self.mode)) + else: + self.outputNameNoExt = os.path.join(self.output_dir, outputName) + self.outputName = "%s%s" % (self.outputNameNoExt, extension) + + self.out = cv2.VideoWriter(self.outputName,cv2.VideoWriter_fourcc(*'mp4v'), fps, (width,height)) + + print ("Output name: %s"%self.outputName) + self.colors = self.generate_colors + t=0 + + for img in sorted(glob.glob(os.path.join(self.image_dir,"*.jpg"))): + t+=1 + + im = cv2.imread(img,1) + + if not self.mode == "raw": + try: + im = self.drawResults(im, t) + except Exception as e: + print(str(traceback.format_exc())) + im=cv2.resize(im,(0,0),fx=self.imScale,fy=self.imScale) + + if displayTime: + cv2.putText(im,"%d" % t,(25,50),cv2.FONT_HERSHEY_PLAIN,self.imScale*6,[255, 255, 255], thickness = 3) + if displayName: + text = "%s: %s" %(self.seqName, displayName) + cv2.putText(im, text,(25,height - 25 ),cv2.FONT_HERSHEY_DUPLEX,self.imScale* 2,[255, 255, 255], thickness = 2) + + if t == 1: + cv2.imwrite("{}.jpg".format(self.outputNameNoExt), im) + im_mini = cv2.resize(im, (0,0), fx=0.25, fy=0.25) + cv2.imwrite("{}-mini.jpg".format(self.outputNameNoExt), im_mini) + self.out.write(im) + self.out.release() + + print("Finished: %s"%self.outputName) + if not len(extensions)==0: + print("Convert Video to : ", extensions) + self.convertVideo(extensions) + + def drawResults(self, image = None): + NotImplemented + + def load(self): + NotImplemented + + def convertVideo(self, extensions): + + for ext in extensions: + print( self.outputName) + outputNameNewExt = "%s%s" % (self.outputNameNoExt, ext) + print("Convert Video to: %s" % outputNameNewExt) + command = "ffmpeg -loglevel warning -y -i %s -c:v libvpx-vp9 -crf 30 -b:v 0 -b:a 128k -c:a libvorbis -cpu-used 8 %s" % (self.outputName, outputNameNewExt) + os.system(command) diff --git a/OpenPVSG/models/unitrack/eval/mots/__init__.py b/OpenPVSG/models/unitrack/eval/mots/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cc453a15138eb8d4f770413bd24ff5e0f9f8a880 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/__init__.py @@ -0,0 +1,2 @@ +import os, sys +sys.path.append(os.path.dirname(os.path.abspath(__file__))) diff --git a/OpenPVSG/models/unitrack/eval/mots/evalMOTS.py b/OpenPVSG/models/unitrack/eval/mots/evalMOTS.py new file mode 100644 index 0000000000000000000000000000000000000000..e4cb8f07f2230d20a9606110e1a94d3d0e123314 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/evalMOTS.py @@ -0,0 +1,53 @@ +import sys, os +import pdb +sys.path.append(os.path.abspath(os.getcwd())) +import math +from collections import defaultdict +from MOTS_metrics import MOTSMetrics +from Evaluator import Evaluator, run_metrics + +import multiprocessing as mp + + + +class MOTSEvaluator(Evaluator): + def __init__(self): + self.type = "MOTS" + def eval(self): + + arguments = [] + for seq, res, gt in zip(self.sequences, self.tsfiles, self.gtfiles): + arguments.append({"metricObject": MOTSMetrics(seq), + "args" : {"gtDataDir": os.path.join( self.datadir,seq), + "sequence": str(seq) , + "pred_file":res, + "gt_file": gt, + "benchmark_name": self.benchmark_name}}) + + if self.MULTIPROCESSING: + p = mp.Pool(self.NR_CORES) + processes = [p.apply_async(run_metrics, kwds=inp) for inp in arguments] + self.results = [p.get() for p in processes] + p.close() + p.join() + + else: + self.results = [run_metrics(**inp) for inp in arguments] + + + # Sum up results for all sequences + self.Overall_Results = MOTSMetrics("OVERALL") + return self.results + + +if __name__ == "__main__": + eval = MOTSEvaluator() + benchmark_name = "MOTS" + gt_dir = "data/MOTS" + res_dir = "res/MOTSres" + eval_mode = "train" + eval.run( + benchmark_name = benchmark_name, + gt_dir = gt_dir, + res_dir = res_dir, + eval_mode = eval_mode) diff --git a/OpenPVSG/models/unitrack/eval/mots/mots_common/images_to_txt.py b/OpenPVSG/models/unitrack/eval/mots/mots_common/images_to_txt.py new file mode 100644 index 0000000000000000000000000000000000000000..f10d04c3c7c6d4b986173565041f442be0c6de65 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/mots_common/images_to_txt.py @@ -0,0 +1,18 @@ +import sys +from mots_common.io import load_sequences, load_seqmap, write_sequences + + +if __name__ == "__main__": + if len(sys.argv) != 4: + print("Usage: python images_to_txt.py gt_img_folder gt_txt_output_folder seqmap") + sys.exit(1) + + gt_img_folder = sys.argv[1] + gt_txt_output_folder = sys.argv[2] + seqmap_filename = sys.argv[3] + + seqmap, _ = load_seqmap(seqmap_filename) + print("Loading ground truth images...") + gt = load_sequences(gt_img_folder, seqmap) + print("Writing ground truth txts...") + write_sequences(gt, gt_txt_output_folder) diff --git a/OpenPVSG/models/unitrack/eval/mots/mots_common/io.py b/OpenPVSG/models/unitrack/eval/mots/mots_common/io.py new file mode 100644 index 0000000000000000000000000000000000000000..ac8b785e9a7272348d73e3e101b6d8ad14172137 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/mots_common/io.py @@ -0,0 +1,135 @@ +import PIL.Image as Image +import numpy as np +import pycocotools.mask as rletools +import glob +import os + + +class SegmentedObject: + def __init__(self, mask, class_id, track_id): + self.mask = mask + self.class_id = class_id + self.track_id = track_id + + +def load_sequences(path, seqmap): + objects_per_frame_per_sequence = {} + for seq in seqmap: + print("Loading sequence", seq) + seq_path_folder = os.path.join(path, seq) + seq_path_txt = os.path.join(path, seq + ".txt") + if os.path.isdir(seq_path_folder): + objects_per_frame_per_sequence[seq] = load_images_for_folder(seq_path_folder) + elif os.path.exists(seq_path_txt): + objects_per_frame_per_sequence[seq] = load_txt(seq_path_txt) + else: + raise Exception( "Can't find data in directory " + path + "") + + return objects_per_frame_per_sequence + + +def load_txt(path): + objects_per_frame = {} + track_ids_per_frame = {} # To check that no frame contains two objects with same id + combined_mask_per_frame = {} # To check that no frame contains overlapping masks + with open(path, "r") as f: + for line in f: + line = line.strip() + fields = line.split(" ") + try: + frame = int(fields[0]) + except: + raise Exception("Error in {} in line: {}".format(path.split("/")[-1], line)) + if frame not in objects_per_frame: + objects_per_frame[frame] = [] + if frame not in track_ids_per_frame: + track_ids_per_frame[frame] = set() + if int(fields[1]) in track_ids_per_frame[frame]: + raise Exception("Multiple objects with track id " + fields[1] + " in frame " + fields[0] + "") + else: + track_ids_per_frame[frame].add(int(fields[1])) + + class_id = int(fields[2]) + if not(class_id == 1 or class_id == 2 or class_id == 10): + raise Exception( "Unknown object class " + fields[2] + "") + + mask = {'size': [int(fields[3]), int(fields[4])], 'counts': fields[5].encode(encoding='UTF-8')} + if frame not in combined_mask_per_frame: + combined_mask_per_frame[frame] = mask + elif rletools.area(rletools.merge([combined_mask_per_frame[frame], mask], intersect=True)) > 0.0: + raise Exception( "Objects with overlapping masks in frame " + fields[0] + "") + else: + combined_mask_per_frame[frame] = rletools.merge([combined_mask_per_frame[frame], mask], intersect=False) + objects_per_frame[frame].append(SegmentedObject( + mask, + class_id, + int(fields[1]) + )) + + return objects_per_frame + + +def load_images_for_folder(path): + files = sorted(glob.glob(os.path.join(path, "*.png"))) + + objects_per_frame = {} + for file in files: + objects = load_image(file) + frame = filename_to_frame_nr(os.path.basename(file)) + objects_per_frame[frame] = objects + + return objects_per_frame + + +def filename_to_frame_nr(filename): + assert len(filename) == 10, "Expect filenames to have format 000000.png, 000001.png, ..." + return int(filename.split('.')[0]) + + +def load_image(filename, id_divisor=1000): + img = np.array(Image.open(filename)) + obj_ids = np.unique(img) + + objects = [] + mask = np.zeros(img.shape, dtype=np.uint8, order="F") # Fortran order needed for pycocos RLE tools + for idx, obj_id in enumerate(obj_ids): + if obj_id == 0: # background + continue + mask.fill(0) + pixels_of_elem = np.where(img == obj_id) + mask[pixels_of_elem] = 1 + objects.append(SegmentedObject( + rletools.encode(mask), + obj_id // id_divisor, + obj_id + )) + + return objects + + +def load_seqmap(seqmap_filename): + print("Loading seqmap...") + seqmap = [] + max_frames = {} + with open(seqmap_filename, "r") as fh: + for i, l in enumerate(fh): + fields = l.split(" ") + seq = "%04d" % int(fields[0]) + seqmap.append(seq) + max_frames[seq] = int(fields[3]) + return seqmap, max_frames + + +def write_sequences(gt, output_folder): + os.makedirs(output_folder, exist_ok=True) + for seq, seq_frames in gt.items(): + write_sequence(seq_frames, os.path.join(output_folder, seq + ".txt")) + return + + +def write_sequence(frames, path): + with open(path, "w") as f: + for t, objects in frames.items(): + for obj in objects: + print(t, obj.track_id, obj.class_id, obj.mask["size"][0], obj.mask["size"][1], + obj.mask["counts"].decode(encoding='UTF-8'), file=f) diff --git a/OpenPVSG/models/unitrack/eval/mots/requirements.txt b/OpenPVSG/models/unitrack/eval/mots/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..09dbbad9b020bd69b617cd2020b7372f8b450f64 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/mots/requirements.txt @@ -0,0 +1,14 @@ +cycler==0.10.0 +Cython==0.29.20 +kiwisolver==1.2.0 +matplotlib==3.2.2 +numpy==1.19.0 +opencv-python==4.2.0.34 +pandas==1.0.5 +Pillow==7.1.2 +pycocotools==2.0.1 +pyparsing==2.4.7 +python-dateutil==2.8.1 +pytz==2020.1 +scipy==1.5.0 +six==1.15.0 diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/AUTHORS.txt b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/AUTHORS.txt new file mode 100644 index 0000000000000000000000000000000000000000..139040f599c19edf20ce0377431d69842f73a19a --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/AUTHORS.txt @@ -0,0 +1,53 @@ +The author of "jsonlab" toolbox is Qianqian Fang. Qianqian +is currently an Assistant Professor in the Department of Bioengineering, +Northeastern University. + +Address: Qianqian Fang + Department of Bioengineering + Northeastern University + 212A Lake Hall + 360 Huntington Ave, Boston, MA 02115, USA + Office: 503 Holmes Hall + Phone[O]: 617-373-3829 +URL: http://fanglab.org +Email: and + + +The script loadjson.m was built upon previous works by + +- Nedialko Krouchev: http://www.mathworks.com/matlabcentral/fileexchange/25713 + date: 2009/11/02 +- François Glineur: http://www.mathworks.com/matlabcentral/fileexchange/23393 + date: 2009/03/22 +- Joel Feenstra: http://www.mathworks.com/matlabcentral/fileexchange/20565 + date: 2008/07/03 + + +This toolbox contains patches submitted by the following contributors: + +- Blake Johnson + part of revision 341 + +- Niclas Borlin + various fixes in revision 394, including + - loadjson crashes for all-zero sparse matrix. + - loadjson crashes for empty sparse matrix. + - Non-zero size of 0-by-N and N-by-0 empty matrices is lost after savejson/loadjson. + - loadjson crashes for sparse real column vector. + - loadjson crashes for sparse complex column vector. + - Data is corrupted by savejson for sparse real row vector. + - savejson crashes for sparse complex row vector. + +- Yul Kang + patches for svn revision 415. + - savejson saves an empty cell array as [] instead of null + - loadjson differentiates an empty struct from an empty array + +- Mykhailo Bratukha + (Pull#14) Bug fix: File path is wrongly inerpreted as JSON string + +- Insik Kim + (Pull#12) Bug fix: Resolving bug that cell type is converted to json with transposed data + +- Sertan Senturk + (Pull#10,#11) Feature: Added matlab object saving to savejson and saveubjson diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/ChangeLog.txt b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/ChangeLog.txt new file mode 100644 index 0000000000000000000000000000000000000000..65016b9647f91faf56985ff2262ef6b926caad8d --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/ChangeLog.txt @@ -0,0 +1,96 @@ +============================================================================ + + JSONlab - a toolbox to encode/decode JSON/UBJSON files in MATLAB/Octave + +---------------------------------------------------------------------------- + +JSONlab ChangeLog (key features marked by *): + +== JSONlab 1.2 (codename: Optimus - Update 2), FangQ == + + 2015/12/16 replacing string concatenation by str cells to gain 2x speed in savejson (Issue#17) + 2015/12/11 fix FileName option case bug (SVN rev#495) + 2015/12/11 add SingletCell option, add SingletArray to replace NoRowBracket (Issue#15,#8) + 2015/11/10 fix bug for inerpreting file names as JSON string - by Mykhailo Bratukha (Pull#14) + 2015/10/16 fix bug for cell with transposed data - by Insik Kim (Pull#12) + 2015/09/25 support exporting matlab object to JSON - by Sertan Senturk (Pull#10, #11) + +== JSONlab 1.1 (codename: Optimus - Update 1), FangQ == + + 2015/05/05 *massively accelerating loadjson for parsing large collection of unstructured small objects + 2015/05/05 force array bracket in 1x1 struct to maintain depth (Issue#1) + 2015/05/05 parse logicals in loadjson + 2015/05/05 make options case insensitive + 2015/05/01 reading unicode encoded json files (thanks to Sertan Senturk,Issue#3) + 2015/04/30 allow \uXXXX to represent a unicode in a string (Issue#2) + 2015/03/30 save a 0x0 solid real empty array as null and handel empty struct array + 2015/03/30 properly handle escape characters in a string + 2015/01/24 *implement the UBJSON Draft12 new name format + 2015/01/13 correct cell array indentation inconsistency + +== JSONlab 1.0 (codename: Optimus - Final), FangQ == + + 2015/01/02 polish help info for all major functions, update examples, finalize 1.0 + 2014/12/19 fix a bug to strictly respect NoRowBracket in savejson + +== JSONlab 1.0.0-RC2 (codename: Optimus - RC2), FangQ == + + 2014/11/22 show progress bar in loadjson ('ShowProgress') + 2014/11/17 *add Compact option in savejson to output compact JSON format ('Compact') + 2014/11/17 add FastArrayParser in loadjson to specify fast parser applicable levels + 2014/09/18 *start official github mirror: https://github.com/fangq/jsonlab + +== JSONlab 1.0.0-RC1 (codename: Optimus - RC1), FangQ == + + 2014/09/17 fix several compatibility issues when running on octave versions 3.2-3.8 + 2014/09/17 *support 2D cell and struct arrays in both savejson and saveubjson + 2014/08/04 escape special characters in a JSON string + 2014/02/16 fix a bug when saving ubjson files + +== JSONlab 0.9.9 (codename: Optimus - beta), FangQ == + + 2014/01/22 use binary read and write in saveubjson and loadubjson + +== JSONlab 0.9.8-1 (codename: Optimus - alpha update 1), FangQ == + + 2013/10/07 better round-trip conservation for empty arrays and structs (patch submitted by Yul Kang) + +== JSONlab 0.9.8 (codename: Optimus - alpha), FangQ == + 2013/08/23 *universal Binary JSON (UBJSON) support, including both saveubjson and loadubjson + +== JSONlab 0.9.1 (codename: Rodimus, update 1), FangQ == + 2012/12/18 *handling of various empty and sparse matrices (fixes submitted by Niclas Borlin) + +== JSONlab 0.9.0 (codename: Rodimus), FangQ == + + 2012/06/17 *new format for an invalid leading char, unpacking hex code in savejson + 2012/06/01 support JSONP in savejson + 2012/05/25 fix the empty cell bug (reported by Cyril Davin) + 2012/04/05 savejson can save to a file (suggested by Patrick Rapin) + +== JSONlab 0.8.1 (codename: Sentiel, Update 1), FangQ == + + 2012/02/28 loadjson quotation mark escape bug, see http://bit.ly/yyk1nS + 2012/01/25 patch to handle root-less objects, contributed by Blake Johnson + +== JSONlab 0.8.0 (codename: Sentiel), FangQ == + + 2012/01/13 *speed up loadjson by 20 fold when parsing large data arrays in matlab + 2012/01/11 remove row bracket if an array has 1 element, suggested by Mykel Kochenderfer + 2011/12/22 *accept sequence of 'param',value input in savejson and loadjson + 2011/11/18 fix struct array bug reported by Mykel Kochenderfer + +== JSONlab 0.5.1 (codename: Nexus Update 1), FangQ == + + 2011/10/21 fix a bug in loadjson, previous code does not use any of the acceleration + 2011/10/20 loadjson supports JSON collections - concatenated JSON objects + +== JSONlab 0.5.0 (codename: Nexus), FangQ == + + 2011/10/16 package and release jsonlab 0.5.0 + 2011/10/15 *add json demo and regression test, support cpx numbers, fix double quote bug + 2011/10/11 *speed up readjson dramatically, interpret _Array* tags, show data in root level + 2011/10/10 create jsonlab project, start jsonlab website, add online documentation + 2011/10/07 *speed up savejson by 25x using sprintf instead of mat2str, add options support + 2011/10/06 *savejson works for structs, cells and arrays + 2011/09/09 derive loadjson from JSON parser from MATLAB Central, draft savejson.m diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/LICENSE_BSD.txt b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/LICENSE_BSD.txt new file mode 100644 index 0000000000000000000000000000000000000000..32d66cbc0eec1ffa82a1f95d5d136353c353dd9b --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/LICENSE_BSD.txt @@ -0,0 +1,25 @@ +Copyright 2011-2015 Qianqian Fang . All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are +permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this list of + conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, this list + of conditions and the following disclaimer in the documentation and/or other materials + provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The views and conclusions contained in the software and documentation are those of the +authors and should not be interpreted as representing official policies, either expressed +or implied, of the copyright holders. diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/README.txt b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/README.txt new file mode 100644 index 0000000000000000000000000000000000000000..849a0f786c9ac0f8445307d7a2c196e88f84fcd6 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/README.txt @@ -0,0 +1,411 @@ +=============================================================================== += JSONLab = += An open-source MATLAB/Octave JSON encoder and decoder = +=============================================================================== + +*Copyright (C) 2011-2015 Qianqian Fang +*License: BSD License, see License_BSD.txt for details +*Version: 1.2 (Optimus - Update 2) + +------------------------------------------------------------------------------- + +Table of Content: + +I. Introduction +II. Installation +III.Using JSONLab +IV. Known Issues and TODOs +V. Contribution and feedback + +------------------------------------------------------------------------------- + +I. Introduction + +JSON ([http://www.json.org/ JavaScript Object Notation]) is a highly portable, +human-readable and "[http://en.wikipedia.org/wiki/JSON fat-free]" text format +to represent complex and hierarchical data. It is as powerful as +[http://en.wikipedia.org/wiki/XML XML], but less verbose. JSON format is widely +used for data-exchange in applications, and is essential for the wild success +of [http://en.wikipedia.org/wiki/Ajax_(programming) Ajax] and +[http://en.wikipedia.org/wiki/Web_2.0 Web2.0]. + +UBJSON (Universal Binary JSON) is a binary JSON format, specifically +optimized for compact file size and better performance while keeping +the semantics as simple as the text-based JSON format. Using the UBJSON +format allows to wrap complex binary data in a flexible and extensible +structure, making it possible to process complex and large dataset +without accuracy loss due to text conversions. + +We envision that both JSON and its binary version will serve as part of +the mainstream data-exchange formats for scientific research in the future. +It will provide the flexibility and generality achieved by other popular +general-purpose file specifications, such as +[http://www.hdfgroup.org/HDF5/whatishdf5.html HDF5], with significantly +reduced complexity and enhanced performance. + +JSONLab is a free and open-source implementation of a JSON/UBJSON encoder +and a decoder in the native MATLAB language. It can be used to convert a MATLAB +data structure (array, struct, cell, struct array and cell array) into +JSON/UBJSON formatted strings, or to decode a JSON/UBJSON file into MATLAB +data structure. JSONLab supports both MATLAB and +[http://www.gnu.org/software/octave/ GNU Octave] (a free MATLAB clone). + +------------------------------------------------------------------------------- + +II. Installation + +The installation of JSONLab is no different than any other simple +MATLAB toolbox. You only need to download/unzip the JSONLab package +to a folder, and add the folder's path to MATLAB/Octave's path list +by using the following command: + + addpath('/path/to/jsonlab'); + +If you want to add this path permanently, you need to type "pathtool", +browse to the jsonlab root folder and add to the list, then click "Save". +Then, run "rehash" in MATLAB, and type "which loadjson", if you see an +output, that means JSONLab is installed for MATLAB/Octave. + +------------------------------------------------------------------------------- + +III.Using JSONLab + +JSONLab provides two functions, loadjson.m -- a MATLAB->JSON decoder, +and savejson.m -- a MATLAB->JSON encoder, for the text-based JSON, and +two equivallent functions -- loadubjson and saveubjson for the binary +JSON. The detailed help info for the four functions can be found below: + +=== loadjson.m === +
+  data=loadjson(fname,opt)
+     or
+  data=loadjson(fname,'param1',value1,'param2',value2,...)
+ 
+  parse a JSON (JavaScript Object Notation) file or string
+ 
+  authors:Qianqian Fang (fangq nmr.mgh.harvard.edu)
+  created on 2011/09/09, including previous works from 
+ 
+          Nedialko Krouchev: http://www.mathworks.com/matlabcentral/fileexchange/25713
+             created on 2009/11/02
+          François Glineur: http://www.mathworks.com/matlabcentral/fileexchange/23393
+             created on  2009/03/22
+          Joel Feenstra:
+          http://www.mathworks.com/matlabcentral/fileexchange/20565
+             created on 2008/07/03
+ 
+  $Id: loadjson.m 487 2015-05-06 18:19:07Z fangq $
+ 
+  input:
+       fname: input file name, if fname contains "{}" or "[]", fname
+              will be interpreted as a JSON string
+       opt: a struct to store parsing options, opt can be replaced by 
+            a list of ('param',value) pairs - the param string is equivallent
+            to a field in opt. opt can have the following 
+            fields (first in [.|.] is the default)
+ 
+            opt.SimplifyCell [0|1]: if set to 1, loadjson will call cell2mat
+                          for each element of the JSON data, and group 
+                          arrays based on the cell2mat rules.
+            opt.FastArrayParser [1|0 or integer]: if set to 1, use a
+                          speed-optimized array parser when loading an 
+                          array object. The fast array parser may 
+                          collapse block arrays into a single large
+                          array similar to rules defined in cell2mat; 0 to 
+                          use a legacy parser; if set to a larger-than-1
+                          value, this option will specify the minimum
+                          dimension to enable the fast array parser. For
+                          example, if the input is a 3D array, setting
+                          FastArrayParser to 1 will return a 3D array;
+                          setting to 2 will return a cell array of 2D
+                          arrays; setting to 3 will return to a 2D cell
+                          array of 1D vectors; setting to 4 will return a
+                          3D cell array.
+            opt.ShowProgress [0|1]: if set to 1, loadjson displays a progress bar.
+ 
+  output:
+       dat: a cell array, where {...} blocks are converted into cell arrays,
+            and [...] are converted to arrays
+ 
+  examples:
+       dat=loadjson('{"obj":{"string":"value","array":[1,2,3]}}')
+       dat=loadjson(['examples' filesep 'example1.json'])
+       dat=loadjson(['examples' filesep 'example1.json'],'SimplifyCell',1)
+
+ +=== savejson.m === + +
+  json=savejson(rootname,obj,filename)
+     or
+  json=savejson(rootname,obj,opt)
+  json=savejson(rootname,obj,'param1',value1,'param2',value2,...)
+ 
+  convert a MATLAB object (cell, struct or array) into a JSON (JavaScript
+  Object Notation) string
+ 
+  author: Qianqian Fang (fangq nmr.mgh.harvard.edu)
+  created on 2011/09/09
+ 
+  $Id: savejson.m 486 2015-05-05 20:37:11Z fangq $
+ 
+  input:
+       rootname: the name of the root-object, when set to '', the root name
+         is ignored, however, when opt.ForceRootName is set to 1 (see below),
+         the MATLAB variable name will be used as the root name.
+       obj: a MATLAB object (array, cell, cell array, struct, struct array).
+       filename: a string for the file name to save the output JSON data.
+       opt: a struct for additional options, ignore to use default values.
+         opt can have the following fields (first in [.|.] is the default)
+ 
+         opt.FileName [''|string]: a file name to save the output JSON data
+         opt.FloatFormat ['%.10g'|string]: format to show each numeric element
+                          of a 1D/2D array;
+         opt.ArrayIndent [1|0]: if 1, output explicit data array with
+                          precedent indentation; if 0, no indentation
+         opt.ArrayToStruct[0|1]: when set to 0, savejson outputs 1D/2D
+                          array in JSON array format; if sets to 1, an
+                          array will be shown as a struct with fields
+                          "_ArrayType_", "_ArraySize_" and "_ArrayData_"; for
+                          sparse arrays, the non-zero elements will be
+                          saved to _ArrayData_ field in triplet-format i.e.
+                          (ix,iy,val) and "_ArrayIsSparse_" will be added
+                          with a value of 1; for a complex array, the 
+                          _ArrayData_ array will include two columns 
+                          (4 for sparse) to record the real and imaginary 
+                          parts, and also "_ArrayIsComplex_":1 is added. 
+         opt.ParseLogical [0|1]: if this is set to 1, logical array elem
+                          will use true/false rather than 1/0.
+         opt.NoRowBracket [1|0]: if this is set to 1, arrays with a single
+                          numerical element will be shown without a square
+                          bracket, unless it is the root object; if 0, square
+                          brackets are forced for any numerical arrays.
+         opt.ForceRootName [0|1]: when set to 1 and rootname is empty, savejson
+                          will use the name of the passed obj variable as the 
+                          root object name; if obj is an expression and 
+                          does not have a name, 'root' will be used; if this 
+                          is set to 0 and rootname is empty, the root level 
+                          will be merged down to the lower level.
+         opt.Inf ['"$1_Inf_"'|string]: a customized regular expression pattern
+                          to represent +/-Inf. The matched pattern is '([-+]*)Inf'
+                          and $1 represents the sign. For those who want to use
+                          1e999 to represent Inf, they can set opt.Inf to '$11e999'
+         opt.NaN ['"_NaN_"'|string]: a customized regular expression pattern
+                          to represent NaN
+         opt.JSONP [''|string]: to generate a JSONP output (JSON with padding),
+                          for example, if opt.JSONP='foo', the JSON data is
+                          wrapped inside a function call as 'foo(...);'
+         opt.UnpackHex [1|0]: conver the 0x[hex code] output by loadjson 
+                          back to the string form
+         opt.SaveBinary [0|1]: 1 - save the JSON file in binary mode; 0 - text mode.
+         opt.Compact [0|1]: 1- out compact JSON format (remove all newlines and tabs)
+ 
+         opt can be replaced by a list of ('param',value) pairs. The param 
+         string is equivallent to a field in opt and is case sensitive.
+  output:
+       json: a string in the JSON format (see http://json.org)
+ 
+  examples:
+       jsonmesh=struct('MeshNode',[0 0 0;1 0 0;0 1 0;1 1 0;0 0 1;1 0 1;0 1 1;1 1 1],... 
+                'MeshTetra',[1 2 4 8;1 3 4 8;1 2 6 8;1 5 6 8;1 5 7 8;1 3 7 8],...
+                'MeshTri',[1 2 4;1 2 6;1 3 4;1 3 7;1 5 6;1 5 7;...
+                           2 8 4;2 8 6;3 8 4;3 8 7;5 8 6;5 8 7],...
+                'MeshCreator','FangQ','MeshTitle','T6 Cube',...
+                'SpecialData',[nan, inf, -inf]);
+       savejson('jmesh',jsonmesh)
+       savejson('',jsonmesh,'ArrayIndent',0,'FloatFormat','\t%.5g')
+ 
+ +=== loadubjson.m === + +
+  data=loadubjson(fname,opt)
+     or
+  data=loadubjson(fname,'param1',value1,'param2',value2,...)
+ 
+  parse a JSON (JavaScript Object Notation) file or string
+ 
+  authors:Qianqian Fang (fangq nmr.mgh.harvard.edu)
+  created on 2013/08/01
+ 
+  $Id: loadubjson.m 487 2015-05-06 18:19:07Z fangq $
+ 
+  input:
+       fname: input file name, if fname contains "{}" or "[]", fname
+              will be interpreted as a UBJSON string
+       opt: a struct to store parsing options, opt can be replaced by 
+            a list of ('param',value) pairs - the param string is equivallent
+            to a field in opt. opt can have the following 
+            fields (first in [.|.] is the default)
+ 
+            opt.SimplifyCell [0|1]: if set to 1, loadubjson will call cell2mat
+                          for each element of the JSON data, and group 
+                          arrays based on the cell2mat rules.
+            opt.IntEndian [B|L]: specify the endianness of the integer fields
+                          in the UBJSON input data. B - Big-Endian format for 
+                          integers (as required in the UBJSON specification); 
+                          L - input integer fields are in Little-Endian order.
+            opt.NameIsString [0|1]: for UBJSON Specification Draft 8 or 
+                          earlier versions (JSONLab 1.0 final or earlier), 
+                          the "name" tag is treated as a string. To load 
+                          these UBJSON data, you need to manually set this 
+                          flag to 1.
+ 
+  output:
+       dat: a cell array, where {...} blocks are converted into cell arrays,
+            and [...] are converted to arrays
+ 
+  examples:
+       obj=struct('string','value','array',[1 2 3]);
+       ubjdata=saveubjson('obj',obj);
+       dat=loadubjson(ubjdata)
+       dat=loadubjson(['examples' filesep 'example1.ubj'])
+       dat=loadubjson(['examples' filesep 'example1.ubj'],'SimplifyCell',1)
+
+ +=== saveubjson.m === + +
+  json=saveubjson(rootname,obj,filename)
+     or
+  json=saveubjson(rootname,obj,opt)
+  json=saveubjson(rootname,obj,'param1',value1,'param2',value2,...)
+ 
+  convert a MATLAB object (cell, struct or array) into a Universal 
+  Binary JSON (UBJSON) binary string
+ 
+  author: Qianqian Fang (fangq nmr.mgh.harvard.edu)
+  created on 2013/08/17
+ 
+  $Id: saveubjson.m 465 2015-01-25 00:46:07Z fangq $
+ 
+  input:
+       rootname: the name of the root-object, when set to '', the root name
+         is ignored, however, when opt.ForceRootName is set to 1 (see below),
+         the MATLAB variable name will be used as the root name.
+       obj: a MATLAB object (array, cell, cell array, struct, struct array)
+       filename: a string for the file name to save the output UBJSON data
+       opt: a struct for additional options, ignore to use default values.
+         opt can have the following fields (first in [.|.] is the default)
+ 
+         opt.FileName [''|string]: a file name to save the output JSON data
+         opt.ArrayToStruct[0|1]: when set to 0, saveubjson outputs 1D/2D
+                          array in JSON array format; if sets to 1, an
+                          array will be shown as a struct with fields
+                          "_ArrayType_", "_ArraySize_" and "_ArrayData_"; for
+                          sparse arrays, the non-zero elements will be
+                          saved to _ArrayData_ field in triplet-format i.e.
+                          (ix,iy,val) and "_ArrayIsSparse_" will be added
+                          with a value of 1; for a complex array, the 
+                          _ArrayData_ array will include two columns 
+                          (4 for sparse) to record the real and imaginary 
+                          parts, and also "_ArrayIsComplex_":1 is added. 
+         opt.ParseLogical [1|0]: if this is set to 1, logical array elem
+                          will use true/false rather than 1/0.
+         opt.NoRowBracket [1|0]: if this is set to 1, arrays with a single
+                          numerical element will be shown without a square
+                          bracket, unless it is the root object; if 0, square
+                          brackets are forced for any numerical arrays.
+         opt.ForceRootName [0|1]: when set to 1 and rootname is empty, saveubjson
+                          will use the name of the passed obj variable as the 
+                          root object name; if obj is an expression and 
+                          does not have a name, 'root' will be used; if this 
+                          is set to 0 and rootname is empty, the root level 
+                          will be merged down to the lower level.
+         opt.JSONP [''|string]: to generate a JSONP output (JSON with padding),
+                          for example, if opt.JSON='foo', the JSON data is
+                          wrapped inside a function call as 'foo(...);'
+         opt.UnpackHex [1|0]: conver the 0x[hex code] output by loadjson 
+                          back to the string form
+ 
+         opt can be replaced by a list of ('param',value) pairs. The param 
+         string is equivallent to a field in opt and is case sensitive.
+  output:
+       json: a binary string in the UBJSON format (see http://ubjson.org)
+ 
+  examples:
+       jsonmesh=struct('MeshNode',[0 0 0;1 0 0;0 1 0;1 1 0;0 0 1;1 0 1;0 1 1;1 1 1],... 
+                'MeshTetra',[1 2 4 8;1 3 4 8;1 2 6 8;1 5 6 8;1 5 7 8;1 3 7 8],...
+                'MeshTri',[1 2 4;1 2 6;1 3 4;1 3 7;1 5 6;1 5 7;...
+                           2 8 4;2 8 6;3 8 4;3 8 7;5 8 6;5 8 7],...
+                'MeshCreator','FangQ','MeshTitle','T6 Cube',...
+                'SpecialData',[nan, inf, -inf]);
+       saveubjson('jsonmesh',jsonmesh)
+       saveubjson('jsonmesh',jsonmesh,'meshdata.ubj')
+
+ + +=== examples === + +Under the "examples" folder, you can find several scripts to demonstrate the +basic utilities of JSONLab. Running the "demo_jsonlab_basic.m" script, you +will see the conversions from MATLAB data structure to JSON text and backward. +In "jsonlab_selftest.m", we load complex JSON files downloaded from the Internet +and validate the loadjson/savejson functions for regression testing purposes. +Similarly, a "demo_ubjson_basic.m" script is provided to test the saveubjson +and loadubjson functions for various matlab data structures. + +Please run these examples and understand how JSONLab works before you use +it to process your data. + +------------------------------------------------------------------------------- + +IV. Known Issues and TODOs + +JSONLab has several known limitations. We are striving to make it more general +and robust. Hopefully in a few future releases, the limitations become less. + +Here are the known issues: + +# 3D or higher dimensional cell/struct-arrays will be converted to 2D arrays; +# When processing names containing multi-byte characters, Octave and MATLAB \ +can give different field-names; you can use feature('DefaultCharacterSet','latin1') \ +in MATLAB to get consistant results +# savejson can not handle class and dataset. +# saveubjson converts a logical array into a uint8 ([U]) array +# an unofficial N-D array count syntax is implemented in saveubjson. We are \ +actively communicating with the UBJSON spec maintainer to investigate the \ +possibility of making it upstream +# loadubjson can not parse all UBJSON Specification (Draft 9) compliant \ +files, however, it can parse all UBJSON files produced by saveubjson. + +------------------------------------------------------------------------------- + +V. Contribution and feedback + +JSONLab is an open-source project. This means you can not only use it and modify +it as you wish, but also you can contribute your changes back to JSONLab so +that everyone else can enjoy the improvement. For anyone who want to contribute, +please download JSONLab source code from its source code repositories by using the +following command: + + git clone https://github.com/fangq/jsonlab.git jsonlab + +or browsing the github site at + + https://github.com/fangq/jsonlab + +alternatively, if you prefer svn, you can checkout the latest code by using + + svn checkout svn://svn.code.sf.net/p/iso2mesh/code/trunk/jsonlab jsonlab + +You can make changes to the files as needed. Once you are satisfied with your +changes, and ready to share it with others, please cd the root directory of +JSONLab, and type + + git diff --no-prefix > yourname_featurename.patch + +or + + svn diff > yourname_featurename.patch + +You then email the .patch file to JSONLab's maintainer, Qianqian Fang, at +the email address shown in the beginning of this file. Qianqian will review +the changes and commit it to the subversion if they are satisfactory. + +We appreciate any suggestions and feedbacks from you. Please use the following +mailing list to report any questions you may have regarding JSONLab: + +https://groups.google.com/forum/?hl=en#!forum/jsonlab-users + +(Subscription to the mailing list is needed in order to post messages). diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/demo_jsonlab_basic.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/demo_jsonlab_basic.m new file mode 100644 index 0000000000000000000000000000000000000000..d44d4ff13b74b20364a0a1c30205a8ed8b798c5b --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/demo_jsonlab_basic.m @@ -0,0 +1,181 @@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Demonstration of Basic Utilities of JSONlab +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +rngstate = rand ('state'); +randseed=hex2dec('623F9A9E'); +clear data2json json2data + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a simple scalar value \n') +fprintf(1,'%%=================================================\n\n') + +data2json=pi +savejson('',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a complex number\n') +fprintf(1,'%%=================================================\n\n') + +clear i; +data2json=1+2*i +savejson('',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a complex matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=magic(6); +data2json=data2json(:,1:3)+data2json(:,4:6)*i +savejson('',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% MATLAB special constants\n') +fprintf(1,'%%=================================================\n\n') + +data2json=[NaN Inf -Inf] +savejson('specials',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a real sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sprand(10,10,0.1) +savejson('sparse',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a complex sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=data2json-data2json*i +savejson('complex_sparse',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an all-zero sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse(2,3); +savejson('all_zero_sparse',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an empty sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse([]); +savejson('empty_sparse',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an empty 0-by-0 real matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=[]; +savejson('empty_0by0_real',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an empty 0-by-3 real matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=zeros(0,3); +savejson('empty_0by3_real',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse real column vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse([0,3,0,1,4]'); +savejson('sparse_column_vector',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse complex column vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=data2json-1i*data2json; +savejson('complex_sparse_column_vector',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse real row vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse([0,3,0,1,4]); +savejson('sparse_row_vector',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse complex row vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=data2json-1i*data2json; +savejson('complex_sparse_row_vector',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a structure\n') +fprintf(1,'%%=================================================\n\n') + +data2json=struct('name','Think Different','year',1997,'magic',magic(3),... + 'misfits',[Inf,NaN],'embedded',struct('left',true,'right',false)) +savejson('astruct',data2json,struct('ParseLogical',1)) +json2data=loadjson(ans) +class(json2data.astruct.embedded.left) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a structure array\n') +fprintf(1,'%%=================================================\n\n') + +data2json=struct('name','Nexus Prime','rank',9); +data2json(2)=struct('name','Sentinel Prime','rank',9); +data2json(3)=struct('name','Optimus Prime','rank',9); +savejson('Supreme Commander',data2json) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a cell array\n') +fprintf(1,'%%=================================================\n\n') + +data2json=cell(3,1); +data2json{1}=struct('buzz',1.1,'rex',1.2,'bo',1.3,'hamm',2.0,'slink',2.1,'potato',2.2,... + 'woody',3.0,'sarge',3.1,'etch',4.0,'lenny',5.0,'squeeze',6.0,'wheezy',7.0); +data2json{2}=struct('Ubuntu',['Kubuntu';'Xubuntu';'Lubuntu']); +data2json{3}=[10.04,10.10,11.04,11.10] +savejson('debian',data2json,struct('FloatFormat','%.2f')) +json2data=loadjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% invalid field-name handling\n') +fprintf(1,'%%=================================================\n\n') + +json2data=loadjson('{"ValidName":1, "_InvalidName":2, ":Field:":3, "项目":"绝密"}') + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a 2D cell array\n') +fprintf(1,'%%=================================================\n\n') + +data2json={{1,{2,3}},{4,5},{6};{7},{8,9},{10}}; +savejson('data2json',data2json) +json2data=loadjson(ans) % only savejson works for cell arrays, loadjson has issues + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a 2D struct array\n') +fprintf(1,'%%=================================================\n\n') + +data2json=repmat(struct('idx',0,'data','structs'),[2,3]) +for i=1:6 + data2json(i).idx=i; +end +savejson('data2json',data2json) +json2data=loadjson(ans) + +rand ('state',rngstate); + diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/demo_ubjson_basic.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/demo_ubjson_basic.m new file mode 100644 index 0000000000000000000000000000000000000000..0c35433a4713a65b790e7b80cb7fb2a6fa48300c --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/demo_ubjson_basic.m @@ -0,0 +1,180 @@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Demonstration of Basic Utilities of JSONlab +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +rngstate = rand ('state'); +randseed=hex2dec('623F9A9E'); +clear data2json json2data + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a simple scalar value \n') +fprintf(1,'%%=================================================\n\n') + +data2json=pi +saveubjson('',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a complex number\n') +fprintf(1,'%%=================================================\n\n') + +clear i; +data2json=1+2*i +saveubjson('',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a complex matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=magic(6); +data2json=data2json(:,1:3)+data2json(:,4:6)*i +saveubjson('',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% MATLAB special constants\n') +fprintf(1,'%%=================================================\n\n') + +data2json=[NaN Inf -Inf] +saveubjson('specials',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a real sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sprand(10,10,0.1) +saveubjson('sparse',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a complex sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=data2json-data2json*i +saveubjson('complex_sparse',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an all-zero sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse(2,3); +saveubjson('all_zero_sparse',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an empty sparse matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse([]); +saveubjson('empty_sparse',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an empty 0-by-0 real matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=[]; +saveubjson('empty_0by0_real',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% an empty 0-by-3 real matrix\n') +fprintf(1,'%%=================================================\n\n') + +data2json=zeros(0,3); +saveubjson('empty_0by3_real',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse real column vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse([0,3,0,1,4]'); +saveubjson('sparse_column_vector',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse complex column vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=data2json-1i*data2json; +saveubjson('complex_sparse_column_vector',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse real row vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=sparse([0,3,0,1,4]); +saveubjson('sparse_row_vector',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a sparse complex row vector\n') +fprintf(1,'%%=================================================\n\n') + +data2json=data2json-1i*data2json; +saveubjson('complex_sparse_row_vector',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a structure\n') +fprintf(1,'%%=================================================\n\n') + +data2json=struct('name','Think Different','year',1997,'magic',magic(3),... + 'misfits',[Inf,NaN],'embedded',struct('left',true,'right',false)) +saveubjson('astruct',data2json,struct('ParseLogical',1)) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a structure array\n') +fprintf(1,'%%=================================================\n\n') + +data2json=struct('name','Nexus Prime','rank',9); +data2json(2)=struct('name','Sentinel Prime','rank',9); +data2json(3)=struct('name','Optimus Prime','rank',9); +saveubjson('Supreme Commander',data2json) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a cell array\n') +fprintf(1,'%%=================================================\n\n') + +data2json=cell(3,1); +data2json{1}=struct('buzz',1.1,'rex',1.2,'bo',1.3,'hamm',2.0,'slink',2.1,'potato',2.2,... + 'woody',3.0,'sarge',3.1,'etch',4.0,'lenny',5.0,'squeeze',6.0,'wheezy',7.0); +data2json{2}=struct('Ubuntu',['Kubuntu';'Xubuntu';'Lubuntu']); +data2json{3}=[10.04,10.10,11.04,11.10] +saveubjson('debian',data2json,struct('FloatFormat','%.2f')) +json2data=loadubjson(ans) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% invalid field-name handling\n') +fprintf(1,'%%=================================================\n\n') + +json2data=loadubjson(saveubjson('',loadjson('{"ValidName":1, "_InvalidName":2, ":Field:":3, "项目":"绝密"}'))) + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a 2D cell array\n') +fprintf(1,'%%=================================================\n\n') + +data2json={{1,{2,3}},{4,5},{6};{7},{8,9},{10}}; +saveubjson('data2json',data2json) +json2data=loadubjson(ans) % only savejson works for cell arrays, loadjson has issues + +fprintf(1,'\n%%=================================================\n') +fprintf(1,'%% a 2D struct array\n') +fprintf(1,'%%=================================================\n\n') + +data2json=repmat(struct('idx',0,'data','structs'),[2,3]) +for i=1:6 + data2json(i).idx=i; +end +saveubjson('data2json',data2json) +json2data=loadubjson(ans) + +rand ('state',rngstate); + diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_basictest.matlab b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_basictest.matlab new file mode 100644 index 0000000000000000000000000000000000000000..b41c7058cfa60c8faf0058080a06c354fa363734 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_basictest.matlab @@ -0,0 +1,671 @@ + + < M A T L A B (R) > + Copyright 1984-2010 The MathWorks, Inc. + Version 7.11.0.584 (R2010b) 64-bit (glnxa64) + August 16, 2010 + + + To get started, type one of these: helpwin, helpdesk, or demo. + For product information, visit www.mathworks.com. + +>> >> >> >> >> >> >> >> >> +%================================================= +>> % a simple scalar value +>> %================================================= + +>> >> +data2json = + + 3.1416 + +>> +ans = + +[3.141592654] + + +>> +json2data = + + 3.1416 + +>> >> +%================================================= +>> % a complex number +>> %================================================= + +>> >> >> +data2json = + + 1.0000 + 2.0000i + +>> +ans = + +{ + "_ArrayType_": "double", + "_ArraySize_": [1,1], + "_ArrayIsComplex_": 1, + "_ArrayData_": [1,2] +} + + +>> +json2data = + + 1.0000 + 2.0000i + +>> >> +%================================================= +>> % a complex matrix +>> %================================================= + +>> >> >> +data2json = + + 35.0000 +26.0000i 1.0000 +19.0000i 6.0000 +24.0000i + 3.0000 +21.0000i 32.0000 +23.0000i 7.0000 +25.0000i + 31.0000 +22.0000i 9.0000 +27.0000i 2.0000 +20.0000i + 8.0000 +17.0000i 28.0000 +10.0000i 33.0000 +15.0000i + 30.0000 +12.0000i 5.0000 +14.0000i 34.0000 +16.0000i + 4.0000 +13.0000i 36.0000 +18.0000i 29.0000 +11.0000i + +>> +ans = + +{ + "_ArrayType_": "double", + "_ArraySize_": [6,3], + "_ArrayIsComplex_": 1, + "_ArrayData_": [ + [35,26], + [3,21], + [31,22], + [8,17], + [30,12], + [4,13], + [1,19], + [32,23], + [9,27], + [28,10], + [5,14], + [36,18], + [6,24], + [7,25], + [2,20], + [33,15], + [34,16], + [29,11] + ] +} + + +>> +json2data = + + 35.0000 +26.0000i 1.0000 +19.0000i 6.0000 +24.0000i + 3.0000 +21.0000i 32.0000 +23.0000i 7.0000 +25.0000i + 31.0000 +22.0000i 9.0000 +27.0000i 2.0000 +20.0000i + 8.0000 +17.0000i 28.0000 +10.0000i 33.0000 +15.0000i + 30.0000 +12.0000i 5.0000 +14.0000i 34.0000 +16.0000i + 4.0000 +13.0000i 36.0000 +18.0000i 29.0000 +11.0000i + +>> >> +%================================================= +>> % MATLAB special constants +>> %================================================= + +>> >> +data2json = + + NaN Inf -Inf + +>> +ans = + +{ + "specials": ["_NaN_","_Inf_","-_Inf_"] +} + + +>> +json2data = + + specials: [NaN Inf -Inf] + +>> >> +%================================================= +>> % a real sparse matrix +>> %================================================= + +>> >> +data2json = + + (1,2) 0.6557 + (9,2) 0.7577 + (3,5) 0.8491 + (10,5) 0.7431 + (10,8) 0.3922 + (7,9) 0.6787 + (2,10) 0.0357 + (6,10) 0.9340 + (10,10) 0.6555 + +>> +ans = + +{ + "sparse": { + "_ArrayType_": "double", + "_ArraySize_": [10,10], + "_ArrayIsSparse_": 1, + "_ArrayData_": [ + [1,2,0.6557406992], + [9,2,0.7577401306], + [3,5,0.8491293059], + [10,5,0.7431324681], + [10,8,0.3922270195], + [7,9,0.6787351549], + [2,10,0.03571167857], + [6,10,0.9339932478], + [10,10,0.6554778902] + ] + } +} + + +>> +json2data = + + sparse: [10x10 double] + +>> >> +%================================================= +>> % a complex sparse matrix +>> %================================================= + +>> >> +data2json = + + (1,2) 0.6557 - 0.6557i + (9,2) 0.7577 - 0.7577i + (3,5) 0.8491 - 0.8491i + (10,5) 0.7431 - 0.7431i + (10,8) 0.3922 - 0.3922i + (7,9) 0.6787 - 0.6787i + (2,10) 0.0357 - 0.0357i + (6,10) 0.9340 - 0.9340i + (10,10) 0.6555 - 0.6555i + +>> +ans = + +{ + "complex_sparse": { + "_ArrayType_": "double", + "_ArraySize_": [10,10], + "_ArrayIsComplex_": 1, + "_ArrayIsSparse_": 1, + "_ArrayData_": [ + [1,2,0.6557406992,-0.6557406992], + [9,2,0.7577401306,-0.7577401306], + [3,5,0.8491293059,-0.8491293059], + [10,5,0.7431324681,-0.7431324681], + [10,8,0.3922270195,-0.3922270195], + [7,9,0.6787351549,-0.6787351549], + [2,10,0.03571167857,-0.03571167857], + [6,10,0.9339932478,-0.9339932478], + [10,10,0.6554778902,-0.6554778902] + ] + } +} + + +>> +json2data = + + complex_sparse: [10x10 double] + +>> >> +%================================================= +>> % an all-zero sparse matrix +>> %================================================= + +>> >> >> +ans = + +{ + "all_zero_sparse": { + "_ArrayType_": "double", + "_ArraySize_": [2,3], + "_ArrayIsSparse_": 1, + "_ArrayData_": null + } +} + + +>> +json2data = + + all_zero_sparse: [2x3 double] + +>> >> +%================================================= +>> % an empty sparse matrix +>> %================================================= + +>> >> >> +ans = + +{ + "empty_sparse": { + "_ArrayType_": "double", + "_ArraySize_": [0,0], + "_ArrayIsSparse_": 1, + "_ArrayData_": null + } +} + + +>> +json2data = + + empty_sparse: [] + +>> >> +%================================================= +>> % an empty 0-by-0 real matrix +>> %================================================= + +>> >> >> +ans = + +{ + "empty_0by0_real": null +} + + +>> +json2data = + + empty_0by0_real: [] + +>> >> +%================================================= +>> % an empty 0-by-3 real matrix +>> %================================================= + +>> >> >> +ans = + +{ + "empty_0by3_real": { + "_ArrayType_": "double", + "_ArraySize_": [0,3], + "_ArrayData_": null + } +} + + +>> +json2data = + + empty_0by3_real: [0x3 double] + +>> >> +%================================================= +>> % a sparse real column vector +>> %================================================= + +>> >> >> +ans = + +{ + "sparse_column_vector": { + "_ArrayType_": "double", + "_ArraySize_": [5,1], + "_ArrayIsSparse_": 1, + "_ArrayData_": [ + [2,3], + [4,1], + [5,4] + ] + } +} + + +>> +json2data = + + sparse_column_vector: [5x1 double] + +>> >> +%================================================= +>> % a sparse complex column vector +>> %================================================= + +>> >> >> +ans = + +{ + "complex_sparse_column_vector": { + "_ArrayType_": "double", + "_ArraySize_": [5,1], + "_ArrayIsComplex_": 1, + "_ArrayIsSparse_": 1, + "_ArrayData_": [ + [2,3,-3], + [4,1,-1], + [5,4,-4] + ] + } +} + + +>> +json2data = + + complex_sparse_column_vector: [5x1 double] + +>> >> +%================================================= +>> % a sparse real row vector +>> %================================================= + +>> >> >> +ans = + +{ + "sparse_row_vector": { + "_ArrayType_": "double", + "_ArraySize_": [1,5], + "_ArrayIsSparse_": 1, + "_ArrayData_": [ + [2,3], + [4,1], + [5,4] + ] + } +} + + +>> +json2data = + + sparse_row_vector: [0 3 0 1 4] + +>> >> +%================================================= +>> % a sparse complex row vector +>> %================================================= + +>> >> >> +ans = + +{ + "complex_sparse_row_vector": { + "_ArrayType_": "double", + "_ArraySize_": [1,5], + "_ArrayIsComplex_": 1, + "_ArrayIsSparse_": 1, + "_ArrayData_": [ + [2,3,-3], + [4,1,-1], + [5,4,-4] + ] + } +} + + +>> +json2data = + + complex_sparse_row_vector: [1x5 double] + +>> >> +%================================================= +>> % a structure +>> %================================================= + +>> >> +data2json = + + name: 'Think Different' + year: 1997 + magic: [3x3 double] + misfits: [Inf NaN] + embedded: [1x1 struct] + +>> +ans = + +{ + "astruct": { + "name": "Think Different", + "year": 1997, + "magic": [ + [8,1,6], + [3,5,7], + [4,9,2] + ], + "misfits": ["_Inf_","_NaN_"], + "embedded": { + "left": true, + "right": false + } + } +} + + +>> +json2data = + + astruct: [1x1 struct] + +>> +ans = + +logical + +>> >> +%================================================= +>> % a structure array +>> %================================================= + +>> >> >> >> >> +ans = + +{ + "Supreme Commander": [ + { + "name": "Nexus Prime", + "rank": 9 + }, + { + "name": "Sentinel Prime", + "rank": 9 + }, + { + "name": "Optimus Prime", + "rank": 9 + } + ] +} + + +>> +json2data = + + Supreme_0x20_Commander: {[1x1 struct] [1x1 struct] [1x1 struct]} + +>> >> +%================================================= +>> % a cell array +>> %================================================= + +>> >> >> >> >> +data2json = + + [1x1 struct] + [1x1 struct] + [1x4 double] + +>> +ans = + +{ + "debian": [ + [ + { + "buzz": 1.10, + "rex": 1.20, + "bo": 1.30, + "hamm": 2.00, + "slink": 2.10, + "potato": 2.20, + "woody": 3.00, + "sarge": 3.10, + "etch": 4.00, + "lenny": 5.00, + "squeeze": 6.00, + "wheezy": 7.00 + } + ], + [ + { + "Ubuntu": [ + "Kubuntu", + "Xubuntu", + "Lubuntu" + ] + } + ], + [ + [10.04,10.10,11.04,11.10] + ] + ] +} + + +>> +json2data = + + debian: {{1x1 cell} {1x1 cell} [10.0400 10.1000 11.0400 11.1000]} + +>> >> +%================================================= +>> % invalid field-name handling +>> %================================================= + +>> >> +json2data = + + ValidName: 1 + x0x5F_InvalidName: 2 + x0x3A_Field_0x3A_: 3 + x0xE9A1B9__0xE79BAE_: '绝密' + +>> >> +%================================================= +>> % a 2D cell array +>> %================================================= + +>> >> >> +ans = + +{ + "data2json": [ + [ + [ + 1, + [ + 2, + 3 + ] + ], + [ + 4, + 5 + ], + [ + 6 + ] + ], + [ + [ + 7 + ], + [ + 8, + 9 + ], + [ + 10 + ] + ] + ] +} + + +>> +json2data = + + data2json: {{1x3 cell} {1x3 cell}} + +>> >> +%================================================= +>> % a 2D struct array +>> %================================================= + +>> >> +data2json = + +2x3 struct array with fields: + idx + data + +>> >> +ans = + +{ + "data2json": [ + [ + { + "idx": 1, + "data": "structs" + }, + { + "idx": 2, + "data": "structs" + } + ], + [ + { + "idx": 3, + "data": "structs" + }, + { + "idx": 4, + "data": "structs" + } + ], + [ + { + "idx": 5, + "data": "structs" + }, + { + "idx": 6, + "data": "structs" + } + ] + ] +} + + +>> +json2data = + + data2json: {{1x2 cell} {1x2 cell} {1x2 cell}} + +>> >> >> >> \ No newline at end of file diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_selftest.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_selftest.m new file mode 100644 index 0000000000000000000000000000000000000000..27aee244c4e2a8013f6c3ad1f2d8731ad33893c4 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_selftest.m @@ -0,0 +1,27 @@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Regression Test Unit of loadjson and savejson +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +for i=1:4 + fname=sprintf('example%d.json',i); + if(exist(fname,'file')==0) break; end + fprintf(1,'===============================================\n>> %s\n',fname); + json=savejson('data',loadjson(fname)); + fprintf(1,'%s\n',json); + fprintf(1,'%s\n',savejson('data',loadjson(fname),'Compact',1)); + data=loadjson(json); + savejson('data',data,'selftest.json'); + data=loadjson('selftest.json'); +end + +for i=1:4 + fname=sprintf('example%d.json',i); + if(exist(fname,'file')==0) break; end + fprintf(1,'===============================================\n>> %s\n',fname); + json=saveubjson('data',loadjson(fname)); + fprintf(1,'%s\n',json); + data=loadubjson(json); + savejson('',data); + saveubjson('data',data,'selftest.ubj'); + data=loadubjson('selftest.ubj'); +end diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_selftest.matlab b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_selftest.matlab new file mode 100644 index 0000000000000000000000000000000000000000..ac652c56faa0ecd543d1756c0d21b8b306332068 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_selftest.matlab @@ -0,0 +1,154 @@ + + < M A T L A B (R) > + Copyright 1984-2010 The MathWorks, Inc. + Version 7.11.0.584 (R2010b) 64-bit (glnxa64) + August 16, 2010 + + + To get started, type one of these: helpwin, helpdesk, or demo. + For product information, visit www.mathworks.com. + +>> >> >> >> >> =============================================== +>> example1.json +{ + "data": { + "firstName": "John", + "lastName": "Smith", + "age": 25, + "address": { + "streetAddress": "21 2nd Street", + "city": "New York", + "state": "NY", + "postalCode": "10021" + }, + "phoneNumber": [ + { + "type": "home", + "number": "212 555-1234" + }, + { + "type": "fax", + "number": "646 555-4567" + } + ] + } +} + +{"data": {"firstName": "John","lastName": "Smith","age": 25,"address": {"streetAddress": "21 2nd Street","city": "New York","state": "NY","postalCode": "10021"},"phoneNumber": [{"type": "home","number": "212 555-1234"},{"type": "fax","number": "646 555-4567"}]}} + +=============================================== +>> example2.json +{ + "data": { + "glossary": { + "title": "example glossary", + "GlossDiv": { + "title": "S", + "GlossList": { + "GlossEntry": { + "ID": "SGML", + "SortAs": "SGML", + "GlossTerm": "Standard Generalized Markup Language", + "Acronym": "SGML", + "Abbrev": "ISO 8879:1986", + "GlossDef": { + "para": "A meta-markup language, used to create markup languages such as DocBook.", + "GlossSeeAlso": [ + "GML", + "XML" + ] + }, + "GlossSee": "markup" + } + } + } + } + } +} + +{"data": {"glossary": {"title": "example glossary","GlossDiv": {"title": "S","GlossList": {"GlossEntry": {"ID": "SGML","SortAs": "SGML","GlossTerm": "Standard Generalized Markup Language","Acronym": "SGML","Abbrev": "ISO 8879:1986","GlossDef": {"para": "A meta-markup language, used to create markup languages such as DocBook.","GlossSeeAlso": ["GML","XML"]},"GlossSee": "markup"}}}}}} + +=============================================== +>> example3.json +{ + "data": { + "menu": { + "id": "file", + "value": "_&File", + "popup": { + "menuitem": [ + { + "value": "_&New", + "onclick": "CreateNewDoc(\"'\\\"Untitled\\\"'\")" + }, + { + "value": "_&Open", + "onclick": "OpenDoc()" + }, + { + "value": "_&Close", + "onclick": "CloseDoc()" + } + ] + } + } + } +} + +{"data": {"menu": {"id": "file","value": "_&File","popup": {"menuitem": [{"value": "_&New","onclick": "CreateNewDoc(\"'\\\"Untitled\\\"'\")"},{"value": "_&Open","onclick": "OpenDoc()"},{"value": "_&Close","onclick": "CloseDoc()"}]}}}} + +=============================================== +>> example4.json +{ + "data": [ + { + "sample": { + "rho": 1 + } + }, + { + "sample": { + "rho": 2 + } + }, + [ + [1,0], + [1,1], + [1,2] + ], + [ + "Paper", + "Scissors", + "Stone" + ], + [ + "a", + "b\\", + "c\"", + "d\\\"", + "e\"[", + "f\\\"[", + "g[\\", + "h[\\\"" + ] + ] +} + +{"data": [{"sample": {"rho": 1}},{"sample": {"rho": 2}},[[1,0],[1,1],[1,2]],["Paper","Scissors","Stone"],["a","b\\","c\"","d\\\"","e\"[","f\\\"[","g[\\","h[\\\""]]} + +>> >> =============================================== +>> example1.json +{Udata{U firstNameSUJohnUlastNameSUSmithUageiUaddress{U streetAddressSU 21 2nd StreetUcitySUNew YorkUstateSUNYU +postalCodeSU10021}U phoneNumber[{UtypeSUhomeUnumberSU 212 555-1234}{UtypeSUfaxUnumberSU 646 555-4567}]}} +=============================================== +>> example2.json +{Udata{Uglossary{UtitleSUexample glossaryUGlossDiv{UtitleCSU GlossList{U +GlossEntry{UIDSUSGMLUSortAsSUSGMLU GlossTermSU$Standard Generalized Markup LanguageUAcronymSUSGMLUAbbrevSU ISO 8879:1986UGlossDef{UparaSUHA meta-markup language, used to create markup languages such as DocBook.U GlossSeeAlso[SUGMLSUXML]}UGlossSeeSUmarkup}}}}}} +=============================================== +>> example3.json +{Udata{Umenu{UidSUfileUvalueSU_&FileUpopup{Umenuitem[{UvalueSU_&NewUonclickSUCreateNewDoc("'\"Untitled\"'")}{UvalueSU_&OpenUonclickSU OpenDoc()}{UvalueSU_&CloseUonclickSU +CloseDoc()}]}}}} +=============================================== +>> example4.json +{Udata[{Usample{Urhoi}}{Usample{Urhoi}}[[$i#U[$i#U[$i#U][SUPaperSUScissorsSUStone][CaSUb\SUc"SUd\"SUe"[SUf\"[SUg[\SUh[\"]]} +>> \ No newline at end of file diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_speedtest.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_speedtest.m new file mode 100644 index 0000000000000000000000000000000000000000..4990fba0d2d5249be2bdd48d35ec9269c6f1b7c8 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/examples/jsonlab_speedtest.m @@ -0,0 +1,21 @@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Benchmarking processing speed of savejson and loadjson +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +datalen=[1e3 1e4 1e5 1e6]; +len=length(datalen); +tsave=zeros(len,1); +tload=zeros(len,1); +for i=1:len + tic; + json=savejson('data',struct('d1',rand(datalen(i),3),'d2',rand(datalen(i),3)>0.5)); + tsave(i)=toc; + data=loadjson(json); + tload(i)=toc-tsave(i); + fprintf(1,'matrix size: %d\n',datalen(i)); +end + +loglog(datalen,tsave,'o-',datalen,tload,'r*-'); +legend('savejson runtime (s)','loadjson runtime (s)'); +xlabel('array size'); +ylabel('running time (s)'); diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/jsonopt.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/jsonopt.m new file mode 100644 index 0000000000000000000000000000000000000000..c347e967bb1c7c30774382670fc386f442fc7958 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/jsonopt.m @@ -0,0 +1,35 @@ +function val=jsonopt(key,default,varargin) +% +% val=jsonopt(key,default,optstruct) +% +% setting options based on a struct. The struct can be produced +% by varargin2struct from a list of 'param','value' pairs +% +% authors:Qianqian Fang (fangq nmr.mgh.harvard.edu) +% +% $Id: loadjson.m 371 2012-06-20 12:43:06Z fangq $ +% +% input: +% key: a string with which one look up a value from a struct +% default: if the key does not exist, return default +% optstruct: a struct where each sub-field is a key +% +% output: +% val: if key exists, val=optstruct.key; otherwise val=default +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of jsonlab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +val=default; +if(nargin<=2) return; end +opt=varargin{1}; +if(isstruct(opt)) + if(isfield(opt,key)) + val=getfield(opt,key); + elseif(isfield(opt,lower(key))) + val=getfield(opt,lower(key)); + end +end diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/loadjson.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/loadjson.m new file mode 100644 index 0000000000000000000000000000000000000000..788b5496fa718994eca1c1351ff270c010b45f72 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/loadjson.m @@ -0,0 +1,496 @@ +function data = loadjson(fname,varargin) +% +% data=loadjson(fname,opt) +% or +% data=loadjson(fname,'param1',value1,'param2',value2,...) +% +% parse a JSON (JavaScript Object Notation) file or string +% +% authors:Qianqian Fang (fangq nmr.mgh.harvard.edu) +% created on 2011/09/09, including previous works from +% +% Nedialko Krouchev: http://www.mathworks.com/matlabcentral/fileexchange/25713 +% created on 2009/11/02 +% François Glineur: http://www.mathworks.com/matlabcentral/fileexchange/23393 +% created on 2009/03/22 +% Joel Feenstra: +% http://www.mathworks.com/matlabcentral/fileexchange/20565 +% created on 2008/07/03 +% +% $Id$ +% +% input: +% fname: input file name, if fname contains "{}" or "[]", fname +% will be interpreted as a JSON string +% opt: a struct to store parsing options, opt can be replaced by +% a list of ('param',value) pairs - the param string is equivallent +% to a field in opt. opt can have the following +% fields (first in [.|.] is the default) +% +% opt.SimplifyCell [0|1]: if set to 1, loadjson will call cell2mat +% for each element of the JSON data, and group +% arrays based on the cell2mat rules. +% opt.FastArrayParser [1|0 or integer]: if set to 1, use a +% speed-optimized array parser when loading an +% array object. The fast array parser may +% collapse block arrays into a single large +% array similar to rules defined in cell2mat; 0 to +% use a legacy parser; if set to a larger-than-1 +% value, this option will specify the minimum +% dimension to enable the fast array parser. For +% example, if the input is a 3D array, setting +% FastArrayParser to 1 will return a 3D array; +% setting to 2 will return a cell array of 2D +% arrays; setting to 3 will return to a 2D cell +% array of 1D vectors; setting to 4 will return a +% 3D cell array. +% opt.ShowProgress [0|1]: if set to 1, loadjson displays a progress bar. +% +% output: +% dat: a cell array, where {...} blocks are converted into cell arrays, +% and [...] are converted to arrays +% +% examples: +% dat=loadjson('{"obj":{"string":"value","array":[1,2,3]}}') +% dat=loadjson(['examples' filesep 'example1.json']) +% dat=loadjson(['examples' filesep 'example1.json'],'SimplifyCell',1) +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of JSONLab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +global pos inStr len esc index_esc len_esc isoct arraytoken + +if(regexp(fname,'^\s*(?:\[.+\])|(?:\{.+\})\s*$','once')) + string=fname; +elseif(exist(fname,'file')) + try + string = fileread(fname); + catch + try + string = urlread(['file://',fname]); + catch + string = urlread(['file://',fullfile(pwd,fname)]); + end + end +else + error('input file does not exist'); +end + +pos = 1; len = length(string); inStr = string; +isoct=exist('OCTAVE_VERSION','builtin'); +arraytoken=find(inStr=='[' | inStr==']' | inStr=='"'); +jstr=regexprep(inStr,'\\\\',' '); +escquote=regexp(jstr,'\\"'); +arraytoken=sort([arraytoken escquote]); + +% String delimiters and escape chars identified to improve speed: +esc = find(inStr=='"' | inStr=='\' ); % comparable to: regexp(inStr, '["\\]'); +index_esc = 1; len_esc = length(esc); + +opt=varargin2struct(varargin{:}); + +if(jsonopt('ShowProgress',0,opt)==1) + opt.progressbar_=waitbar(0,'loading ...'); +end +jsoncount=1; +while pos <= len + switch(next_char) + case '{' + data{jsoncount} = parse_object(opt); + case '[' + data{jsoncount} = parse_array(opt); + otherwise + error_pos('Outer level structure must be an object or an array'); + end + jsoncount=jsoncount+1; +end % while + +jsoncount=length(data); +if(jsoncount==1 && iscell(data)) + data=data{1}; +end + +if(isfield(opt,'progressbar_')) + close(opt.progressbar_); +end + +%%------------------------------------------------------------------------- +function object = parse_object(varargin) + parse_char('{'); + object = []; + if next_char ~= '}' + while 1 + str = parseStr(varargin{:}); + if isempty(str) + error_pos('Name of value at position %d cannot be empty'); + end + parse_char(':'); + val = parse_value(varargin{:}); + object.(valid_field(str))=val; + if next_char == '}' + break; + end + parse_char(','); + end + end + parse_char('}'); + if(isstruct(object)) + object=struct2jdata(object); + end + +%%------------------------------------------------------------------------- + +function object = parse_array(varargin) % JSON array is written in row-major order +global pos inStr isoct + parse_char('['); + object = cell(0, 1); + dim2=[]; + arraydepth=jsonopt('JSONLAB_ArrayDepth_',1,varargin{:}); + pbar=-1; + if(isfield(varargin{1},'progressbar_')) + pbar=varargin{1}.progressbar_; + end + + if next_char ~= ']' + if(jsonopt('FastArrayParser',1,varargin{:})>=1 && arraydepth>=jsonopt('FastArrayParser',1,varargin{:})) + [endpos, e1l, e1r]=matching_bracket(inStr,pos); + arraystr=['[' inStr(pos:endpos)]; + arraystr=regexprep(arraystr,'"_NaN_"','NaN'); + arraystr=regexprep(arraystr,'"([-+]*)_Inf_"','$1Inf'); + arraystr(arraystr==sprintf('\n'))=[]; + arraystr(arraystr==sprintf('\r'))=[]; + %arraystr=regexprep(arraystr,'\s*,',','); % this is slow,sometimes needed + if(~isempty(e1l) && ~isempty(e1r)) % the array is in 2D or higher D + astr=inStr((e1l+1):(e1r-1)); + astr=regexprep(astr,'"_NaN_"','NaN'); + astr=regexprep(astr,'"([-+]*)_Inf_"','$1Inf'); + astr(astr==sprintf('\n'))=[]; + astr(astr==sprintf('\r'))=[]; + astr(astr==' ')=''; + if(isempty(find(astr=='[', 1))) % array is 2D + dim2=length(sscanf(astr,'%f,',[1 inf])); + end + else % array is 1D + astr=arraystr(2:end-1); + astr(astr==' ')=''; + [obj, count, errmsg, nextidx]=sscanf(astr,'%f,',[1,inf]); + if(nextidx>=length(astr)-1) + object=obj; + pos=endpos; + parse_char(']'); + return; + end + end + if(~isempty(dim2)) + astr=arraystr; + astr(astr=='[')=''; + astr(astr==']')=''; + astr(astr==' ')=''; + [obj, count, errmsg, nextidx]=sscanf(astr,'%f,',inf); + if(nextidx>=length(astr)-1) + object=reshape(obj,dim2,numel(obj)/dim2)'; + pos=endpos; + parse_char(']'); + if(pbar>0) + waitbar(pos/length(inStr),pbar,'loading ...'); + end + return; + end + end + arraystr=regexprep(arraystr,'\]\s*,','];'); + else + arraystr='['; + end + try + if(isoct && regexp(arraystr,'"','once')) + error('Octave eval can produce empty cells for JSON-like input'); + end + object=eval(arraystr); + pos=endpos; + catch + while 1 + newopt=varargin2struct(varargin{:},'JSONLAB_ArrayDepth_',arraydepth+1); + val = parse_value(newopt); + object{end+1} = val; + if next_char == ']' + break; + end + parse_char(','); + end + end + end + if(jsonopt('SimplifyCell',0,varargin{:})==1) + try + oldobj=object; + object=cell2mat(object')'; + if(iscell(oldobj) && isstruct(object) && numel(object)>1 && jsonopt('SimplifyCellArray',1,varargin{:})==0) + object=oldobj; + elseif(size(object,1)>1 && ismatrix(object)) + object=object'; + end + catch + end + end + parse_char(']'); + + if(pbar>0) + waitbar(pos/length(inStr),pbar,'loading ...'); + end +%%------------------------------------------------------------------------- + +function parse_char(c) + global pos inStr len + pos=skip_whitespace(pos,inStr,len); + if pos > len || inStr(pos) ~= c + error_pos(sprintf('Expected %c at position %%d', c)); + else + pos = pos + 1; + pos=skip_whitespace(pos,inStr,len); + end + +%%------------------------------------------------------------------------- + +function c = next_char + global pos inStr len + pos=skip_whitespace(pos,inStr,len); + if pos > len + c = []; + else + c = inStr(pos); + end + +%%------------------------------------------------------------------------- + +function newpos=skip_whitespace(pos,inStr,len) + newpos=pos; + while newpos <= len && isspace(inStr(newpos)) + newpos = newpos + 1; + end + +%%------------------------------------------------------------------------- +function str = parseStr(varargin) + global pos inStr len esc index_esc len_esc + % len, ns = length(inStr), keyboard + if inStr(pos) ~= '"' + error_pos('String starting with " expected at position %d'); + else + pos = pos + 1; + end + str = ''; + while pos <= len + while index_esc <= len_esc && esc(index_esc) < pos + index_esc = index_esc + 1; + end + if index_esc > len_esc + str = [str inStr(pos:len)]; + pos = len + 1; + break; + else + str = [str inStr(pos:esc(index_esc)-1)]; + pos = esc(index_esc); + end + nstr = length(str); + switch inStr(pos) + case '"' + pos = pos + 1; + if(~isempty(str)) + if(strcmp(str,'_Inf_')) + str=Inf; + elseif(strcmp(str,'-_Inf_')) + str=-Inf; + elseif(strcmp(str,'_NaN_')) + str=NaN; + end + end + return; + case '\' + if pos+1 > len + error_pos('End of file reached right after escape character'); + end + pos = pos + 1; + switch inStr(pos) + case {'"' '\' '/'} + str(nstr+1) = inStr(pos); + pos = pos + 1; + case {'b' 'f' 'n' 'r' 't'} + str(nstr+1) = sprintf(['\' inStr(pos)]); + pos = pos + 1; + case 'u' + if pos+4 > len + error_pos('End of file reached in escaped unicode character'); + end + str(nstr+(1:6)) = inStr(pos-1:pos+4); + pos = pos + 5; + end + otherwise % should never happen + str(nstr+1) = inStr(pos); + keyboard; + pos = pos + 1; + end + end + error_pos('End of file while expecting end of inStr'); + +%%------------------------------------------------------------------------- + +function num = parse_number(varargin) + global pos inStr isoct + currstr=inStr(pos:min(pos+30,end)); + if(isoct~=0) + numstr=regexp(currstr,'^\s*-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+\-]?\d+)?','end'); + [num] = sscanf(currstr, '%f', 1); + delta=numstr+1; + else + [num, one, err, delta] = sscanf(currstr, '%f', 1); + if ~isempty(err) + error_pos('Error reading number at position %d'); + end + end + pos = pos + delta-1; + +%%------------------------------------------------------------------------- + +function val = parse_value(varargin) + global pos inStr len + + if(isfield(varargin{1},'progressbar_')) + waitbar(pos/len,varargin{1}.progressbar_,'loading ...'); + end + + switch(inStr(pos)) + case '"' + val = parseStr(varargin{:}); + return; + case '[' + val = parse_array(varargin{:}); + return; + case '{' + val = parse_object(varargin{:}); + return; + case {'-','0','1','2','3','4','5','6','7','8','9'} + val = parse_number(varargin{:}); + return; + case 't' + if pos+3 <= len && strcmpi(inStr(pos:pos+3), 'true') + val = true; + pos = pos + 4; + return; + end + case 'f' + if pos+4 <= len && strcmpi(inStr(pos:pos+4), 'false') + val = false; + pos = pos + 5; + return; + end + case 'n' + if pos+3 <= len && strcmpi(inStr(pos:pos+3), 'null') + val = []; + pos = pos + 4; + return; + end + end + error_pos('Value expected at position %d'); +%%------------------------------------------------------------------------- + +function error_pos(msg) + global pos inStr len + poShow = max(min([pos-15 pos-1 pos pos+20],len),1); + if poShow(3) == poShow(2) + poShow(3:4) = poShow(2)+[0 -1]; % display nothing after + end + msg = [sprintf(msg, pos) ': ' ... + inStr(poShow(1):poShow(2)) '' inStr(poShow(3):poShow(4)) ]; + error( ['JSONparser:invalidFormat: ' msg] ); + +%%------------------------------------------------------------------------- + +function str = valid_field(str) +global isoct +% From MATLAB doc: field names must begin with a letter, which may be +% followed by any combination of letters, digits, and underscores. +% Invalid characters will be converted to underscores, and the prefix +% "x0x[Hex code]_" will be added if the first character is not a letter. + pos=regexp(str,'^[^A-Za-z]','once'); + if(~isempty(pos)) + if(~isoct) + str=regexprep(str,'^([^A-Za-z])','x0x${sprintf(''%X'',unicode2native($1))}_','once'); + else + str=sprintf('x0x%X_%s',char(str(1)),str(2:end)); + end + end + if(isempty(regexp(str,'[^0-9A-Za-z_]', 'once' ))) + return; + end + if(~isoct) + str=regexprep(str,'([^0-9A-Za-z_])','_0x${sprintf(''%X'',unicode2native($1))}_'); + else + pos=regexp(str,'[^0-9A-Za-z_]'); + if(isempty(pos)) + return; + end + str0=str; + pos0=[0 pos(:)' length(str)]; + str=''; + for i=1:length(pos) + str=[str str0(pos0(i)+1:pos(i)-1) sprintf('_0x%X_',str0(pos(i)))]; + end + if(pos(end)~=length(str)) + str=[str str0(pos0(end-1)+1:pos0(end))]; + end + end + %str(~isletter(str) & ~('0' <= str & str <= '9')) = '_'; + +%%------------------------------------------------------------------------- +function endpos = matching_quote(str,pos) +len=length(str); +while(pos1 && str(pos-1)=='\')) + endpos=pos; + return; + end + end + pos=pos+1; +end +error('unmatched quotation mark'); +%%------------------------------------------------------------------------- +function [endpos, e1l, e1r, maxlevel] = matching_bracket(str,pos) +global arraytoken +level=1; +maxlevel=level; +endpos=0; +bpos=arraytoken(arraytoken>=pos); +tokens=str(bpos); +len=length(tokens); +pos=1; +e1l=[]; +e1r=[]; +while(pos<=len) + c=tokens(pos); + if(c==']') + level=level-1; + if(isempty(e1r)) + e1r=bpos(pos); + end + if(level==0) + endpos=bpos(pos); + return + end + end + if(c=='[') + if(isempty(e1l)) + e1l=bpos(pos); + end + level=level+1; + maxlevel=max(maxlevel,level); + end + if(c=='"') + pos=matching_quote(tokens,pos+1); + end + pos=pos+1; +end +if(endpos==0) + error('unmatched "]"'); +end diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/loadubjson.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/loadubjson.m new file mode 100644 index 0000000000000000000000000000000000000000..bb47a6a3127953b59a089adc7a6692bef70cf080 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/loadubjson.m @@ -0,0 +1,457 @@ +function data = loadubjson(fname,varargin) +% +% data=loadubjson(fname,opt) +% or +% data=loadubjson(fname,'param1',value1,'param2',value2,...) +% +% parse a JSON (JavaScript Object Notation) file or string +% +% authors:Qianqian Fang (fangq nmr.mgh.harvard.edu) +% created on 2013/08/01 +% +% $Id$ +% +% input: +% fname: input file name, if fname contains "{}" or "[]", fname +% will be interpreted as a UBJSON string +% opt: a struct to store parsing options, opt can be replaced by +% a list of ('param',value) pairs - the param string is equivallent +% to a field in opt. opt can have the following +% fields (first in [.|.] is the default) +% +% opt.SimplifyCell [0|1]: if set to 1, loadubjson will call cell2mat +% for each element of the JSON data, and group +% arrays based on the cell2mat rules. +% opt.IntEndian [B|L]: specify the endianness of the integer fields +% in the UBJSON input data. B - Big-Endian format for +% integers (as required in the UBJSON specification); +% L - input integer fields are in Little-Endian order. +% opt.NameIsString [0|1]: for UBJSON Specification Draft 8 or +% earlier versions (JSONLab 1.0 final or earlier), +% the "name" tag is treated as a string. To load +% these UBJSON data, you need to manually set this +% flag to 1. +% +% output: +% dat: a cell array, where {...} blocks are converted into cell arrays, +% and [...] are converted to arrays +% +% examples: +% obj=struct('string','value','array',[1 2 3]); +% ubjdata=saveubjson('obj',obj); +% dat=loadubjson(ubjdata) +% dat=loadubjson(['examples' filesep 'example1.ubj']) +% dat=loadubjson(['examples' filesep 'example1.ubj'],'SimplifyCell',1) +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of JSONLab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +global pos inStr len esc index_esc len_esc isoct arraytoken fileendian systemendian + +if(regexp(fname,'[\{\}\]\[]','once')) + string=fname; +elseif(exist(fname,'file')) + fid = fopen(fname,'rb'); + string = fread(fid,inf,'uint8=>char')'; + fclose(fid); +else + error('input file does not exist'); +end + +pos = 1; len = length(string); inStr = string; +isoct=exist('OCTAVE_VERSION','builtin'); +arraytoken=find(inStr=='[' | inStr==']' | inStr=='"'); +jstr=regexprep(inStr,'\\\\',' '); +escquote=regexp(jstr,'\\"'); +arraytoken=sort([arraytoken escquote]); + +% String delimiters and escape chars identified to improve speed: +esc = find(inStr=='"' | inStr=='\' ); % comparable to: regexp(inStr, '["\\]'); +index_esc = 1; len_esc = length(esc); + +opt=varargin2struct(varargin{:}); +fileendian=upper(jsonopt('IntEndian','B',opt)); +[os,maxelem,systemendian]=computer; + +jsoncount=1; +while pos <= len + switch(next_char) + case '{' + data{jsoncount} = parse_object(opt); + case '[' + data{jsoncount} = parse_array(opt); + otherwise + error_pos('Outer level structure must be an object or an array'); + end + jsoncount=jsoncount+1; +end % while + +jsoncount=length(data); +if(jsoncount==1 && iscell(data)) + data=data{1}; +end + +%%------------------------------------------------------------------------- +function object = parse_object(varargin) + parse_char('{'); + object = []; + type=''; + count=-1; + if(next_char == '$') + type=inStr(pos+1); % TODO + pos=pos+2; + end + if(next_char == '#') + pos=pos+1; + count=double(parse_number()); + end + if next_char ~= '}' + num=0; + while 1 + if(jsonopt('NameIsString',0,varargin{:})) + str = parseStr(varargin{:}); + else + str = parse_name(varargin{:}); + end + if isempty(str) + error_pos('Name of value at position %d cannot be empty'); + end + %parse_char(':'); + val = parse_value(varargin{:}); + num=num+1; + object.(valid_field(str))=val; + if next_char == '}' || (count>=0 && num>=count) + break; + end + %parse_char(','); + end + end + if(count==-1) + parse_char('}'); + end + if(isstruct(object)) + object=struct2jdata(object); + end + +%%------------------------------------------------------------------------- +function [cid,len]=elem_info(type) +id=strfind('iUIlLdD',type); +dataclass={'int8','uint8','int16','int32','int64','single','double'}; +bytelen=[1,1,2,4,8,4,8]; +if(id>0) + cid=dataclass{id}; + len=bytelen(id); +else + error_pos('unsupported type at position %d'); +end +%%------------------------------------------------------------------------- + + +function [data, adv]=parse_block(type,count,varargin) +global pos inStr isoct fileendian systemendian +[cid,len]=elem_info(type); +datastr=inStr(pos:pos+len*count-1); +if(isoct) + newdata=int8(datastr); +else + newdata=uint8(datastr); +end +id=strfind('iUIlLdD',type); +if(id<=5 && fileendian~=systemendian) + newdata=swapbytes(typecast(newdata,cid)); +end +data=typecast(newdata,cid); +adv=double(len*count); + +%%------------------------------------------------------------------------- + + +function object = parse_array(varargin) % JSON array is written in row-major order +global pos inStr + parse_char('['); + object = cell(0, 1); + dim=[]; + type=''; + count=-1; + if(next_char == '$') + type=inStr(pos+1); + pos=pos+2; + end + if(next_char == '#') + pos=pos+1; + if(next_char=='[') + dim=parse_array(varargin{:}); + count=prod(double(dim)); + else + count=double(parse_number()); + end + end + if(~isempty(type)) + if(count>=0) + [object, adv]=parse_block(type,count,varargin{:}); + if(~isempty(dim)) + object=reshape(object,dim); + end + pos=pos+adv; + return; + else + endpos=matching_bracket(inStr,pos); + [cid,len]=elem_info(type); + count=(endpos-pos)/len; + [object, adv]=parse_block(type,count,varargin{:}); + pos=pos+adv; + parse_char(']'); + return; + end + end + if next_char ~= ']' + while 1 + val = parse_value(varargin{:}); + object{end+1} = val; + if next_char == ']' + break; + end + %parse_char(','); + end + end + if(jsonopt('SimplifyCell',0,varargin{:})==1) + try + oldobj=object; + object=cell2mat(object')'; + if(iscell(oldobj) && isstruct(object) && numel(object)>1 && jsonopt('SimplifyCellArray',1,varargin{:})==0) + object=oldobj; + elseif(size(object,1)>1 && ismatrix(object)) + object=object'; + end + catch + end + end + if(count==-1) + parse_char(']'); + end + +%%------------------------------------------------------------------------- + +function parse_char(c) + global pos inStr len + skip_whitespace; + if pos > len || inStr(pos) ~= c + error_pos(sprintf('Expected %c at position %%d', c)); + else + pos = pos + 1; + skip_whitespace; + end + +%%------------------------------------------------------------------------- + +function c = next_char + global pos inStr len + skip_whitespace; + if pos > len + c = []; + else + c = inStr(pos); + end + +%%------------------------------------------------------------------------- + +function skip_whitespace + global pos inStr len + while pos <= len && isspace(inStr(pos)) + pos = pos + 1; + end + +%%------------------------------------------------------------------------- +function str = parse_name(varargin) + global pos inStr + bytelen=double(parse_number()); + if(length(inStr)>=pos+bytelen-1) + str=inStr(pos:pos+bytelen-1); + pos=pos+bytelen; + else + error_pos('End of file while expecting end of name'); + end +%%------------------------------------------------------------------------- + +function str = parseStr(varargin) + global pos inStr + % len, ns = length(inStr), keyboard + type=inStr(pos); + if type ~= 'S' && type ~= 'C' && type ~= 'H' + error_pos('String starting with S expected at position %d'); + else + pos = pos + 1; + end + if(type == 'C') + str=inStr(pos); + pos=pos+1; + return; + end + bytelen=double(parse_number()); + if(length(inStr)>=pos+bytelen-1) + str=inStr(pos:pos+bytelen-1); + pos=pos+bytelen; + else + error_pos('End of file while expecting end of inStr'); + end + +%%------------------------------------------------------------------------- + +function num = parse_number(varargin) + global pos inStr isoct fileendian systemendian + id=strfind('iUIlLdD',inStr(pos)); + if(isempty(id)) + error_pos('expecting a number at position %d'); + end + type={'int8','uint8','int16','int32','int64','single','double'}; + bytelen=[1,1,2,4,8,4,8]; + datastr=inStr(pos+1:pos+bytelen(id)); + if(isoct) + newdata=int8(datastr); + else + newdata=uint8(datastr); + end + if(id<=5 && fileendian~=systemendian) + newdata=swapbytes(typecast(newdata,type{id})); + end + num=typecast(newdata,type{id}); + pos = pos + bytelen(id)+1; + +%%------------------------------------------------------------------------- + +function val = parse_value(varargin) + global pos inStr + + switch(inStr(pos)) + case {'S','C','H'} + val = parseStr(varargin{:}); + return; + case '[' + val = parse_array(varargin{:}); + return; + case '{' + val = parse_object(varargin{:}); + return; + case {'i','U','I','l','L','d','D'} + val = parse_number(varargin{:}); + return; + case 'T' + val = true; + pos = pos + 1; + return; + case 'F' + val = false; + pos = pos + 1; + return; + case {'Z','N'} + val = []; + pos = pos + 1; + return; + end + error_pos('Value expected at position %d'); +%%------------------------------------------------------------------------- + +function error_pos(msg) + global pos inStr len + poShow = max(min([pos-15 pos-1 pos pos+20],len),1); + if poShow(3) == poShow(2) + poShow(3:4) = poShow(2)+[0 -1]; % display nothing after + end + msg = [sprintf(msg, pos) ': ' ... + inStr(poShow(1):poShow(2)) '' inStr(poShow(3):poShow(4)) ]; + error( ['JSONparser:invalidFormat: ' msg] ); + +%%------------------------------------------------------------------------- + +function str = valid_field(str) +global isoct +% From MATLAB doc: field names must begin with a letter, which may be +% followed by any combination of letters, digits, and underscores. +% Invalid characters will be converted to underscores, and the prefix +% "x0x[Hex code]_" will be added if the first character is not a letter. + pos=regexp(str,'^[^A-Za-z]','once'); + if(~isempty(pos)) + if(~isoct) + str=regexprep(str,'^([^A-Za-z])','x0x${sprintf(''%X'',unicode2native($1))}_','once'); + else + str=sprintf('x0x%X_%s',char(str(1)),str(2:end)); + end + end + if(isempty(regexp(str,'[^0-9A-Za-z_]', 'once' ))) + return; + end + if(~isoct) + str=regexprep(str,'([^0-9A-Za-z_])','_0x${sprintf(''%X'',unicode2native($1))}_'); + else + pos=regexp(str,'[^0-9A-Za-z_]'); + if(isempty(pos)) + return; + end + str0=str; + pos0=[0 pos(:)' length(str)]; + str=''; + for i=1:length(pos) + str=[str str0(pos0(i)+1:pos(i)-1) sprintf('_0x%X_',str0(pos(i)))]; + end + if(pos(end)~=length(str)) + str=[str str0(pos0(end-1)+1:pos0(end))]; + end + end + %str(~isletter(str) & ~('0' <= str & str <= '9')) = '_'; + +%%------------------------------------------------------------------------- +function endpos = matching_quote(str,pos) +len=length(str); +while(pos1 && str(pos-1)=='\')) + endpos=pos; + return; + end + end + pos=pos+1; +end +error('unmatched quotation mark'); +%%------------------------------------------------------------------------- +function [endpos, e1l, e1r, maxlevel] = matching_bracket(str,pos) +global arraytoken +level=1; +maxlevel=level; +endpos=0; +bpos=arraytoken(arraytoken>=pos); +tokens=str(bpos); +len=length(tokens); +pos=1; +e1l=[]; +e1r=[]; +while(pos<=len) + c=tokens(pos); + if(c==']') + level=level-1; + if(isempty(e1r)) + e1r=bpos(pos); + end + if(level==0) + endpos=bpos(pos); + return + end + end + if(c=='[') + if(isempty(e1l)) + e1l=bpos(pos); + end + level=level+1; + maxlevel=max(maxlevel,level); + end + if(c=='"') + pos=matching_quote(tokens,pos+1); + end + pos=pos+1; +end +if(endpos==0) + error('unmatched "]"'); +end + diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/mergestruct.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/mergestruct.m new file mode 100644 index 0000000000000000000000000000000000000000..c89b95275094dd506bea61caceed59b97fbc636a --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/mergestruct.m @@ -0,0 +1,33 @@ +function s=mergestruct(s1,s2) +% +% s=mergestruct(s1,s2) +% +% merge two struct objects into one +% +% authors:Qianqian Fang (fangq nmr.mgh.harvard.edu) +% date: 2012/12/22 +% +% input: +% s1,s2: a struct object, s1 and s2 can not be arrays +% +% output: +% s: the merged struct object. fields in s1 and s2 will be combined in s. +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of jsonlab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +if(~isstruct(s1) || ~isstruct(s2)) + error('input parameters contain non-struct'); +end +if(length(s1)>1 || length(s2)>1) + error('can not merge struct arrays'); +end +fn=fieldnames(s2); +s=s1; +for i=1:length(fn) + s=setfield(s,fn{i},getfield(s2,fn{i})); +end + diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/savejson.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/savejson.m new file mode 100644 index 0000000000000000000000000000000000000000..e88b18994be6d951a94efa1aa0a344a972a43c65 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/savejson.m @@ -0,0 +1,551 @@ +function json=savejson(rootname,obj,varargin) +% +% json=savejson(rootname,obj,filename) +% or +% json=savejson(rootname,obj,opt) +% json=savejson(rootname,obj,'param1',value1,'param2',value2,...) +% +% convert a MATLAB object (cell, struct or array) into a JSON (JavaScript +% Object Notation) string +% +% author: Qianqian Fang (fangq nmr.mgh.harvard.edu) +% created on 2011/09/09 +% +% $Id$ +% +% input: +% rootname: the name of the root-object, when set to '', the root name +% is ignored, however, when opt.ForceRootName is set to 1 (see below), +% the MATLAB variable name will be used as the root name. +% obj: a MATLAB object (array, cell, cell array, struct, struct array, +% class instance). +% filename: a string for the file name to save the output JSON data. +% opt: a struct for additional options, ignore to use default values. +% opt can have the following fields (first in [.|.] is the default) +% +% opt.FileName [''|string]: a file name to save the output JSON data +% opt.FloatFormat ['%.10g'|string]: format to show each numeric element +% of a 1D/2D array; +% opt.ArrayIndent [1|0]: if 1, output explicit data array with +% precedent indentation; if 0, no indentation +% opt.ArrayToStruct[0|1]: when set to 0, savejson outputs 1D/2D +% array in JSON array format; if sets to 1, an +% array will be shown as a struct with fields +% "_ArrayType_", "_ArraySize_" and "_ArrayData_"; for +% sparse arrays, the non-zero elements will be +% saved to _ArrayData_ field in triplet-format i.e. +% (ix,iy,val) and "_ArrayIsSparse_" will be added +% with a value of 1; for a complex array, the +% _ArrayData_ array will include two columns +% (4 for sparse) to record the real and imaginary +% parts, and also "_ArrayIsComplex_":1 is added. +% opt.ParseLogical [0|1]: if this is set to 1, logical array elem +% will use true/false rather than 1/0. +% opt.SingletArray [0|1]: if this is set to 1, arrays with a single +% numerical element will be shown without a square +% bracket, unless it is the root object; if 0, square +% brackets are forced for any numerical arrays. +% opt.SingletCell [1|0]: if 1, always enclose a cell with "[]" +% even it has only one element; if 0, brackets +% are ignored when a cell has only 1 element. +% opt.ForceRootName [0|1]: when set to 1 and rootname is empty, savejson +% will use the name of the passed obj variable as the +% root object name; if obj is an expression and +% does not have a name, 'root' will be used; if this +% is set to 0 and rootname is empty, the root level +% will be merged down to the lower level. +% opt.Inf ['"$1_Inf_"'|string]: a customized regular expression pattern +% to represent +/-Inf. The matched pattern is '([-+]*)Inf' +% and $1 represents the sign. For those who want to use +% 1e999 to represent Inf, they can set opt.Inf to '$11e999' +% opt.NaN ['"_NaN_"'|string]: a customized regular expression pattern +% to represent NaN +% opt.JSONP [''|string]: to generate a JSONP output (JSON with padding), +% for example, if opt.JSONP='foo', the JSON data is +% wrapped inside a function call as 'foo(...);' +% opt.UnpackHex [1|0]: conver the 0x[hex code] output by loadjson +% back to the string form +% opt.SaveBinary [0|1]: 1 - save the JSON file in binary mode; 0 - text mode. +% opt.Compact [0|1]: 1- out compact JSON format (remove all newlines and tabs) +% +% opt can be replaced by a list of ('param',value) pairs. The param +% string is equivallent to a field in opt and is case sensitive. +% output: +% json: a string in the JSON format (see http://json.org) +% +% examples: +% jsonmesh=struct('MeshNode',[0 0 0;1 0 0;0 1 0;1 1 0;0 0 1;1 0 1;0 1 1;1 1 1],... +% 'MeshTetra',[1 2 4 8;1 3 4 8;1 2 6 8;1 5 6 8;1 5 7 8;1 3 7 8],... +% 'MeshTri',[1 2 4;1 2 6;1 3 4;1 3 7;1 5 6;1 5 7;... +% 2 8 4;2 8 6;3 8 4;3 8 7;5 8 6;5 8 7],... +% 'MeshCreator','FangQ','MeshTitle','T6 Cube',... +% 'SpecialData',[nan, inf, -inf]); +% savejson('jmesh',jsonmesh) +% savejson('',jsonmesh,'ArrayIndent',0,'FloatFormat','\t%.5g') +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of JSONLab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +if(nargin==1) + varname=inputname(1); + obj=rootname; + if(isempty(varname)) + varname='root'; + end + rootname=varname; +else + varname=inputname(2); +end +if(length(varargin)==1 && ischar(varargin{1})) + opt=struct('filename',varargin{1}); +else + opt=varargin2struct(varargin{:}); +end +opt.IsOctave=exist('OCTAVE_VERSION','builtin'); +if(isfield(opt,'norowbracket')) + warning('Option ''NoRowBracket'' is depreciated, please use ''SingletArray'' and set its value to not(NoRowBracket)'); + if(~isfield(opt,'singletarray')) + opt.singletarray=not(opt.norowbracket); + end +end +rootisarray=0; +rootlevel=1; +forceroot=jsonopt('ForceRootName',0,opt); +if((isnumeric(obj) || islogical(obj) || ischar(obj) || isstruct(obj) || ... + iscell(obj) || isobject(obj)) && isempty(rootname) && forceroot==0) + rootisarray=1; + rootlevel=0; +else + if(isempty(rootname)) + rootname=varname; + end +end +if((isstruct(obj) || iscell(obj))&& isempty(rootname) && forceroot) + rootname='root'; +end + +whitespaces=struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n')); +if(jsonopt('Compact',0,opt)==1) + whitespaces=struct('tab','','newline','','sep',','); +end +if(~isfield(opt,'whitespaces_')) + opt.whitespaces_=whitespaces; +end + +nl=whitespaces.newline; + +json=obj2json(rootname,obj,rootlevel,opt); +if(rootisarray) + json=sprintf('%s%s',json,nl); +else + json=sprintf('{%s%s%s}\n',nl,json,nl); +end + +jsonp=jsonopt('JSONP','',opt); +if(~isempty(jsonp)) + json=sprintf('%s(%s);%s',jsonp,json,nl); +end + +% save to a file if FileName is set, suggested by Patrick Rapin +filename=jsonopt('FileName','',opt); +if(~isempty(filename)) + if(jsonopt('SaveBinary',0,opt)==1) + fid = fopen(filename, 'wb'); + fwrite(fid,json); + else + fid = fopen(filename, 'wt'); + fwrite(fid,json,'char'); + end + fclose(fid); +end + +%%------------------------------------------------------------------------- +function txt=obj2json(name,item,level,varargin) + +if(iscell(item)) + txt=cell2json(name,item,level,varargin{:}); +elseif(isstruct(item)) + txt=struct2json(name,item,level,varargin{:}); +elseif(ischar(item)) + txt=str2json(name,item,level,varargin{:}); +elseif(isobject(item)) + txt=matlabobject2json(name,item,level,varargin{:}); +else + txt=mat2json(name,item,level,varargin{:}); +end + +%%------------------------------------------------------------------------- +function txt=cell2json(name,item,level,varargin) +txt={}; +if(~iscell(item)) + error('input is not a cell'); +end + +dim=size(item); +if(ndims(squeeze(item))>2) % for 3D or higher dimensions, flatten to 2D for now + item=reshape(item,dim(1),numel(item)/dim(1)); + dim=size(item); +end +len=numel(item); +ws=jsonopt('whitespaces_',struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n')),varargin{:}); +padding0=repmat(ws.tab,1,level); +padding2=repmat(ws.tab,1,level+1); +nl=ws.newline; +bracketlevel=~jsonopt('singletcell',1,varargin{:}); +if(len>bracketlevel) + if(~isempty(name)) + txt={padding0, '"', checkname(name,varargin{:}),'": [', nl}; name=''; + else + txt={padding0, '[', nl}; + end +elseif(len==0) + if(~isempty(name)) + txt={padding0, '"' checkname(name,varargin{:}) '": []'}; name=''; + else + txt={padding0, '[]'}; + end +end +for i=1:dim(1) + if(dim(1)>1) + txt(end+1:end+3)={padding2,'[',nl}; + end + for j=1:dim(2) + txt{end+1}=obj2json(name,item{i,j},level+(dim(1)>1)+(len>bracketlevel),varargin{:}); + if(j1) + txt(end+1:end+3)={nl,padding2,']'}; + end + if(ibracketlevel) + txt(end+1:end+3)={nl,padding0,']'}; +end +txt = sprintf('%s',txt{:}); + +%%------------------------------------------------------------------------- +function txt=struct2json(name,item,level,varargin) +txt={}; +if(~isstruct(item)) + error('input is not a struct'); +end +dim=size(item); +if(ndims(squeeze(item))>2) % for 3D or higher dimensions, flatten to 2D for now + item=reshape(item,dim(1),numel(item)/dim(1)); + dim=size(item); +end +len=numel(item); +forcearray= (len>1 || (jsonopt('SingletArray',0,varargin{:})==1 && level>0)); +ws=struct('tab',sprintf('\t'),'newline',sprintf('\n')); +ws=jsonopt('whitespaces_',ws,varargin{:}); +padding0=repmat(ws.tab,1,level); +padding2=repmat(ws.tab,1,level+1); +padding1=repmat(ws.tab,1,level+(dim(1)>1)+forcearray); +nl=ws.newline; + +if(isempty(item)) + if(~isempty(name)) + txt={padding0, '"', checkname(name,varargin{:}),'": []'}; + else + txt={padding0, '[]'}; + end + return; +end +if(~isempty(name)) + if(forcearray) + txt={padding0, '"', checkname(name,varargin{:}),'": [', nl}; + end +else + if(forcearray) + txt={padding0, '[', nl}; + end +end +for j=1:dim(2) + if(dim(1)>1) + txt(end+1:end+3)={padding2,'[',nl}; + end + for i=1:dim(1) + names = fieldnames(item(i,j)); + if(~isempty(name) && len==1 && ~forcearray) + txt(end+1:end+5)={padding1, '"', checkname(name,varargin{:}),'": {', nl}; + else + txt(end+1:end+3)={padding1, '{', nl}; + end + if(~isempty(names)) + for e=1:length(names) + txt{end+1}=obj2json(names{e},item(i,j).(names{e}),... + level+(dim(1)>1)+1+forcearray,varargin{:}); + if(e1) + txt(end+1:end+3)={nl,padding2,']'}; + end + if(j1) + txt={padding1, '"', checkname(name,varargin{:}),'": [', nl}; + end +else + if(len>1) + txt={padding1, '[', nl}; + end +end +for e=1:len + val=escapejsonstring(item(e,:)); + if(len==1) + obj=['"' checkname(name,varargin{:}) '": ' '"',val,'"']; + if(isempty(name)) + obj=['"',val,'"']; + end + txt(end+1:end+2)={padding1, obj}; + else + txt(end+1:end+4)={padding0,'"',val,'"'}; + end + if(e==len) + sep=''; + end + txt{end+1}=sep; +end +if(len>1) + txt(end+1:end+3)={nl,padding1,']'}; +end +txt = sprintf('%s',txt{:}); + +%%------------------------------------------------------------------------- +function txt=mat2json(name,item,level,varargin) +if(~isnumeric(item) && ~islogical(item)) + error('input is not an array'); +end +ws=struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n')); +ws=jsonopt('whitespaces_',ws,varargin{:}); +padding1=repmat(ws.tab,1,level); +padding0=repmat(ws.tab,1,level+1); +nl=ws.newline; +sep=ws.sep; + +if(length(size(item))>2 || issparse(item) || ~isreal(item) || ... + (isempty(item) && any(size(item))) ||jsonopt('ArrayToStruct',0,varargin{:})) + if(isempty(name)) + txt=sprintf('%s{%s%s"_ArrayType_": "%s",%s%s"_ArraySize_": %s,%s',... + padding1,nl,padding0,class(item),nl,padding0,regexprep(mat2str(size(item)),'\s+',','),nl); + else + txt=sprintf('%s"%s": {%s%s"_ArrayType_": "%s",%s%s"_ArraySize_": %s,%s',... + padding1,checkname(name,varargin{:}),nl,padding0,class(item),nl,padding0,regexprep(mat2str(size(item)),'\s+',','),nl); + end +else + if(numel(item)==1 && jsonopt('SingletArray',0,varargin{:})==0 && level>0) + numtxt=regexprep(regexprep(matdata2json(item,level+1,varargin{:}),'^\[',''),']',''); + else + numtxt=matdata2json(item,level+1,varargin{:}); + end + if(isempty(name)) + txt=sprintf('%s%s',padding1,numtxt); + else + if(numel(item)==1 && jsonopt('SingletArray',0,varargin{:})==0) + txt=sprintf('%s"%s": %s',padding1,checkname(name,varargin{:}),numtxt); + else + txt=sprintf('%s"%s": %s',padding1,checkname(name,varargin{:}),numtxt); + end + end + return; +end +dataformat='%s%s%s%s%s'; + +if(issparse(item)) + [ix,iy]=find(item); + data=full(item(find(item))); + if(~isreal(item)) + data=[real(data(:)),imag(data(:))]; + if(size(item,1)==1) + % Kludge to have data's 'transposedness' match item's. + % (Necessary for complex row vector handling below.) + data=data'; + end + txt=sprintf(dataformat,txt,padding0,'"_ArrayIsComplex_": ','1', sep); + end + txt=sprintf(dataformat,txt,padding0,'"_ArrayIsSparse_": ','1', sep); + if(size(item,1)==1) + % Row vector, store only column indices. + txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',... + matdata2json([iy(:),data'],level+2,varargin{:}), nl); + elseif(size(item,2)==1) + % Column vector, store only row indices. + txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',... + matdata2json([ix,data],level+2,varargin{:}), nl); + else + % General case, store row and column indices. + txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',... + matdata2json([ix,iy,data],level+2,varargin{:}), nl); + end +else + if(isreal(item)) + txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',... + matdata2json(item(:)',level+2,varargin{:}), nl); + else + txt=sprintf(dataformat,txt,padding0,'"_ArrayIsComplex_": ','1', sep); + txt=sprintf(dataformat,txt,padding0,'"_ArrayData_": ',... + matdata2json([real(item(:)) imag(item(:))],level+2,varargin{:}), nl); + end +end +txt=sprintf('%s%s%s',txt,padding1,'}'); + +%%------------------------------------------------------------------------- +function txt=matlabobject2json(name,item,level,varargin) +if numel(item) == 0 %empty object + st = struct(); +else + % "st = struct(item);" would produce an inmutable warning, because it + % make the protected and private properties visible. Instead we get the + % visible properties + propertynames = properties(item); + for p = 1:numel(propertynames) + for o = numel(item):-1:1 % aray of objects + st(o).(propertynames{p}) = item(o).(propertynames{p}); + end + end +end +txt=struct2json(name,st,level,varargin{:}); + +%%------------------------------------------------------------------------- +function txt=matdata2json(mat,level,varargin) + +ws=struct('tab',sprintf('\t'),'newline',sprintf('\n'),'sep',sprintf(',\n')); +ws=jsonopt('whitespaces_',ws,varargin{:}); +tab=ws.tab; +nl=ws.newline; + +if(size(mat,1)==1) + pre=''; + post=''; + level=level-1; +else + pre=sprintf('[%s',nl); + post=sprintf('%s%s]',nl,repmat(tab,1,level-1)); +end + +if(isempty(mat)) + txt='[]'; + return; +end +floatformat=jsonopt('FloatFormat','%.10g',varargin{:}); +%if(numel(mat)>1) + formatstr=['[' repmat([floatformat ','],1,size(mat,2)-1) [floatformat sprintf('],%s',nl)]]; +%else +% formatstr=[repmat([floatformat ','],1,size(mat,2)-1) [floatformat sprintf(',\n')]]; +%end + +if(nargin>=2 && size(mat,1)>1 && jsonopt('ArrayIndent',1,varargin{:})==1) + formatstr=[repmat(tab,1,level) formatstr]; +end + +txt=sprintf(formatstr,mat'); +txt(end-length(nl):end)=[]; +if(islogical(mat) && jsonopt('ParseLogical',0,varargin{:})==1) + txt=regexprep(txt,'1','true'); + txt=regexprep(txt,'0','false'); +end +%txt=regexprep(mat2str(mat),'\s+',','); +%txt=regexprep(txt,';',sprintf('],\n[')); +% if(nargin>=2 && size(mat,1)>1) +% txt=regexprep(txt,'\[',[repmat(sprintf('\t'),1,level) '[']); +% end +txt=[pre txt post]; +if(any(isinf(mat(:)))) + txt=regexprep(txt,'([-+]*)Inf',jsonopt('Inf','"$1_Inf_"',varargin{:})); +end +if(any(isnan(mat(:)))) + txt=regexprep(txt,'NaN',jsonopt('NaN','"_NaN_"',varargin{:})); +end + +%%------------------------------------------------------------------------- +function newname=checkname(name,varargin) +isunpack=jsonopt('UnpackHex',1,varargin{:}); +newname=name; +if(isempty(regexp(name,'0x([0-9a-fA-F]+)_','once'))) + return +end +if(isunpack) + isoct=jsonopt('IsOctave',0,varargin{:}); + if(~isoct) + newname=regexprep(name,'(^x|_){1}0x([0-9a-fA-F]+)_','${native2unicode(hex2dec($2))}'); + else + pos=regexp(name,'(^x|_){1}0x([0-9a-fA-F]+)_','start'); + pend=regexp(name,'(^x|_){1}0x([0-9a-fA-F]+)_','end'); + if(isempty(pos)) + return; + end + str0=name; + pos0=[0 pend(:)' length(name)]; + newname=''; + for i=1:length(pos) + newname=[newname str0(pos0(i)+1:pos(i)-1) char(hex2dec(str0(pos(i)+3:pend(i)-1)))]; + end + if(pos(end)~=length(name)) + newname=[newname str0(pos0(end-1)+1:pos0(end))]; + end + end +end + +%%------------------------------------------------------------------------- +function newstr=escapejsonstring(str) +newstr=str; +isoct=exist('OCTAVE_VERSION','builtin'); +if(isoct) + vv=sscanf(OCTAVE_VERSION,'%f'); + if(vv(1)>=3.8) + isoct=0; + end +end +if(isoct) + escapechars={'\\','\"','\/','\a','\f','\n','\r','\t','\v'}; + for i=1:length(escapechars); + newstr=regexprep(newstr,escapechars{i},escapechars{i}); + end + newstr=regexprep(newstr,'\\\\(u[0-9a-fA-F]{4}[^0-9a-fA-F]*)','\$1'); +else + escapechars={'\\','\"','\/','\a','\b','\f','\n','\r','\t','\v'}; + for i=1:length(escapechars); + newstr=regexprep(newstr,escapechars{i},regexprep(escapechars{i},'\\','\\\\')); + end + newstr=regexprep(newstr,'\\\\(u[0-9a-fA-F]{4}[^0-9a-fA-F]*)','\\$1'); +end diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/saveubjson.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/saveubjson.m new file mode 100644 index 0000000000000000000000000000000000000000..cfba94c0f1f39dac029369d9bbedf8ba3f948350 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/saveubjson.m @@ -0,0 +1,562 @@ +function json=saveubjson(rootname,obj,varargin) +% +% json=saveubjson(rootname,obj,filename) +% or +% json=saveubjson(rootname,obj,opt) +% json=saveubjson(rootname,obj,'param1',value1,'param2',value2,...) +% +% convert a MATLAB object (cell, struct or array) into a Universal +% Binary JSON (UBJSON) binary string +% +% author: Qianqian Fang (fangq nmr.mgh.harvard.edu) +% created on 2013/08/17 +% +% $Id$ +% +% input: +% rootname: the name of the root-object, when set to '', the root name +% is ignored, however, when opt.ForceRootName is set to 1 (see below), +% the MATLAB variable name will be used as the root name. +% obj: a MATLAB object (array, cell, cell array, struct, struct array, +% class instance) +% filename: a string for the file name to save the output UBJSON data +% opt: a struct for additional options, ignore to use default values. +% opt can have the following fields (first in [.|.] is the default) +% +% opt.FileName [''|string]: a file name to save the output JSON data +% opt.ArrayToStruct[0|1]: when set to 0, saveubjson outputs 1D/2D +% array in JSON array format; if sets to 1, an +% array will be shown as a struct with fields +% "_ArrayType_", "_ArraySize_" and "_ArrayData_"; for +% sparse arrays, the non-zero elements will be +% saved to _ArrayData_ field in triplet-format i.e. +% (ix,iy,val) and "_ArrayIsSparse_" will be added +% with a value of 1; for a complex array, the +% _ArrayData_ array will include two columns +% (4 for sparse) to record the real and imaginary +% parts, and also "_ArrayIsComplex_":1 is added. +% opt.ParseLogical [1|0]: if this is set to 1, logical array elem +% will use true/false rather than 1/0. +% opt.SingletArray [0|1]: if this is set to 1, arrays with a single +% numerical element will be shown without a square +% bracket, unless it is the root object; if 0, square +% brackets are forced for any numerical arrays. +% opt.SingletCell [1|0]: if 1, always enclose a cell with "[]" +% even it has only one element; if 0, brackets +% are ignored when a cell has only 1 element. +% opt.ForceRootName [0|1]: when set to 1 and rootname is empty, saveubjson +% will use the name of the passed obj variable as the +% root object name; if obj is an expression and +% does not have a name, 'root' will be used; if this +% is set to 0 and rootname is empty, the root level +% will be merged down to the lower level. +% opt.JSONP [''|string]: to generate a JSONP output (JSON with padding), +% for example, if opt.JSON='foo', the JSON data is +% wrapped inside a function call as 'foo(...);' +% opt.UnpackHex [1|0]: conver the 0x[hex code] output by loadjson +% back to the string form +% +% opt can be replaced by a list of ('param',value) pairs. The param +% string is equivallent to a field in opt and is case sensitive. +% output: +% json: a binary string in the UBJSON format (see http://ubjson.org) +% +% examples: +% jsonmesh=struct('MeshNode',[0 0 0;1 0 0;0 1 0;1 1 0;0 0 1;1 0 1;0 1 1;1 1 1],... +% 'MeshTetra',[1 2 4 8;1 3 4 8;1 2 6 8;1 5 6 8;1 5 7 8;1 3 7 8],... +% 'MeshTri',[1 2 4;1 2 6;1 3 4;1 3 7;1 5 6;1 5 7;... +% 2 8 4;2 8 6;3 8 4;3 8 7;5 8 6;5 8 7],... +% 'MeshCreator','FangQ','MeshTitle','T6 Cube',... +% 'SpecialData',[nan, inf, -inf]); +% saveubjson('jsonmesh',jsonmesh) +% saveubjson('jsonmesh',jsonmesh,'meshdata.ubj') +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of JSONLab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +if(nargin==1) + varname=inputname(1); + obj=rootname; + if(isempty(varname)) + varname='root'; + end + rootname=varname; +else + varname=inputname(2); +end +if(length(varargin)==1 && ischar(varargin{1})) + opt=struct('filename',varargin{1}); +else + opt=varargin2struct(varargin{:}); +end +opt.IsOctave=exist('OCTAVE_VERSION','builtin'); +if(isfield(opt,'norowbracket')) + warning('Option ''NoRowBracket'' is depreciated, please use ''SingletArray'' and set its value to not(NoRowBracket)'); + if(~isfield(opt,'singletarray')) + opt.singletarray=not(opt.norowbracket); + end +end +rootisarray=0; +rootlevel=1; +forceroot=jsonopt('ForceRootName',0,opt); +if((isnumeric(obj) || islogical(obj) || ischar(obj) || isstruct(obj) || ... + iscell(obj) || isobject(obj)) && isempty(rootname) && forceroot==0) + rootisarray=1; + rootlevel=0; +else + if(isempty(rootname)) + rootname=varname; + end +end +if((isstruct(obj) || iscell(obj))&& isempty(rootname) && forceroot) + rootname='root'; +end +json=obj2ubjson(rootname,obj,rootlevel,opt); +if(~rootisarray) + json=['{' json '}']; +end + +jsonp=jsonopt('JSONP','',opt); +if(~isempty(jsonp)) + json=[jsonp '(' json ')']; +end + +% save to a file if FileName is set, suggested by Patrick Rapin +filename=jsonopt('FileName','',opt); +if(~isempty(filename)) + fid = fopen(filename, 'wb'); + fwrite(fid,json); + fclose(fid); +end + +%%------------------------------------------------------------------------- +function txt=obj2ubjson(name,item,level,varargin) + +if(iscell(item)) + txt=cell2ubjson(name,item,level,varargin{:}); +elseif(isstruct(item)) + txt=struct2ubjson(name,item,level,varargin{:}); +elseif(ischar(item)) + txt=str2ubjson(name,item,level,varargin{:}); +elseif(isobject(item)) + txt=matlabobject2ubjson(name,item,level,varargin{:}); +else + txt=mat2ubjson(name,item,level,varargin{:}); +end + +%%------------------------------------------------------------------------- +function txt=cell2ubjson(name,item,level,varargin) +txt=''; +if(~iscell(item)) + error('input is not a cell'); +end + +dim=size(item); +if(ndims(squeeze(item))>2) % for 3D or higher dimensions, flatten to 2D for now + item=reshape(item,dim(1),numel(item)/dim(1)); + dim=size(item); +end +bracketlevel=~jsonopt('singletcell',1,varargin{:}); +len=numel(item); % let's handle 1D cell first +if(len>bracketlevel) + if(~isempty(name)) + txt=[N_(checkname(name,varargin{:})) '[']; name=''; + else + txt='['; + end +elseif(len==0) + if(~isempty(name)) + txt=[N_(checkname(name,varargin{:})) 'Z']; name=''; + else + txt='Z'; + end +end +for j=1:dim(2) + if(dim(1)>1) + txt=[txt '[']; + end + for i=1:dim(1) + txt=[txt obj2ubjson(name,item{i,j},level+(len>bracketlevel),varargin{:})]; + end + if(dim(1)>1) + txt=[txt ']']; + end +end +if(len>bracketlevel) + txt=[txt ']']; +end + +%%------------------------------------------------------------------------- +function txt=struct2ubjson(name,item,level,varargin) +txt=''; +if(~isstruct(item)) + error('input is not a struct'); +end +dim=size(item); +if(ndims(squeeze(item))>2) % for 3D or higher dimensions, flatten to 2D for now + item=reshape(item,dim(1),numel(item)/dim(1)); + dim=size(item); +end +len=numel(item); +forcearray= (len>1 || (jsonopt('SingletArray',0,varargin{:})==1 && level>0)); + +if(~isempty(name)) + if(forcearray) + txt=[N_(checkname(name,varargin{:})) '[']; + end +else + if(forcearray) + txt='['; + end +end +for j=1:dim(2) + if(dim(1)>1) + txt=[txt '[']; + end + for i=1:dim(1) + names = fieldnames(item(i,j)); + if(~isempty(name) && len==1 && ~forcearray) + txt=[txt N_(checkname(name,varargin{:})) '{']; + else + txt=[txt '{']; + end + if(~isempty(names)) + for e=1:length(names) + txt=[txt obj2ubjson(names{e},item(i,j).(names{e}),... + level+(dim(1)>1)+1+forcearray,varargin{:})]; + end + end + txt=[txt '}']; + end + if(dim(1)>1) + txt=[txt ']']; + end +end +if(forcearray) + txt=[txt ']']; +end + +%%------------------------------------------------------------------------- +function txt=str2ubjson(name,item,level,varargin) +txt=''; +if(~ischar(item)) + error('input is not a string'); +end +item=reshape(item, max(size(item),[1 0])); +len=size(item,1); + +if(~isempty(name)) + if(len>1) + txt=[N_(checkname(name,varargin{:})) '[']; + end +else + if(len>1) + txt='['; + end +end +for e=1:len + val=item(e,:); + if(len==1) + obj=[N_(checkname(name,varargin{:})) '' '',S_(val),'']; + if(isempty(name)) + obj=['',S_(val),'']; + end + txt=[txt,'',obj]; + else + txt=[txt,'',['',S_(val),'']]; + end +end +if(len>1) + txt=[txt ']']; +end + +%%------------------------------------------------------------------------- +function txt=mat2ubjson(name,item,level,varargin) +if(~isnumeric(item) && ~islogical(item)) + error('input is not an array'); +end + +if(length(size(item))>2 || issparse(item) || ~isreal(item) || ... + (isempty(item) && any(size(item))) ||jsonopt('ArrayToStruct',0,varargin{:})) + cid=I_(uint32(max(size(item)))); + if(isempty(name)) + txt=['{' N_('_ArrayType_'),S_(class(item)),N_('_ArraySize_'),I_a(size(item),cid(1)) ]; + else + if(isempty(item)) + txt=[N_(checkname(name,varargin{:})),'Z']; + return; + else + txt=[N_(checkname(name,varargin{:})),'{',N_('_ArrayType_'),S_(class(item)),N_('_ArraySize_'),I_a(size(item),cid(1))]; + end + end +else + if(isempty(name)) + txt=matdata2ubjson(item,level+1,varargin{:}); + else + if(numel(item)==1 && jsonopt('SingletArray',0,varargin{:})==0) + numtxt=regexprep(regexprep(matdata2ubjson(item,level+1,varargin{:}),'^\[',''),']',''); + txt=[N_(checkname(name,varargin{:})) numtxt]; + else + txt=[N_(checkname(name,varargin{:})),matdata2ubjson(item,level+1,varargin{:})]; + end + end + return; +end +if(issparse(item)) + [ix,iy]=find(item); + data=full(item(find(item))); + if(~isreal(item)) + data=[real(data(:)),imag(data(:))]; + if(size(item,1)==1) + % Kludge to have data's 'transposedness' match item's. + % (Necessary for complex row vector handling below.) + data=data'; + end + txt=[txt,N_('_ArrayIsComplex_'),'T']; + end + txt=[txt,N_('_ArrayIsSparse_'),'T']; + if(size(item,1)==1) + % Row vector, store only column indices. + txt=[txt,N_('_ArrayData_'),... + matdata2ubjson([iy(:),data'],level+2,varargin{:})]; + elseif(size(item,2)==1) + % Column vector, store only row indices. + txt=[txt,N_('_ArrayData_'),... + matdata2ubjson([ix,data],level+2,varargin{:})]; + else + % General case, store row and column indices. + txt=[txt,N_('_ArrayData_'),... + matdata2ubjson([ix,iy,data],level+2,varargin{:})]; + end +else + if(isreal(item)) + txt=[txt,N_('_ArrayData_'),... + matdata2ubjson(item(:)',level+2,varargin{:})]; + else + txt=[txt,N_('_ArrayIsComplex_'),'T']; + txt=[txt,N_('_ArrayData_'),... + matdata2ubjson([real(item(:)) imag(item(:))],level+2,varargin{:})]; + end +end +txt=[txt,'}']; + +%%------------------------------------------------------------------------- +function txt=matlabobject2ubjson(name,item,level,varargin) +if numel(item) == 0 %empty object + st = struct(); +else + % "st = struct(item);" would produce an inmutable warning, because it + % make the protected and private properties visible. Instead we get the + % visible properties + propertynames = properties(item); + for p = 1:numel(propertynames) + for o = numel(item):-1:1 % aray of objects + st(o).(propertynames{p}) = item(o).(propertynames{p}); + end + end +end +txt=struct2ubjson(name,st,level,varargin{:}); + +%%------------------------------------------------------------------------- +function txt=matdata2ubjson(mat,level,varargin) +if(isempty(mat)) + txt='Z'; + return; +end +type=''; +hasnegtive=(mat<0); +if(isa(mat,'integer') || isinteger(mat) || (isfloat(mat) && all(mod(mat(:),1) == 0))) + if(isempty(hasnegtive)) + if(max(mat(:))<=2^8) + type='U'; + end + end + if(isempty(type)) + % todo - need to consider negative ones separately + id= histc(abs(max(mat(:))),[0 2^7 2^15 2^31 2^63]); + if(isempty(id~=0)) + error('high-precision data is not yet supported'); + end + key='iIlL'; + type=key(id~=0); + end + txt=[I_a(mat(:),type,size(mat))]; +elseif(islogical(mat)) + logicalval='FT'; + if(numel(mat)==1) + txt=logicalval(mat+1); + else + txt=['[$U#' I_a(size(mat),'l') typecast(swapbytes(uint8(mat(:)')),'uint8')]; + end +else + if(numel(mat)==1) + txt=['[' D_(mat) ']']; + else + txt=D_a(mat(:),'D',size(mat)); + end +end + +%txt=regexprep(mat2str(mat),'\s+',','); +%txt=regexprep(txt,';',sprintf('],[')); +% if(nargin>=2 && size(mat,1)>1) +% txt=regexprep(txt,'\[',[repmat(sprintf('\t'),1,level) '[']); +% end +if(any(isinf(mat(:)))) + txt=regexprep(txt,'([-+]*)Inf',jsonopt('Inf','"$1_Inf_"',varargin{:})); +end +if(any(isnan(mat(:)))) + txt=regexprep(txt,'NaN',jsonopt('NaN','"_NaN_"',varargin{:})); +end + +%%------------------------------------------------------------------------- +function newname=checkname(name,varargin) +isunpack=jsonopt('UnpackHex',1,varargin{:}); +newname=name; +if(isempty(regexp(name,'0x([0-9a-fA-F]+)_','once'))) + return +end +if(isunpack) + isoct=jsonopt('IsOctave',0,varargin{:}); + if(~isoct) + newname=regexprep(name,'(^x|_){1}0x([0-9a-fA-F]+)_','${native2unicode(hex2dec($2))}'); + else + pos=regexp(name,'(^x|_){1}0x([0-9a-fA-F]+)_','start'); + pend=regexp(name,'(^x|_){1}0x([0-9a-fA-F]+)_','end'); + if(isempty(pos)) + return; + end + str0=name; + pos0=[0 pend(:)' length(name)]; + newname=''; + for i=1:length(pos) + newname=[newname str0(pos0(i)+1:pos(i)-1) char(hex2dec(str0(pos(i)+3:pend(i)-1)))]; + end + if(pos(end)~=length(name)) + newname=[newname str0(pos0(end-1)+1:pos0(end))]; + end + end +end +%%------------------------------------------------------------------------- +function val=N_(str) +val=[I_(int32(length(str))) str]; +%%------------------------------------------------------------------------- +function val=S_(str) +if(length(str)==1) + val=['C' str]; +else + val=['S' I_(int32(length(str))) str]; +end +%%------------------------------------------------------------------------- +function val=I_(num) +if(~isinteger(num)) + error('input is not an integer'); +end +if(num>=0 && num<255) + val=['U' data2byte(swapbytes(cast(num,'uint8')),'uint8')]; + return; +end +key='iIlL'; +cid={'int8','int16','int32','int64'}; +for i=1:4 + if((num>0 && num<2^(i*8-1)) || (num<0 && num>=-2^(i*8-1))) + val=[key(i) data2byte(swapbytes(cast(num,cid{i})),'uint8')]; + return; + end +end +error('unsupported integer'); + +%%------------------------------------------------------------------------- +function val=D_(num) +if(~isfloat(num)) + error('input is not a float'); +end + +if(isa(num,'single')) + val=['d' data2byte(num,'uint8')]; +else + val=['D' data2byte(num,'uint8')]; +end +%%------------------------------------------------------------------------- +function data=I_a(num,type,dim,format) +id=find(ismember('iUIlL',type)); + +if(id==0) + error('unsupported integer array'); +end + +% based on UBJSON specs, all integer types are stored in big endian format + +if(id==1) + data=data2byte(swapbytes(int8(num)),'uint8'); + blen=1; +elseif(id==2) + data=data2byte(swapbytes(uint8(num)),'uint8'); + blen=1; +elseif(id==3) + data=data2byte(swapbytes(int16(num)),'uint8'); + blen=2; +elseif(id==4) + data=data2byte(swapbytes(int32(num)),'uint8'); + blen=4; +elseif(id==5) + data=data2byte(swapbytes(int64(num)),'uint8'); + blen=8; +end + +if(nargin>=3 && length(dim)>=2 && prod(dim)~=dim(2)) + format='opt'; +end +if((nargin<4 || strcmp(format,'opt')) && numel(num)>1) + if(nargin>=3 && (length(dim)==1 || (length(dim)>=2 && prod(dim)~=dim(2)))) + cid=I_(uint32(max(dim))); + data=['$' type '#' I_a(dim,cid(1)) data(:)']; + else + data=['$' type '#' I_(int32(numel(data)/blen)) data(:)']; + end + data=['[' data(:)']; +else + data=reshape(data,blen,numel(data)/blen); + data(2:blen+1,:)=data; + data(1,:)=type; + data=data(:)'; + data=['[' data(:)' ']']; +end +%%------------------------------------------------------------------------- +function data=D_a(num,type,dim,format) +id=find(ismember('dD',type)); + +if(id==0) + error('unsupported float array'); +end + +if(id==1) + data=data2byte(single(num),'uint8'); +elseif(id==2) + data=data2byte(double(num),'uint8'); +end + +if(nargin>=3 && length(dim)>=2 && prod(dim)~=dim(2)) + format='opt'; +end +if((nargin<4 || strcmp(format,'opt')) && numel(num)>1) + if(nargin>=3 && (length(dim)==1 || (length(dim)>=2 && prod(dim)~=dim(2)))) + cid=I_(uint32(max(dim))); + data=['$' type '#' I_a(dim,cid(1)) data(:)']; + else + data=['$' type '#' I_(int32(numel(data)/(id*4))) data(:)']; + end + data=['[' data]; +else + data=reshape(data,(id*4),length(data)/(id*4)); + data(2:(id*4+1),:)=data; + data(1,:)=type; + data=data(:)'; + data=['[' data(:)' ']']; +end +%%------------------------------------------------------------------------- +function bytes=data2byte(varargin) +bytes=typecast(varargin{:}); +bytes=bytes(:)'; diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/struct2jdata.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/struct2jdata.m new file mode 100644 index 0000000000000000000000000000000000000000..6526390dec9d98ab466203041a90bbee6a903237 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/struct2jdata.m @@ -0,0 +1,96 @@ +function newdata=struct2jdata(data,varargin) +% +% newdata=struct2jdata(data,opt,...) +% +% convert a JData object (in the form of a struct array) into an array +% +% authors:Qianqian Fang (fangq nmr.mgh.harvard.edu) +% +% input: +% data: a struct array. If data contains JData keywords in the first +% level children, these fields are parsed and regrouped into a +% data object (arrays, trees, graphs etc) based on JData +% specification. The JData keywords are +% "_ArrayType_", "_ArraySize_", "_ArrayData_" +% "_ArrayIsSparse_", "_ArrayIsComplex_" +% opt: (optional) a list of 'Param',value pairs for additional options +% The supported options include +% 'Recursive', if set to 1, will apply the conversion to +% every child; 0 to disable +% +% output: +% newdata: the covnerted data if the input data does contain a JData +% structure; otherwise, the same as the input. +% +% examples: +% obj=struct('_ArrayType_','double','_ArraySize_',[2 3], +% '_ArrayIsSparse_',1 ,'_ArrayData_',null); +% ubjdata=struct2jdata(obj); +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of JSONLab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +fn=fieldnames(data); +newdata=data; +len=length(data); +if(jsonopt('Recursive',0,varargin{:})==1) + for i=1:length(fn) % depth-first + for j=1:len + if(isstruct(getfield(data(j),fn{i}))) + newdata(j)=setfield(newdata(j),fn{i},jstruct2array(getfield(data(j),fn{i}))); + end + end + end +end +if(~isempty(strmatch('x0x5F_ArrayType_',fn)) && ~isempty(strmatch('x0x5F_ArrayData_',fn))) + newdata=cell(len,1); + for j=1:len + ndata=cast(data(j).x0x5F_ArrayData_,data(j).x0x5F_ArrayType_); + iscpx=0; + if(~isempty(strmatch('x0x5F_ArrayIsComplex_',fn))) + if(data(j).x0x5F_ArrayIsComplex_) + iscpx=1; + end + end + if(~isempty(strmatch('x0x5F_ArrayIsSparse_',fn))) + if(data(j).x0x5F_ArrayIsSparse_) + if(~isempty(strmatch('x0x5F_ArraySize_',fn))) + dim=double(data(j).x0x5F_ArraySize_); + if(iscpx && size(ndata,2)==4-any(dim==1)) + ndata(:,end-1)=complex(ndata(:,end-1),ndata(:,end)); + end + if isempty(ndata) + % All-zeros sparse + ndata=sparse(dim(1),prod(dim(2:end))); + elseif dim(1)==1 + % Sparse row vector + ndata=sparse(1,ndata(:,1),ndata(:,2),dim(1),prod(dim(2:end))); + elseif dim(2)==1 + % Sparse column vector + ndata=sparse(ndata(:,1),1,ndata(:,2),dim(1),prod(dim(2:end))); + else + % Generic sparse array. + ndata=sparse(ndata(:,1),ndata(:,2),ndata(:,3),dim(1),prod(dim(2:end))); + end + else + if(iscpx && size(ndata,2)==4) + ndata(:,3)=complex(ndata(:,3),ndata(:,4)); + end + ndata=sparse(ndata(:,1),ndata(:,2),ndata(:,3)); + end + end + elseif(~isempty(strmatch('x0x5F_ArraySize_',fn))) + if(iscpx && size(ndata,2)==2) + ndata=complex(ndata(:,1),ndata(:,2)); + end + ndata=reshape(ndata(:),data(j).x0x5F_ArraySize_); + end + newdata{j}=ndata; + end + if(len==1) + newdata=newdata{1}; + end +end \ No newline at end of file diff --git a/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/varargin2struct.m b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/varargin2struct.m new file mode 100644 index 0000000000000000000000000000000000000000..675be650d9862c2b5d68206202a4801fe414ff7a --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/poseval/matlab/external/jsonlab/varargin2struct.m @@ -0,0 +1,40 @@ +function opt=varargin2struct(varargin) +% +% opt=varargin2struct('param1',value1,'param2',value2,...) +% or +% opt=varargin2struct(...,optstruct,...) +% +% convert a series of input parameters into a structure +% +% authors:Qianqian Fang (fangq nmr.mgh.harvard.edu) +% date: 2012/12/22 +% +% input: +% 'param', value: the input parameters should be pairs of a string and a value +% optstruct: if a parameter is a struct, the fields will be merged to the output struct +% +% output: +% opt: a struct where opt.param1=value1, opt.param2=value2 ... +% +% license: +% BSD License, see LICENSE_BSD.txt files for details +% +% -- this function is part of jsonlab toolbox (http://iso2mesh.sf.net/cgi-bin/index.cgi?jsonlab) +% + +len=length(varargin); +opt=struct; +if(len==0) return; end +i=1; +while(i<=len) + if(isstruct(varargin{i})) + opt=mergestruct(opt,varargin{i}); + elseif(ischar(varargin{i}) && i= 0 - np.finfo('float').eps).all() + assert (ious <= 1 + np.finfo('float').eps).all() + + return ious + + @staticmethod + def _calculate_box_ious(bboxes1, bboxes2, box_format='xywh', do_ioa=False): + """ Calculates the IOU (intersection over union) between two arrays of boxes. + Allows variable box formats ('xywh' and 'x0y0x1y1'). + If do_ioa (intersection over area) , then calculates the intersection over the area of boxes1 - this is commonly + used to determine if detections are within crowd ignore region. + """ + if box_format in 'xywh': + # layout: (x0, y0, w, h) + bboxes1 = deepcopy(bboxes1) + bboxes2 = deepcopy(bboxes2) + + bboxes1[:, 2] = bboxes1[:, 0] + bboxes1[:, 2] + bboxes1[:, 3] = bboxes1[:, 1] + bboxes1[:, 3] + bboxes2[:, 2] = bboxes2[:, 0] + bboxes2[:, 2] + bboxes2[:, 3] = bboxes2[:, 1] + bboxes2[:, 3] + elif box_format not in 'x0y0x1y1': + raise (TrackEvalException('box_format %s is not implemented' % box_format)) + + # layout: (x0, y0, x1, y1) + min_ = np.minimum(bboxes1[:, np.newaxis, :], bboxes2[np.newaxis, :, :]) + max_ = np.maximum(bboxes1[:, np.newaxis, :], bboxes2[np.newaxis, :, :]) + intersection = np.maximum(min_[..., 2] - max_[..., 0], 0) * np.maximum(min_[..., 3] - max_[..., 1], 0) + area1 = (bboxes1[..., 2] - bboxes1[..., 0]) * (bboxes1[..., 3] - bboxes1[..., 1]) + + if do_ioa: + ioas = np.zeros_like(intersection) + valid_mask = area1 > 0 + np.finfo('float').eps + ioas[valid_mask, :] = intersection[valid_mask, :] / area1[valid_mask][:, np.newaxis] + + return ioas + else: + area2 = (bboxes2[..., 2] - bboxes2[..., 0]) * (bboxes2[..., 3] - bboxes2[..., 1]) + union = area1[:, np.newaxis] + area2[np.newaxis, :] - intersection + intersection[area1 <= 0 + np.finfo('float').eps, :] = 0 + intersection[:, area2 <= 0 + np.finfo('float').eps] = 0 + intersection[union <= 0 + np.finfo('float').eps] = 0 + union[union <= 0 + np.finfo('float').eps] = 1 + ious = intersection / union + return ious + + @staticmethod + def _check_unique_ids(data, after_preproc=False): + """Check the requirement that the tracker_ids and gt_ids are unique per timestep""" + gt_ids = data['gt_ids'] + tracker_ids = data['tracker_ids'] + for t, (gt_ids_t, tracker_ids_t) in enumerate(zip(gt_ids, tracker_ids)): + if len(tracker_ids_t) > 0: + unique_ids, counts = np.unique(tracker_ids_t, return_counts=True) + if np.max(counts) != 1: + duplicate_ids = unique_ids[counts > 1] + exc_str_init = 'Tracker predicts the same ID more than once in a single timestep ' \ + '(seq: %s, frame: %i, ids:' % (data['seq'], t+1) + exc_str = ' '.join([exc_str_init] + [str(d) for d in duplicate_ids]) + ')' + if after_preproc: + exc_str_init += '\n Note that this error occurred after preprocessing (but not before), ' \ + 'so ids may not be as in file, and something seems wrong with preproc.' + raise TrackEvalException(exc_str) + if len(gt_ids_t) > 0: + unique_ids, counts = np.unique(gt_ids_t, return_counts=True) + if np.max(counts) != 1: + duplicate_ids = unique_ids[counts > 1] + exc_str_init = 'Ground-truth has the same ID more than once in a single timestep ' \ + '(seq: %s, frame: %i, ids:' % (data['seq'], t+1) + exc_str = ' '.join([exc_str_init] + [str(d) for d in duplicate_ids]) + ')' + if after_preproc: + exc_str_init += '\n Note that this error occurred after preprocessing (but not before), ' \ + 'so ids may not be as in file, and something seems wrong with preproc.' + raise TrackEvalException(exc_str) diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/bdd100k.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/bdd100k.py new file mode 100644 index 0000000000000000000000000000000000000000..cc4fd06ee49e520e9a8887239532816074aea41f --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/bdd100k.py @@ -0,0 +1,302 @@ + +import os +import json +import numpy as np +from scipy.optimize import linear_sum_assignment +from ..utils import TrackEvalException +from ._base_dataset import _BaseDataset +from .. import utils +from .. import _timing + + +class BDD100K(_BaseDataset): + """Dataset class for BDD100K tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/bdd100k/bdd100k_val'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/bdd100k/bdd100k_val'), # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'CLASSES_TO_EVAL': ['pedestrian', 'rider', 'car', 'bus', 'truck', 'train', 'motorcycle', 'bicycle'], + # Valid: ['pedestrian', 'rider', 'car', 'bus', 'truck', 'train', 'motorcycle', 'bicycle'] + 'SPLIT_TO_EVAL': 'val', # Valid: 'training', 'val', + 'INPUT_AS_ZIP': False, # Whether tracker input files are zipped + 'PRINT_CONFIG': True, # Whether to print current config + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + self.gt_fol = self.config['GT_FOLDER'] + self.tracker_fol = self.config['TRACKERS_FOLDER'] + self.should_classes_combine = True + self.use_super_categories = True + + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.tracker_fol + + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + + # Get classes to eval + self.valid_classes = ['pedestrian', 'rider', 'car', 'bus', 'truck', 'train', 'motorcycle', 'bicycle'] + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. Only classes [pedestrian, rider, car, ' + 'bus, truck, train, motorcycle, bicycle] are valid.') + self.super_categories = {"HUMAN": [cls for cls in ["pedestrian", "rider"] if cls in self.class_list], + "VEHICLE": [cls for cls in ["car", "truck", "bus", "train"] if cls in self.class_list], + "BIKE": [cls for cls in ["motorcycle", "bicycle"] if cls in self.class_list]} + self.distractor_classes = ['other person', 'trailer', 'other vehicle'] + self.class_name_to_class_id = {'pedestrian': 1, 'rider': 2, 'other person': 3, 'car': 4, 'bus': 5, 'truck': 6, + 'train': 7, 'trailer': 8, 'other vehicle': 9, 'motorcycle': 10, 'bicycle': 11} + + # Get sequences to eval + self.seq_list = [] + self.seq_lengths = {} + + self.seq_list = [seq_file.replace('.json', '') for seq_file in os.listdir(self.gt_fol)] + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + for tracker in self.tracker_list: + for seq in self.seq_list: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.json') + if not os.path.isfile(curr_file): + print('Tracker file not found: ' + curr_file) + raise TrackEvalException( + 'Tracker file not found: ' + tracker + '/' + self.tracker_sub_fol + '/' + os.path.basename( + curr_file)) + + def get_display_name(self, tracker): + return self.tracker_to_disp[tracker] + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the BDD100K format + + If is_gt, this returns a dict which contains the fields: + [gt_ids, gt_classes] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, gt_crowd_ignore_regions]: list (for each timestep) of lists of detections. + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids, tracker_classes, tracker_confidences] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + """ + # File location + if is_gt: + file = os.path.join(self.gt_fol, seq + '.json') + else: + file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.json') + + with open(file) as f: + data = json.load(f) + + # sort data by frame index + data = sorted(data, key=lambda x: x['index']) + + # check sequence length + if is_gt: + self.seq_lengths[seq] = len(data) + num_timesteps = len(data) + else: + num_timesteps = self.seq_lengths[seq] + if num_timesteps != len(data): + raise TrackEvalException('Number of ground truth and tracker timesteps do not match for sequence %s' + % seq) + + # Convert data to required format + data_keys = ['ids', 'classes', 'dets'] + if is_gt: + data_keys += ['gt_crowd_ignore_regions'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + for t in range(num_timesteps): + ig_ids = [] + keep_ids = [] + for i in range(len(data[t]['labels'])): + ann = data[t]['labels'][i] + if is_gt and (ann['category'] in self.distractor_classes or 'attributes' in ann.keys() + and ann['attributes']['Crowd']): + ig_ids.append(i) + else: + keep_ids.append(i) + + if keep_ids: + raw_data['dets'][t] = np.atleast_2d([[data[t]['labels'][i]['box2d']['x1'], + data[t]['labels'][i]['box2d']['y1'], + data[t]['labels'][i]['box2d']['x2'], + data[t]['labels'][i]['box2d']['y2'] + ] for i in keep_ids]).astype(float) + raw_data['ids'][t] = np.atleast_1d([data[t]['labels'][i]['id'] for i in keep_ids]).astype(int) + raw_data['classes'][t] = np.atleast_1d([self.class_name_to_class_id[data[t]['labels'][i]['category']] + for i in keep_ids]).astype(int) + else: + raw_data['dets'][t] = np.empty((0, 4)).astype(float) + raw_data['ids'][t] = np.empty(0).astype(int) + raw_data['classes'][t] = np.empty(0).astype(int) + + if is_gt: + if ig_ids: + raw_data['gt_crowd_ignore_regions'][t] = np.atleast_2d([[data[t]['labels'][i]['box2d']['x1'], + data[t]['labels'][i]['box2d']['y1'], + data[t]['labels'][i]['box2d']['x2'], + data[t]['labels'][i]['box2d']['y2'] + ] for i in ig_ids]).astype(float) + else: + raw_data['gt_crowd_ignore_regions'][t] = np.empty((0, 4)).astype(float) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'classes': 'gt_classes', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'classes': 'tracker_classes', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + raw_data['num_timesteps'] = num_timesteps + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids, tracker_confidences]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detections. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + + BDD100K: + In BDD100K, the 4 preproc steps are as follow: + 1) There are eight classes (pedestrian, rider, car, bus, truck, train, motorcycle, bicycle) + which are evaluated separately. + 2) For BDD100K there is no removal of matched tracker dets. + 3) Crowd ignore regions are used to remove unmatched detections. + 4) No removal of gt dets. + """ + cls_id = self.class_name_to_class_id[cls] + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + unique_gt_ids = [] + unique_tracker_ids = [] + num_gt_dets = 0 + num_tracker_dets = 0 + for t in range(raw_data['num_timesteps']): + + # Only extract relevant dets for this class for preproc and eval (cls) + gt_class_mask = np.atleast_1d(raw_data['gt_classes'][t] == cls_id) + gt_class_mask = gt_class_mask.astype(np.bool) + gt_ids = raw_data['gt_ids'][t][gt_class_mask] + gt_dets = raw_data['gt_dets'][t][gt_class_mask] + + tracker_class_mask = np.atleast_1d(raw_data['tracker_classes'][t] == cls_id) + tracker_class_mask = tracker_class_mask.astype(np.bool) + tracker_ids = raw_data['tracker_ids'][t][tracker_class_mask] + tracker_dets = raw_data['tracker_dets'][t][tracker_class_mask] + similarity_scores = raw_data['similarity_scores'][t][gt_class_mask, :][:, tracker_class_mask] + + # Match tracker and gt dets (with hungarian algorithm) + unmatched_indices = np.arange(tracker_ids.shape[0]) + if gt_ids.shape[0] > 0 and tracker_ids.shape[0] > 0: + matching_scores = similarity_scores.copy() + matching_scores[matching_scores < 0.5 - np.finfo('float').eps] = 0 + match_rows, match_cols = linear_sum_assignment(-matching_scores) + actually_matched_mask = matching_scores[match_rows, match_cols] > 0 + np.finfo('float').eps + match_cols = match_cols[actually_matched_mask] + unmatched_indices = np.delete(unmatched_indices, match_cols, axis=0) + + # For unmatched tracker dets, remove those that are greater than 50% within a crowd ignore region. + unmatched_tracker_dets = tracker_dets[unmatched_indices, :] + crowd_ignore_regions = raw_data['gt_crowd_ignore_regions'][t] + intersection_with_ignore_region = self._calculate_box_ious(unmatched_tracker_dets, crowd_ignore_regions, + box_format='x0y0x1y1', do_ioa=True) + is_within_crowd_ignore_region = np.any(intersection_with_ignore_region > 0.5 + np.finfo('float').eps, + axis=1) + + # Apply preprocessing to remove unwanted tracker dets. + to_remove_tracker = unmatched_indices[is_within_crowd_ignore_region] + data['tracker_ids'][t] = np.delete(tracker_ids, to_remove_tracker, axis=0) + data['tracker_dets'][t] = np.delete(tracker_dets, to_remove_tracker, axis=0) + similarity_scores = np.delete(similarity_scores, to_remove_tracker, axis=1) + + data['gt_ids'][t] = gt_ids + data['gt_dets'][t] = gt_dets + data['similarity_scores'][t] = similarity_scores + + unique_gt_ids += list(np.unique(data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(data['tracker_ids'][t])) + num_tracker_dets += len(data['tracker_ids'][t]) + num_gt_dets += len(data['gt_ids'][t]) + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = len(unique_tracker_ids) + data['num_gt_ids'] = len(unique_gt_ids) + data['num_timesteps'] = raw_data['num_timesteps'] + + # Ensure that ids are unique per timestep. + self._check_unique_ids(data) + + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_box_ious(gt_dets_t, tracker_dets_t, box_format='x0y0x1y1') + return similarity_scores diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/davis.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/davis.py new file mode 100644 index 0000000000000000000000000000000000000000..9db25e933b0c4951f2ea70c5c4d806fb6b08ccd5 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/davis.py @@ -0,0 +1,276 @@ +import os +import csv +import numpy as np +from ._base_dataset import _BaseDataset +from ..utils import TrackEvalException +from .. import utils +from .. import _timing + + +class DAVIS(_BaseDataset): + """Dataset class for DAVIS tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/davis/davis_unsupervised_val/'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/davis/davis_unsupervised_val/'), # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'SPLIT_TO_EVAL': 'val', # Valid: 'val', 'train' + 'CLASSES_TO_EVAL': ['general'], + 'PRINT_CONFIG': True, # Whether to print current config + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + 'SEQMAP_FILE': None, # Specify seqmap file + 'SEQ_INFO': None, # If not None, directly specify sequences to eval and their number of timesteps + # '{gt_folder}/Annotations_unsupervised/480p/{seq}' + 'MAX_DETECTIONS': 0 # Maximum number of allowed detections per sequence (0 for no threshold) + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + # defining a default class since there are no classes in DAVIS + self.should_classes_combine = False + self.use_super_categories = False + + self.gt_fol = self.config['GT_FOLDER'] + self.tracker_fol = self.config['TRACKERS_FOLDER'] + + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.config['TRACKERS_FOLDER'] + + self.max_det = self.config['MAX_DETECTIONS'] + + # Get classes to eval + self.valid_classes = ['general'] + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. Only general class is valid.') + + # Get sequences to eval + if self.config["SEQ_INFO"]: + self.seq_list = list(self.config["SEQ_INFO"].keys()) + self.seq_lengths = self.config["SEQ_INFO"] + elif self.config["SEQMAP_FILE"]: + self.seq_list = [] + seqmap_file = self.config["SEQMAP_FILE"] + if not os.path.isfile(seqmap_file): + raise TrackEvalException('no seqmap found: ' + os.path.basename(seqmap_file)) + with open(seqmap_file) as fp: + reader = csv.reader(fp) + for i, row in enumerate(reader): + if row[0] == '': + continue + seq = row[0] + self.seq_list.append(seq) + else: + self.seq_list = os.listdir(self.gt_fol) + + self.seq_lengths = {seq: len(os.listdir(os.path.join(self.gt_fol, seq))) for seq in self.seq_list} + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + for tracker in self.tracker_list: + for seq in self.seq_list: + curr_dir = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq) + if not os.path.isdir(curr_dir): + print('Tracker directory not found: ' + curr_dir) + raise TrackEvalException('Tracker directory not found: ' + + os.path.join(tracker, self.tracker_sub_fol, seq)) + tr_timesteps = len(os.listdir(curr_dir)) + if self.seq_lengths[seq] != tr_timesteps: + raise TrackEvalException('GT folder and tracker folder have a different number' + 'timesteps for tracker %s and sequence %s' % (tracker, seq)) + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the DAVIS format + + If is_gt, this returns a dict which contains the fields: + [gt_ids] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets]: list (for each timestep) of lists of detections. + [masks_void]: list of masks with void pixels (pixels to be ignored during evaluation) + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + """ + + # Only loaded when run to reduce minimum requirements + from pycocotools import mask as mask_utils + from PIL import Image + + # File location + if is_gt: + seq_dir = os.path.join(self.gt_fol, seq) + else: + seq_dir = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq) + + num_timesteps = self.seq_lengths[seq] + data_keys = ['ids', 'dets', 'masks_void'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + + # read frames + frames = [os.path.join(seq_dir, im_name) for im_name in sorted(os.listdir(seq_dir))] + + id_list = [] + for t in range(num_timesteps): + frame = np.array(Image.open(frames[t])) + if is_gt: + void = frame == 255 + frame[void] = 0 + raw_data['masks_void'][t] = mask_utils.encode(np.asfortranarray(void.astype(np.uint8))) + id_values = np.unique(frame) + id_values = id_values[id_values != 0] + id_list += list(id_values) + tmp = np.ones((len(id_values), *frame.shape)) + tmp = tmp * id_values[:, None, None] + masks = np.array(tmp == frame[None, ...]).astype(np.uint8) + raw_data['dets'][t] = mask_utils.encode(np.array(np.transpose(masks, (1, 2, 0)), order='F')) + raw_data['ids'][t] = id_values.astype(int) + num_objects = len(np.unique(id_list)) + + if not is_gt and num_objects > self.max_det > 0: + raise Exception('Number of proposals (%i) for sequence %s exceeds number of maximum allowed proposals (%i).' + % (num_objects, seq, self.max_det)) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + raw_data["num_timesteps"] = num_timesteps + raw_data['mask_shape'] = np.array(Image.open(frames[0])).shape + if is_gt: + raw_data['num_gt_ids'] = num_objects + else: + raw_data['num_tracker_ids'] = num_objects + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detection masks. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + + DAVIS: + In DAVIS, the 4 preproc steps are as follow: + 1) There are no classes, all detections are evaluated jointly + 2) No matched tracker detections are removed. + 3) No unmatched tracker detections are removed. + 4) There are no ground truth detections (e.g. those of distractor classes) to be removed. + Preprocessing special to DAVIS: Pixels which are marked as void in the ground truth are set to zero in the + tracker detections since they are not considered during evaluation. + """ + + # Only loaded when run to reduce minimum requirements + from pycocotools import mask as mask_utils + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + num_gt_dets = 0 + num_tracker_dets = 0 + unique_gt_ids = [] + unique_tracker_ids = [] + num_timesteps = raw_data['num_timesteps'] + + # count detections + for t in range(num_timesteps): + num_gt_dets += len(raw_data['gt_dets'][t]) + num_tracker_dets += len(raw_data['tracker_dets'][t]) + unique_gt_ids += list(np.unique(raw_data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(raw_data['tracker_ids'][t])) + + data['gt_ids'] = raw_data['gt_ids'] + data['gt_dets'] = raw_data['gt_dets'] + data['similarity_scores'] = raw_data['similarity_scores'] + data['tracker_ids'] = raw_data['tracker_ids'] + + # set void pixels in tracker detections to zero + for t in range(num_timesteps): + void_mask = raw_data['masks_void'][t] + if mask_utils.area(void_mask) > 0: + void_mask_ious = np.atleast_1d(mask_utils.iou(raw_data['tracker_dets'][t], [void_mask], [False])) + if void_mask_ious.any(): + rows, columns = np.where(void_mask_ious > 0) + for r in rows: + det = mask_utils.decode(raw_data['tracker_dets'][t][r]) + void = mask_utils.decode(void_mask).astype(np.bool) + det[void] = 0 + det = mask_utils.encode(np.array(det, order='F').astype(np.uint8)) + raw_data['tracker_dets'][t][r] = det + data['tracker_dets'] = raw_data['tracker_dets'] + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = raw_data['num_tracker_ids'] + data['num_gt_ids'] = raw_data['num_gt_ids'] + data['mask_shape'] = raw_data['mask_shape'] + data['num_timesteps'] = num_timesteps + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_mask_ious(gt_dets_t, tracker_dets_t, is_encoded=True, do_ioa=False) + return similarity_scores diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/kitti_2d_box.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/kitti_2d_box.py new file mode 100644 index 0000000000000000000000000000000000000000..4be16ba703b85266cd93f4827ec783f92121703b --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/kitti_2d_box.py @@ -0,0 +1,388 @@ + +import os +import csv +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_dataset import _BaseDataset +from .. import utils +from ..utils import TrackEvalException +from .. import _timing + + +class Kitti2DBox(_BaseDataset): + """Dataset class for KITTI 2D bounding box tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/kitti/kitti_2d_box_train'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/kitti/kitti_2d_box_train/'), # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'CLASSES_TO_EVAL': ['car', 'pedestrian'], # Valid: ['car', 'pedestrian'] + 'SPLIT_TO_EVAL': 'training', # Valid: 'training', 'val', 'training_minus_val', 'test' + 'INPUT_AS_ZIP': False, # Whether tracker input files are zipped + 'PRINT_CONFIG': True, # Whether to print current config + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + self.gt_fol = self.config['GT_FOLDER'] + self.tracker_fol = self.config['TRACKERS_FOLDER'] + self.should_classes_combine = False + self.use_super_categories = False + self.data_is_zipped = self.config['INPUT_AS_ZIP'] + + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.tracker_fol + + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + + self.max_occlusion = 2 + self.max_truncation = 0 + self.min_height = 25 + + # Get classes to eval + self.valid_classes = ['car', 'pedestrian'] + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. Only classes [car, pedestrian] are valid.') + self.class_name_to_class_id = {'car': 1, 'van': 2, 'truck': 3, 'pedestrian': 4, 'person': 5, # person sitting + 'cyclist': 6, 'tram': 7, 'misc': 8, 'dontcare': 9, 'car_2': 1} + + # Get sequences to eval and check gt files exist + self.seq_list = [] + self.seq_lengths = {} + seqmap_name = 'evaluate_tracking.seqmap.' + self.config['SPLIT_TO_EVAL'] + seqmap_file = os.path.join(self.gt_fol, seqmap_name) + if not os.path.isfile(seqmap_file): + raise TrackEvalException('no seqmap found: ' + os.path.basename(seqmap_file)) + with open(seqmap_file) as fp: + dialect = csv.Sniffer().sniff(fp.read(1024)) + fp.seek(0) + reader = csv.reader(fp, dialect) + for row in reader: + if len(row) >= 4: + seq = row[0] + self.seq_list.append(seq) + self.seq_lengths[seq] = int(row[3]) + if not self.data_is_zipped: + curr_file = os.path.join(self.gt_fol, 'label_02', seq + '.txt') + if not os.path.isfile(curr_file): + raise TrackEvalException('GT file not found: ' + os.path.basename(curr_file)) + if self.data_is_zipped: + curr_file = os.path.join(self.gt_fol, 'data.zip') + if not os.path.isfile(curr_file): + raise TrackEvalException('GT file not found: ' + os.path.basename(curr_file)) + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + for tracker in self.tracker_list: + if self.data_is_zipped: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + if not os.path.isfile(curr_file): + raise TrackEvalException('Tracker file not found: ' + tracker + '/' + os.path.basename(curr_file)) + else: + for seq in self.seq_list: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + if not os.path.isfile(curr_file): + raise TrackEvalException( + 'Tracker file not found: ' + tracker + '/' + self.tracker_sub_fol + '/' + os.path.basename( + curr_file)) + + def get_display_name(self, tracker): + return self.tracker_to_disp[tracker] + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the kitti 2D box format + + If is_gt, this returns a dict which contains the fields: + [gt_ids, gt_classes] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, gt_crowd_ignore_regions]: list (for each timestep) of lists of detections. + [gt_extras] : list (for each timestep) of dicts (for each extra) of 1D NDArrays (for each det). + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids, tracker_classes, tracker_confidences] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + """ + # File location + if self.data_is_zipped: + if is_gt: + zip_file = os.path.join(self.gt_fol, 'data.zip') + else: + zip_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + file = seq + '.txt' + else: + zip_file = None + if is_gt: + file = os.path.join(self.gt_fol, 'label_02', seq + '.txt') + else: + file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + + # Ignore regions + if is_gt: + crowd_ignore_filter = {2: ['dontcare']} + else: + crowd_ignore_filter = None + + # Valid classes + valid_filter = {2: [x for x in self.class_list]} + if is_gt: + if 'car' in self.class_list: + valid_filter[2].append('van') + if 'pedestrian' in self.class_list: + valid_filter[2] += ['person'] + + # Convert kitti class strings to class ids + convert_filter = {2: self.class_name_to_class_id} + + # Load raw data from text file + read_data, ignore_data = self._load_simple_text_file(file, time_col=0, id_col=1, remove_negative_ids=True, + valid_filter=valid_filter, + crowd_ignore_filter=crowd_ignore_filter, + convert_filter=convert_filter, + is_zipped=self.data_is_zipped, zip_file=zip_file) + # Convert data to required format + num_timesteps = self.seq_lengths[seq] + data_keys = ['ids', 'classes', 'dets'] + if is_gt: + data_keys += ['gt_crowd_ignore_regions', 'gt_extras'] + else: + data_keys += ['tracker_confidences'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + + # Check for any extra time keys + extra_time_keys = [x for x in read_data.keys() if x not in [str(t) for t in range(num_timesteps)]] + if len(extra_time_keys) > 0: + if is_gt: + text = 'Ground-truth' + else: + text = 'Tracking' + raise TrackEvalException( + text + ' data contains the following invalid timesteps in seq %s: ' % seq + ', '.join( + [str(x) + ', ' for x in extra_time_keys])) + + for t in range(num_timesteps): + time_key = str(t) + if time_key in read_data.keys(): + time_data = np.asarray(read_data[time_key], dtype=np.float) + raw_data['dets'][t] = np.atleast_2d(time_data[:, 6:10]) + raw_data['ids'][t] = np.atleast_1d(time_data[:, 1]).astype(int) + raw_data['classes'][t] = np.atleast_1d(time_data[:, 2]).astype(int) + if is_gt: + gt_extras_dict = {'truncation': np.atleast_1d(time_data[:, 3].astype(int)), + 'occlusion': np.atleast_1d(time_data[:, 4].astype(int))} + raw_data['gt_extras'][t] = gt_extras_dict + else: + if time_data.shape[1] > 17: + raw_data['tracker_confidences'][t] = np.atleast_1d(time_data[:, 17]) + else: + raw_data['tracker_confidences'][t] = np.ones(time_data.shape[0]) + else: + raw_data['dets'][t] = np.empty((0, 4)) + raw_data['ids'][t] = np.empty(0).astype(int) + raw_data['classes'][t] = np.empty(0).astype(int) + if is_gt: + gt_extras_dict = {'truncation': np.empty(0), + 'occlusion': np.empty(0)} + raw_data['gt_extras'][t] = gt_extras_dict + else: + raw_data['tracker_confidences'][t] = np.empty(0) + if is_gt: + if time_key in ignore_data.keys(): + time_ignore = np.asarray(ignore_data[time_key], dtype=np.float) + raw_data['gt_crowd_ignore_regions'][t] = np.atleast_2d(time_ignore[:, 6:10]) + else: + raw_data['gt_crowd_ignore_regions'][t] = np.empty((0, 4)) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'classes': 'gt_classes', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'classes': 'tracker_classes', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + raw_data['num_timesteps'] = num_timesteps + raw_data['seq'] = seq + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids, tracker_confidences]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detections. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + + KITTI: + In KITTI, the 4 preproc steps are as follow: + 1) There are two classes (pedestrian and car) which are evaluated separately. + 2) For the pedestrian class, the 'person' class is distractor objects (people sitting). + For the car class, the 'van' class are distractor objects. + GT boxes marked as having occlusion level > 2 or truncation level > 0 are also treated as + distractors. + 3) Crowd ignore regions are used to remove unmatched detections. Also unmatched detections with + height <= 25 pixels are removed. + 4) Distractor gt dets (including truncated and occluded) are removed. + """ + if cls == 'pedestrian': + distractor_classes = [self.class_name_to_class_id['person']] + elif cls == 'car': + distractor_classes = [self.class_name_to_class_id['van']] + else: + raise (TrackEvalException('Class %s is not evaluatable' % cls)) + cls_id = self.class_name_to_class_id[cls] + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'tracker_confidences', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + unique_gt_ids = [] + unique_tracker_ids = [] + num_gt_dets = 0 + num_tracker_dets = 0 + for t in range(raw_data['num_timesteps']): + + # Only extract relevant dets for this class for preproc and eval (cls + distractor classes) + gt_class_mask = np.sum([raw_data['gt_classes'][t] == c for c in [cls_id] + distractor_classes], axis=0) + gt_class_mask = gt_class_mask.astype(np.bool) + gt_ids = raw_data['gt_ids'][t][gt_class_mask] + gt_dets = raw_data['gt_dets'][t][gt_class_mask] + gt_classes = raw_data['gt_classes'][t][gt_class_mask] + gt_occlusion = raw_data['gt_extras'][t]['occlusion'][gt_class_mask] + gt_truncation = raw_data['gt_extras'][t]['truncation'][gt_class_mask] + + tracker_class_mask = np.atleast_1d(raw_data['tracker_classes'][t] == cls_id) + tracker_class_mask = tracker_class_mask.astype(np.bool) + tracker_ids = raw_data['tracker_ids'][t][tracker_class_mask] + tracker_dets = raw_data['tracker_dets'][t][tracker_class_mask] + tracker_confidences = raw_data['tracker_confidences'][t][tracker_class_mask] + similarity_scores = raw_data['similarity_scores'][t][gt_class_mask, :][:, tracker_class_mask] + + # Match tracker and gt dets (with hungarian algorithm) and remove tracker dets which match with gt dets + # which are labeled as truncated, occluded, or belonging to a distractor class. + to_remove_matched = np.array([], np.int) + unmatched_indices = np.arange(tracker_ids.shape[0]) + if gt_ids.shape[0] > 0 and tracker_ids.shape[0] > 0: + matching_scores = similarity_scores.copy() + matching_scores[matching_scores < 0.5 - np.finfo('float').eps] = 0 + match_rows, match_cols = linear_sum_assignment(-matching_scores) + actually_matched_mask = matching_scores[match_rows, match_cols] > 0 + np.finfo('float').eps + match_rows = match_rows[actually_matched_mask] + match_cols = match_cols[actually_matched_mask] + + is_distractor_class = np.isin(gt_classes[match_rows], distractor_classes) + is_occluded_or_truncated = np.logical_or( + gt_occlusion[match_rows] > self.max_occlusion + np.finfo('float').eps, + gt_truncation[match_rows] > self.max_truncation + np.finfo('float').eps) + to_remove_matched = np.logical_or(is_distractor_class, is_occluded_or_truncated) + to_remove_matched = match_cols[to_remove_matched] + unmatched_indices = np.delete(unmatched_indices, match_cols, axis=0) + + # For unmatched tracker dets, also remove those smaller than a minimum height. + unmatched_tracker_dets = tracker_dets[unmatched_indices, :] + unmatched_heights = unmatched_tracker_dets[:, 3] - unmatched_tracker_dets[:, 1] + is_too_small = unmatched_heights <= self.min_height + np.finfo('float').eps + + # For unmatched tracker dets, also remove those that are greater than 50% within a crowd ignore region. + crowd_ignore_regions = raw_data['gt_crowd_ignore_regions'][t] + intersection_with_ignore_region = self._calculate_box_ious(unmatched_tracker_dets, crowd_ignore_regions, + box_format='x0y0x1y1', do_ioa=True) + is_within_crowd_ignore_region = np.any(intersection_with_ignore_region > 0.5 + np.finfo('float').eps, axis=1) + + # Apply preprocessing to remove all unwanted tracker dets. + to_remove_unmatched = unmatched_indices[np.logical_or(is_too_small, is_within_crowd_ignore_region)] + to_remove_tracker = np.concatenate((to_remove_matched, to_remove_unmatched), axis=0) + data['tracker_ids'][t] = np.delete(tracker_ids, to_remove_tracker, axis=0) + data['tracker_dets'][t] = np.delete(tracker_dets, to_remove_tracker, axis=0) + data['tracker_confidences'][t] = np.delete(tracker_confidences, to_remove_tracker, axis=0) + similarity_scores = np.delete(similarity_scores, to_remove_tracker, axis=1) + + # Also remove gt dets that were only useful for preprocessing and are not needed for evaluation. + # These are those that are occluded, truncated and from distractor objects. + gt_to_keep_mask = (np.less_equal(gt_occlusion, self.max_occlusion)) & \ + (np.less_equal(gt_truncation, self.max_truncation)) & \ + (np.equal(gt_classes, cls_id)) + data['gt_ids'][t] = gt_ids[gt_to_keep_mask] + data['gt_dets'][t] = gt_dets[gt_to_keep_mask, :] + data['similarity_scores'][t] = similarity_scores[gt_to_keep_mask] + + unique_gt_ids += list(np.unique(data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(data['tracker_ids'][t])) + num_tracker_dets += len(data['tracker_ids'][t]) + num_gt_dets += len(data['gt_ids'][t]) + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = len(unique_tracker_ids) + data['num_gt_ids'] = len(unique_gt_ids) + data['num_timesteps'] = raw_data['num_timesteps'] + data['seq'] = raw_data['seq'] + + # Ensure that ids are unique per timestep. + self._check_unique_ids(data) + + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_box_ious(gt_dets_t, tracker_dets_t, box_format='x0y0x1y1') + return similarity_scores diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/kitti_mots.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/kitti_mots.py new file mode 100644 index 0000000000000000000000000000000000000000..6d966813c1d926efa0ba9185f8db70e17ff2d2eb --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/kitti_mots.py @@ -0,0 +1,425 @@ +import os +import csv +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_dataset import _BaseDataset +from .. import utils +from .. import _timing +from ..utils import TrackEvalException + + +class KittiMOTS(_BaseDataset): + """Dataset class for KITTI MOTS tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/kitti/kitti_mots_val'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/kitti/kitti_mots_val'), # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'CLASSES_TO_EVAL': ['car', 'pedestrian'], # Valid: ['car', 'pedestrian'] + 'SPLIT_TO_EVAL': 'val', # Valid: 'training', 'val' + 'INPUT_AS_ZIP': False, # Whether tracker input files are zipped + 'PRINT_CONFIG': True, # Whether to print current config + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + 'SEQMAP_FOLDER': None, # Where seqmaps are found (if None, GT_FOLDER) + 'SEQMAP_FILE': None, # Directly specify seqmap file (if none use seqmap_folder/split_to_eval.seqmap) + 'SEQ_INFO': None, # If not None, directly specify sequences to eval and their number of timesteps + 'GT_LOC_FORMAT': '{gt_folder}/label_02/{seq}.txt', # format of gt localization + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + self.gt_fol = self.config['GT_FOLDER'] + self.tracker_fol = self.config['TRACKERS_FOLDER'] + self.split_to_eval = self.config['SPLIT_TO_EVAL'] + self.should_classes_combine = False + self.use_super_categories = False + self.data_is_zipped = self.config['INPUT_AS_ZIP'] + + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.tracker_fol + + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + + # Get classes to eval + self.valid_classes = ['car', 'pedestrian'] + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. ' + 'Only classes [car, pedestrian] are valid.') + self.class_name_to_class_id = {'car': '1', 'pedestrian': '2', 'ignore': '10'} + + # Get sequences to eval and check gt files exist + self.seq_list, self.seq_lengths = self._get_seq_info() + if len(self.seq_list) < 1: + raise TrackEvalException('No sequences are selected to be evaluated.') + + # Check gt files exist + for seq in self.seq_list: + if not self.data_is_zipped: + curr_file = self.config["GT_LOC_FORMAT"].format(gt_folder=self.gt_fol, seq=seq) + if not os.path.isfile(curr_file): + print('GT file not found ' + curr_file) + raise TrackEvalException('GT file not found for sequence: ' + seq) + if self.data_is_zipped: + curr_file = os.path.join(self.gt_fol, 'data.zip') + if not os.path.isfile(curr_file): + raise TrackEvalException('GT file not found: ' + os.path.basename(curr_file)) + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + for tracker in self.tracker_list: + if self.data_is_zipped: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + if not os.path.isfile(curr_file): + print('Tracker file not found: ' + curr_file) + raise TrackEvalException('Tracker file not found: ' + tracker + '/' + os.path.basename(curr_file)) + else: + for seq in self.seq_list: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + if not os.path.isfile(curr_file): + print('Tracker file not found: ' + curr_file) + raise TrackEvalException( + 'Tracker file not found: ' + tracker + '/' + self.tracker_sub_fol + '/' + os.path.basename( + curr_file)) + + def get_display_name(self, tracker): + return self.tracker_to_disp[tracker] + + def _get_seq_info(self): + seq_list = [] + seq_lengths = {} + seqmap_name = 'evaluate_mots.seqmap.' + self.config['SPLIT_TO_EVAL'] + + if self.config["SEQ_INFO"]: + seq_list = list(self.config["SEQ_INFO"].keys()) + seq_lengths = self.config["SEQ_INFO"] + else: + if self.config["SEQMAP_FILE"]: + seqmap_file = self.config["SEQMAP_FILE"] + else: + if self.config["SEQMAP_FOLDER"] is None: + seqmap_file = os.path.join(self.config['GT_FOLDER'], seqmap_name) + else: + seqmap_file = os.path.join(self.config["SEQMAP_FOLDER"], seqmap_name) + if not os.path.isfile(seqmap_file): + print('no seqmap found: ' + seqmap_file) + raise TrackEvalException('no seqmap found: ' + os.path.basename(seqmap_file)) + with open(seqmap_file) as fp: + reader = csv.reader(fp) + for i, _ in enumerate(reader): + dialect = csv.Sniffer().sniff(fp.read(1024)) + fp.seek(0) + reader = csv.reader(fp, dialect) + for row in reader: + if len(row) >= 4: + seq = "%04d" % int(row[0]) + seq_list.append(seq) + seq_lengths[seq] = int(row[3]) + 1 + return seq_list, seq_lengths + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the KITTI MOTS format + + If is_gt, this returns a dict which contains the fields: + [gt_ids, gt_classes] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets]: list (for each timestep) of lists of detections. + [gt_ignore_region]: list (for each timestep) of masks for the ignore regions + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids, tracker_classes] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + """ + + # Only loaded when run to reduce minimum requirements + from pycocotools import mask as mask_utils + + # File location + if self.data_is_zipped: + if is_gt: + zip_file = os.path.join(self.gt_fol, 'data.zip') + else: + zip_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + file = seq + '.txt' + else: + zip_file = None + if is_gt: + file = self.config["GT_LOC_FORMAT"].format(gt_folder=self.gt_fol, seq=seq) + else: + file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + + # Ignore regions + if is_gt: + crowd_ignore_filter = {2: ['10']} + else: + crowd_ignore_filter = None + + # Load raw data from text file + read_data, ignore_data = self._load_simple_text_file(file, crowd_ignore_filter=crowd_ignore_filter, + is_zipped=self.data_is_zipped, zip_file=zip_file, + force_delimiters=' ') + + # Convert data to required format + num_timesteps = self.seq_lengths[seq] + data_keys = ['ids', 'classes', 'dets'] + if is_gt: + data_keys += ['gt_ignore_region'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + + # Check for any extra time keys + extra_time_keys = [x for x in read_data.keys() if x not in [str(t) for t in range(num_timesteps)]] + if len(extra_time_keys) > 0: + if is_gt: + text = 'Ground-truth' + else: + text = 'Tracking' + raise TrackEvalException( + text + ' data contains the following invalid timesteps in seq %s: ' % seq + ', '.join( + [str(x) + ', ' for x in extra_time_keys])) + + for t in range(num_timesteps): + time_key = str(t) + # list to collect all masks of a timestep to check for overlapping areas + all_masks = [] + if time_key in read_data.keys(): + try: + raw_data['dets'][t] = [{'size': [int(region[3]), int(region[4])], + 'counts': region[5].encode(encoding='UTF-8')} + for region in read_data[time_key]] + raw_data['ids'][t] = np.atleast_1d([region[1] for region in read_data[time_key]]).astype(int) + raw_data['classes'][t] = np.atleast_1d([region[2] for region in read_data[time_key]]).astype(int) + all_masks += raw_data['dets'][t] + except IndexError: + self._raise_index_error(is_gt, tracker, seq) + except ValueError: + self._raise_value_error(is_gt, tracker, seq) + else: + raw_data['dets'][t] = [] + raw_data['ids'][t] = np.empty(0).astype(int) + raw_data['classes'][t] = np.empty(0).astype(int) + if is_gt: + if time_key in ignore_data.keys(): + try: + time_ignore = [{'size': [int(region[3]), int(region[4])], + 'counts': region[5].encode(encoding='UTF-8')} + for region in ignore_data[time_key]] + raw_data['gt_ignore_region'][t] = mask_utils.merge([mask for mask in time_ignore], + intersect=False) + all_masks += [raw_data['gt_ignore_region'][t]] + except IndexError: + self._raise_index_error(is_gt, tracker, seq) + except ValueError: + self._raise_value_error(is_gt, tracker, seq) + else: + raw_data['gt_ignore_region'][t] = mask_utils.merge([], intersect=False) + + # check for overlapping masks + if all_masks: + masks_merged = all_masks[0] + for mask in all_masks[1:]: + if mask_utils.area(mask_utils.merge([masks_merged, mask], intersect=True)) != 0.0: + raise TrackEvalException( + 'Tracker has overlapping masks. Tracker: ' + tracker + ' Seq: ' + seq + ' Timestep: ' + str( + t)) + masks_merged = mask_utils.merge([masks_merged, mask], intersect=False) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'classes': 'gt_classes', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'classes': 'tracker_classes', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + raw_data["num_timesteps"] = num_timesteps + raw_data['seq'] = seq + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detection masks. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + + KITTI MOTS: + In KITTI MOTS, the 4 preproc steps are as follow: + 1) There are two classes (car and pedestrian) which are evaluated separately. + 2) There are no ground truth detections marked as to be removed/distractor classes. + Therefore also no matched tracker detections are removed. + 3) Ignore regions are used to remove unmatched detections (at least 50% overlap with ignore region). + 4) There are no ground truth detections (e.g. those of distractor classes) to be removed. + """ + # Check that input data has unique ids + self._check_unique_ids(raw_data) + + cls_id = int(self.class_name_to_class_id[cls]) + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + unique_gt_ids = [] + unique_tracker_ids = [] + num_gt_dets = 0 + num_tracker_dets = 0 + for t in range(raw_data['num_timesteps']): + + # Only extract relevant dets for this class for preproc and eval (cls) + gt_class_mask = np.atleast_1d(raw_data['gt_classes'][t] == cls_id) + gt_class_mask = gt_class_mask.astype(np.bool) + gt_ids = raw_data['gt_ids'][t][gt_class_mask] + gt_dets = [raw_data['gt_dets'][t][ind] for ind in range(len(gt_class_mask)) if gt_class_mask[ind]] + + tracker_class_mask = np.atleast_1d(raw_data['tracker_classes'][t] == cls_id) + tracker_class_mask = tracker_class_mask.astype(np.bool) + tracker_ids = raw_data['tracker_ids'][t][tracker_class_mask] + tracker_dets = [raw_data['tracker_dets'][t][ind] for ind in range(len(tracker_class_mask)) if + tracker_class_mask[ind]] + similarity_scores = raw_data['similarity_scores'][t][gt_class_mask, :][:, tracker_class_mask] + + # Match tracker and gt dets (with hungarian algorithm) + unmatched_indices = np.arange(tracker_ids.shape[0]) + if gt_ids.shape[0] > 0 and tracker_ids.shape[0] > 0: + matching_scores = similarity_scores.copy() + matching_scores[matching_scores < 0.5 - np.finfo('float').eps] = -10000 + match_rows, match_cols = linear_sum_assignment(-matching_scores) + actually_matched_mask = matching_scores[match_rows, match_cols] > 0 + np.finfo('float').eps + match_cols = match_cols[actually_matched_mask] + + unmatched_indices = np.delete(unmatched_indices, match_cols, axis=0) + + # For unmatched tracker dets, remove those that are greater than 50% within a crowd ignore region. + unmatched_tracker_dets = [tracker_dets[i] for i in range(len(tracker_dets)) if i in unmatched_indices] + ignore_region = raw_data['gt_ignore_region'][t] + intersection_with_ignore_region = self._calculate_mask_ious(unmatched_tracker_dets, [ignore_region], + is_encoded=True, do_ioa=True) + is_within_ignore_region = np.any(intersection_with_ignore_region > 0.5 + np.finfo('float').eps, axis=1) + + # Apply preprocessing to remove unwanted tracker dets. + to_remove_tracker = unmatched_indices[is_within_ignore_region] + data['tracker_ids'][t] = np.delete(tracker_ids, to_remove_tracker, axis=0) + data['tracker_dets'][t] = np.delete(tracker_dets, to_remove_tracker, axis=0) + similarity_scores = np.delete(similarity_scores, to_remove_tracker, axis=1) + + # Keep all ground truth detections + data['gt_ids'][t] = gt_ids + data['gt_dets'][t] = gt_dets + data['similarity_scores'][t] = similarity_scores + + unique_gt_ids += list(np.unique(data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(data['tracker_ids'][t])) + num_tracker_dets += len(data['tracker_ids'][t]) + num_gt_dets += len(data['gt_ids'][t]) + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = len(unique_tracker_ids) + data['num_gt_ids'] = len(unique_gt_ids) + data['num_timesteps'] = raw_data['num_timesteps'] + data['seq'] = raw_data['seq'] + data['cls'] = cls + + # Ensure again that ids are unique per timestep after preproc. + self._check_unique_ids(data, after_preproc=True) + + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_mask_ious(gt_dets_t, tracker_dets_t, is_encoded=True, do_ioa=False) + return similarity_scores + + @staticmethod + def _raise_index_error(is_gt, tracker, seq): + """ + Auxiliary method to raise an evaluation error in case of an index error while reading files. + :param is_gt: whether gt or tracker data is read + :param tracker: the name of the tracker + :param seq: the name of the seq + :return: None + """ + if is_gt: + err = 'Cannot load gt data from sequence %s, because there are not enough ' \ + 'columns in the data.' % seq + raise TrackEvalException(err) + else: + err = 'Cannot load tracker data from tracker %s, sequence %s, because there are not enough ' \ + 'columns in the data.' % (tracker, seq) + raise TrackEvalException(err) + + @staticmethod + def _raise_value_error(is_gt, tracker, seq): + """ + Auxiliary method to raise an evaluation error in case of an value error while reading files. + :param is_gt: whether gt or tracker data is read + :param tracker: the name of the tracker + :param seq: the name of the seq + :return: None + """ + if is_gt: + raise TrackEvalException( + 'GT data for sequence %s cannot be converted to the right format. Is data corrupted?' % seq) + else: + raise TrackEvalException( + 'Tracking data from tracker %s, sequence %s cannot be converted to the right format. ' + 'Is data corrupted?' % (tracker, seq)) diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/mot_challenge_2d_box.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/mot_challenge_2d_box.py new file mode 100644 index 0000000000000000000000000000000000000000..dc14125396630a138a78f8e1bbc51c7e909a4071 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/mot_challenge_2d_box.py @@ -0,0 +1,425 @@ +import os +import csv +import configparser +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_dataset import _BaseDataset +from .. import utils +from .. import _timing +from ..utils import TrackEvalException + + +class MotChallenge2DBox(_BaseDataset): + """Dataset class for MOT Challenge 2D bounding box tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/mot_challenge/'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/mot_challenge/'), # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'CLASSES_TO_EVAL': ['pedestrian'], # Valid: ['pedestrian'] + 'BENCHMARK': 'MOT17', # Valid: 'MOT17', 'MOT16', 'MOT20', 'MOT15' + 'SPLIT_TO_EVAL': 'train', # Valid: 'train', 'test', 'all' + 'INPUT_AS_ZIP': False, # Whether tracker input files are zipped + 'PRINT_CONFIG': True, # Whether to print current config + 'DO_PREPROC': True, # Whether to perform preprocessing (never done for MOT15) + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + 'SEQMAP_FOLDER': None, # Where seqmaps are found (if None, GT_FOLDER/seqmaps) + 'SEQMAP_FILE': None, # Directly specify seqmap file (if none use seqmap_folder/benchmark-split_to_eval) + 'SEQ_INFO': None, # If not None, directly specify sequences to eval and their number of timesteps + 'GT_LOC_FORMAT': '{gt_folder}/{seq}/gt/gt.txt', # '{gt_folder}/{seq}/gt/gt.txt' + 'SKIP_SPLIT_FOL': False, # If False, data is in GT_FOLDER/BENCHMARK-SPLIT_TO_EVAL/ and in + # TRACKERS_FOLDER/BENCHMARK-SPLIT_TO_EVAL/tracker/ + # If True, then the middle 'benchmark-split' folder is skipped for both. + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + + self.benchmark = self.config['BENCHMARK'] + gt_set = self.config['BENCHMARK'] + '-' + self.config['SPLIT_TO_EVAL'] + self.gt_set = gt_set + if not self.config['SKIP_SPLIT_FOL']: + split_fol = gt_set + else: + split_fol = '' + if self.benchmark == 'MOT16': + split_fol = '' + self.gt_fol = os.path.join(self.config['GT_FOLDER'], split_fol) + self.tracker_fol = os.path.join(self.config['TRACKERS_FOLDER'], split_fol) + self.should_classes_combine = False + self.use_super_categories = False + self.data_is_zipped = self.config['INPUT_AS_ZIP'] + self.do_preproc = self.config['DO_PREPROC'] + + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.tracker_fol + + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + + # Get classes to eval + self.valid_classes = ['pedestrian'] + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. Only pedestrian class is valid.') + self.class_name_to_class_id = {'pedestrian': 1, 'person_on_vehicle': 2, 'car': 3, 'bicycle': 4, 'motorbike': 5, + 'non_mot_vehicle': 6, 'static_person': 7, 'distractor': 8, 'occluder': 9, + 'occluder_on_ground': 10, 'occluder_full': 11, 'reflection': 12, 'crowd': 13} + + # Get sequences to eval and check gt files exist + self.seq_list, self.seq_lengths = self._get_seq_info() + if len(self.seq_list) < 1: + raise TrackEvalException('No sequences are selected to be evaluated.') + + # Check gt files exist + for seq in self.seq_list: + if not self.data_is_zipped: + curr_file = self.config["GT_LOC_FORMAT"].format(gt_folder=self.gt_fol, seq=seq) + if not os.path.isfile(curr_file): + print('GT file not found ' + curr_file) + raise TrackEvalException('GT file not found for sequence: ' + seq) + if self.data_is_zipped: + curr_file = os.path.join(self.gt_fol, 'data.zip') + if not os.path.isfile(curr_file): + print('GT file not found ' + curr_file) + raise TrackEvalException('GT file not found: ' + os.path.basename(curr_file)) + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + for tracker in self.tracker_list: + if self.data_is_zipped: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + if not os.path.isfile(curr_file): + print('Tracker file not found: ' + curr_file) + raise TrackEvalException('Tracker file not found: ' + tracker + '/' + os.path.basename(curr_file)) + else: + for seq in self.seq_list: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + if not os.path.isfile(curr_file): + print('Tracker file not found: ' + curr_file) + raise TrackEvalException( + 'Tracker file not found: ' + tracker + '/' + self.tracker_sub_fol + '/' + os.path.basename( + curr_file)) + + def get_display_name(self, tracker): + return self.tracker_to_disp[tracker] + + def _get_seq_info(self): + seq_list = [] + seq_lengths = {} + if self.config["SEQ_INFO"]: + seq_list = list(self.config["SEQ_INFO"].keys()) + seq_lengths = self.config["SEQ_INFO"] + + # If sequence length is 'None' tries to read sequence length from .ini files. + for seq, seq_length in seq_lengths.items(): + if seq_length is None: + ini_file = os.path.join(self.gt_fol, seq, 'seqinfo.ini') + if not os.path.isfile(ini_file): + raise TrackEvalException('ini file does not exist: ' + seq + '/' + os.path.basename(ini_file)) + ini_data = configparser.ConfigParser() + ini_data.read(ini_file) + seq_lengths[seq] = int(ini_data['Sequence']['seqLength']) + + else: + if self.config["SEQMAP_FILE"]: + seqmap_file = self.config["SEQMAP_FILE"] + else: + if self.config["SEQMAP_FOLDER"] is None: + seqmap_file = os.path.join(self.config['GT_FOLDER'], 'seqmaps', self.gt_set + '.txt') + else: + seqmap_file = os.path.join(self.config["SEQMAP_FOLDER"], self.gt_set + '.txt') + if not os.path.isfile(seqmap_file): + print('no seqmap found: ' + seqmap_file) + raise TrackEvalException('no seqmap found: ' + os.path.basename(seqmap_file)) + with open(seqmap_file) as fp: + reader = csv.reader(fp) + for i, row in enumerate(reader): + if i == 0 or row[0] == '': + continue + seq = row[0] + seq_list.append(seq) + ini_file = os.path.join(self.gt_fol, seq, 'seqinfo.ini') + if not os.path.isfile(ini_file): + raise TrackEvalException('ini file does not exist: ' + seq + '/' + os.path.basename(ini_file)) + ini_data = configparser.ConfigParser() + ini_data.read(ini_file) + seq_lengths[seq] = int(ini_data['Sequence']['seqLength']) + return seq_list, seq_lengths + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the MOT Challenge 2D box format + + If is_gt, this returns a dict which contains the fields: + [gt_ids, gt_classes] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, gt_crowd_ignore_regions]: list (for each timestep) of lists of detections. + [gt_extras] : list (for each timestep) of dicts (for each extra) of 1D NDArrays (for each det). + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids, tracker_classes, tracker_confidences] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + """ + # File location + if self.data_is_zipped: + if is_gt: + zip_file = os.path.join(self.gt_fol, 'data.zip') + else: + zip_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + file = seq + '.txt' + else: + zip_file = None + if is_gt: + file = self.config["GT_LOC_FORMAT"].format(gt_folder=self.gt_fol, seq=seq) + else: + file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + + # Load raw data from text file + read_data, ignore_data = self._load_simple_text_file(file, is_zipped=self.data_is_zipped, zip_file=zip_file) + + # Convert data to required format + num_timesteps = self.seq_lengths[seq] + data_keys = ['ids', 'classes', 'dets'] + if is_gt: + data_keys += ['gt_crowd_ignore_regions', 'gt_extras'] + else: + data_keys += ['tracker_confidences'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + + # Check for any extra time keys + extra_time_keys = [x for x in read_data.keys() if x not in [str(t+1) for t in range(num_timesteps)]] + if len(extra_time_keys) > 0: + if is_gt: + text = 'Ground-truth' + else: + text = 'Tracking' + raise TrackEvalException( + text + ' data contains the following invalid timesteps in seq %s: ' % seq + ', '.join( + [str(x) + ', ' for x in extra_time_keys])) + + for t in range(num_timesteps): + time_key = str(t+1) + if time_key in read_data.keys(): + try: + time_data = np.asarray(read_data[time_key], dtype=np.float) + except ValueError: + if is_gt: + raise TrackEvalException( + 'Cannot convert gt data for sequence %s to float. Is data corrupted?' % seq) + else: + raise TrackEvalException( + 'Cannot convert tracking data from tracker %s, sequence %s to float. Is data corrupted?' % ( + tracker, seq)) + try: + raw_data['dets'][t] = np.atleast_2d(time_data[:, 2:6]) + raw_data['ids'][t] = np.atleast_1d(time_data[:, 1]).astype(int) + except IndexError: + if is_gt: + err = 'Cannot load gt data from sequence %s, because there is not enough ' \ + 'columns in the data.' % seq + raise TrackEvalException(err) + else: + err = 'Cannot load tracker data from tracker %s, sequence %s, because there is not enough ' \ + 'columns in the data.' % (tracker, seq) + raise TrackEvalException(err) + if time_data.shape[1] >= 8: + raw_data['classes'][t] = np.atleast_1d(time_data[:, 7]).astype(int) + else: + if not is_gt: + raw_data['classes'][t] = np.ones_like(raw_data['ids'][t]) + else: + raise TrackEvalException( + 'GT data is not in a valid format, there is not enough rows in seq %s, timestep %i.' % ( + seq, t)) + if is_gt: + gt_extras_dict = {'zero_marked': np.atleast_1d(time_data[:, 6].astype(int))} + raw_data['gt_extras'][t] = gt_extras_dict + else: + raw_data['tracker_confidences'][t] = np.atleast_1d(time_data[:, 6]) + else: + raw_data['dets'][t] = np.empty((0, 4)) + raw_data['ids'][t] = np.empty(0).astype(int) + raw_data['classes'][t] = np.empty(0).astype(int) + if is_gt: + gt_extras_dict = {'zero_marked': np.empty(0)} + raw_data['gt_extras'][t] = gt_extras_dict + else: + raw_data['tracker_confidences'][t] = np.empty(0) + if is_gt: + raw_data['gt_crowd_ignore_regions'][t] = np.empty((0, 4)) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'classes': 'gt_classes', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'classes': 'tracker_classes', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + raw_data['num_timesteps'] = num_timesteps + raw_data['seq'] = seq + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids, tracker_confidences]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detections. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + + MOT Challenge: + In MOT Challenge, the 4 preproc steps are as follow: + 1) There is only one class (pedestrian) to be evaluated, but all other classes are used for preproc. + 2) Predictions are matched against all gt boxes (regardless of class), those matching with distractor + objects are removed. + 3) There is no crowd ignore regions. + 4) All gt dets except pedestrian are removed, also removes pedestrian gt dets marked with zero_marked. + """ + # Check that input data has unique ids + self._check_unique_ids(raw_data) + + distractor_class_names = ['person_on_vehicle', 'static_person', 'distractor', 'reflection'] + if self.benchmark == 'MOT20': + distractor_class_names.append('non_mot_vehicle') + distractor_classes = [self.class_name_to_class_id[x] for x in distractor_class_names] + cls_id = self.class_name_to_class_id[cls] + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'tracker_confidences', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + unique_gt_ids = [] + unique_tracker_ids = [] + num_gt_dets = 0 + num_tracker_dets = 0 + for t in range(raw_data['num_timesteps']): + + # Get all data + gt_ids = raw_data['gt_ids'][t] + gt_dets = raw_data['gt_dets'][t] + gt_classes = raw_data['gt_classes'][t] + gt_zero_marked = raw_data['gt_extras'][t]['zero_marked'] + + tracker_ids = raw_data['tracker_ids'][t] + tracker_dets = raw_data['tracker_dets'][t] + tracker_classes = raw_data['tracker_classes'][t] + tracker_confidences = raw_data['tracker_confidences'][t] + similarity_scores = raw_data['similarity_scores'][t] + + # Evaluation is ONLY valid for pedestrian class + if len(tracker_classes) > 0 and np.max(tracker_classes) > 1: + raise TrackEvalException( + 'Evaluation is only valid for pedestrian class. Non pedestrian class (%i) found in sequence %s at ' + 'timestep %i.' % (np.max(tracker_classes), raw_data['seq'], t)) + + # Match tracker and gt dets (with hungarian algorithm) and remove tracker dets which match with gt dets + # which are labeled as belonging to a distractor class. + to_remove_tracker = np.array([], np.int) + if self.do_preproc and self.benchmark != 'MOT15' and gt_ids.shape[0] > 0 and tracker_ids.shape[0] > 0: + matching_scores = similarity_scores.copy() + matching_scores[matching_scores < 0.5 - np.finfo('float').eps] = 0 + match_rows, match_cols = linear_sum_assignment(-matching_scores) + actually_matched_mask = matching_scores[match_rows, match_cols] > 0 + np.finfo('float').eps + match_rows = match_rows[actually_matched_mask] + match_cols = match_cols[actually_matched_mask] + + is_distractor_class = np.isin(gt_classes[match_rows], distractor_classes) + to_remove_tracker = match_cols[is_distractor_class] + + # Apply preprocessing to remove all unwanted tracker dets. + data['tracker_ids'][t] = np.delete(tracker_ids, to_remove_tracker, axis=0) + data['tracker_dets'][t] = np.delete(tracker_dets, to_remove_tracker, axis=0) + data['tracker_confidences'][t] = np.delete(tracker_confidences, to_remove_tracker, axis=0) + similarity_scores = np.delete(similarity_scores, to_remove_tracker, axis=1) + + # Remove gt detections marked as to remove (zero marked), and also remove gt detections not in pedestrian + # class (not applicable for MOT15) + if self.benchmark != 'MOT15': + gt_to_keep_mask = (np.not_equal(gt_zero_marked, 0)) & \ + (np.equal(gt_classes, cls_id)) + else: + # There are no classes for MOT15 + gt_to_keep_mask = np.not_equal(gt_zero_marked, 0) + data['gt_ids'][t] = gt_ids[gt_to_keep_mask] + data['gt_dets'][t] = gt_dets[gt_to_keep_mask, :] + data['similarity_scores'][t] = similarity_scores[gt_to_keep_mask] + + unique_gt_ids += list(np.unique(data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(data['tracker_ids'][t])) + num_tracker_dets += len(data['tracker_ids'][t]) + num_gt_dets += len(data['gt_ids'][t]) + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = len(unique_tracker_ids) + data['num_gt_ids'] = len(unique_gt_ids) + data['num_timesteps'] = raw_data['num_timesteps'] + data['seq'] = raw_data['seq'] + + # Ensure again that ids are unique per timestep after preproc. + self._check_unique_ids(data, after_preproc=True) + + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_box_ious(gt_dets_t, tracker_dets_t, box_format='xywh') + return similarity_scores diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/mots_challenge.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/mots_challenge.py new file mode 100644 index 0000000000000000000000000000000000000000..469157480de25792aaf3fa5b3d642d32c6057018 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/mots_challenge.py @@ -0,0 +1,445 @@ +import os +import csv +import configparser +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_dataset import _BaseDataset +from .. import utils +from .. import _timing +from ..utils import TrackEvalException + + +class MOTSChallenge(_BaseDataset): + """Dataset class for MOTS Challenge tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/mot_challenge/'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/mot_challenge/'), # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'CLASSES_TO_EVAL': ['pedestrian'], # Valid: ['pedestrian'] + 'SPLIT_TO_EVAL': 'train', # Valid: 'train', 'test' + 'INPUT_AS_ZIP': False, # Whether tracker input files are zipped + 'PRINT_CONFIG': True, # Whether to print current config + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + 'SEQMAP_FOLDER': None, # Where seqmaps are found (if None, GT_FOLDER/seqmaps) + 'SEQMAP_FILE': None, # Directly specify seqmap file (if none use seqmap_folder/MOTS-split_to_eval) + 'SEQ_INFO': None, # If not None, directly specify sequences to eval and their number of timesteps + 'GT_LOC_FORMAT': '{gt_folder}/{seq}/gt/gt.txt', # '{gt_folder}/{seq}/gt/gt.txt' + 'SKIP_SPLIT_FOL': False, # If False, data is in GT_FOLDER/MOTS-SPLIT_TO_EVAL/ and in + # TRACKERS_FOLDER/MOTS-SPLIT_TO_EVAL/tracker/ + # If True, then the middle 'MOTS-split' folder is skipped for both. + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + + self.benchmark = 'MOTS' + self.gt_set = self.benchmark + '-' + self.config['SPLIT_TO_EVAL'] + if not self.config['SKIP_SPLIT_FOL']: + split_fol = self.gt_set + else: + split_fol = '' + self.gt_fol = os.path.join(self.config['GT_FOLDER'], split_fol) + self.tracker_fol = os.path.join(self.config['TRACKERS_FOLDER'], split_fol) + self.should_classes_combine = False + self.use_super_categories = False + self.data_is_zipped = self.config['INPUT_AS_ZIP'] + + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.tracker_fol + + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + + # Get classes to eval + self.valid_classes = ['pedestrian'] + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. Only pedestrian class is valid.') + self.class_name_to_class_id = {'pedestrian': '2', 'ignore': '10'} + + # Get sequences to eval and check gt files exist + self.seq_list, self.seq_lengths = self._get_seq_info() + if len(self.seq_list) < 1: + raise TrackEvalException('No sequences are selected to be evaluated.') + + # Check gt files exist + for seq in self.seq_list: + if not self.data_is_zipped: + curr_file = self.config["GT_LOC_FORMAT"].format(gt_folder=self.gt_fol, seq=seq) + if not os.path.isfile(curr_file): + print('GT file not found ' + curr_file) + raise TrackEvalException('GT file not found for sequence: ' + seq) + if self.data_is_zipped: + curr_file = os.path.join(self.gt_fol, 'data.zip') + if not os.path.isfile(curr_file): + print('GT file not found ' + curr_file) + raise TrackEvalException('GT file not found: ' + os.path.basename(curr_file)) + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + for tracker in self.tracker_list: + if self.data_is_zipped: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + if not os.path.isfile(curr_file): + print('Tracker file not found: ' + curr_file) + raise TrackEvalException('Tracker file not found: ' + tracker + '/' + os.path.basename(curr_file)) + else: + for seq in self.seq_list: + curr_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + if not os.path.isfile(curr_file): + print('Tracker file not found: ' + curr_file) + raise TrackEvalException( + 'Tracker file not found: ' + tracker + '/' + self.tracker_sub_fol + '/' + os.path.basename( + curr_file)) + + def get_display_name(self, tracker): + return self.tracker_to_disp[tracker] + + def _get_seq_info(self): + seq_list = [] + seq_lengths = {} + if self.config["SEQ_INFO"]: + seq_list = list(self.config["SEQ_INFO"].keys()) + seq_lengths = self.config["SEQ_INFO"] + + # If sequence length is 'None' tries to read sequence length from .ini files. + for seq, seq_length in seq_lengths.items(): + if seq_length is None: + ini_file = os.path.join(self.gt_fol, seq, 'seqinfo.ini') + if not os.path.isfile(ini_file): + raise TrackEvalException('ini file does not exist: ' + seq + '/' + os.path.basename(ini_file)) + ini_data = configparser.ConfigParser() + ini_data.read(ini_file) + seq_lengths[seq] = int(ini_data['Sequence']['seqLength']) + + else: + if self.config["SEQMAP_FILE"]: + seqmap_file = self.config["SEQMAP_FILE"] + else: + if self.config["SEQMAP_FOLDER"] is None: + seqmap_file = os.path.join(self.config['GT_FOLDER'], 'seqmaps', self.gt_set + '.txt') + else: + seqmap_file = os.path.join(self.config["SEQMAP_FOLDER"], self.gt_set + '.txt') + if not os.path.isfile(seqmap_file): + print('no seqmap found: ' + seqmap_file) + raise TrackEvalException('no seqmap found: ' + os.path.basename(seqmap_file)) + with open(seqmap_file) as fp: + reader = csv.reader(fp) + for i, row in enumerate(reader): + if i == 0 or row[0] == '': + continue + seq = row[0] + seq_list.append(seq) + ini_file = os.path.join(self.gt_fol, seq, 'seqinfo.ini') + if not os.path.isfile(ini_file): + raise TrackEvalException('ini file does not exist: ' + seq + '/' + os.path.basename(ini_file)) + ini_data = configparser.ConfigParser() + ini_data.read(ini_file) + seq_lengths[seq] = int(ini_data['Sequence']['seqLength']) + return seq_list, seq_lengths + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the MOTS Challenge format + + If is_gt, this returns a dict which contains the fields: + [gt_ids, gt_classes] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets]: list (for each timestep) of lists of detections. + [gt_ignore_region]: list (for each timestep) of masks for the ignore regions + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids, tracker_classes] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + """ + + # Only loaded when run to reduce minimum requirements + from pycocotools import mask as mask_utils + + # File location + if self.data_is_zipped: + if is_gt: + zip_file = os.path.join(self.gt_fol, 'data.zip') + else: + zip_file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol + '.zip') + file = seq + '.txt' + else: + zip_file = None + if is_gt: + file = self.config["GT_LOC_FORMAT"].format(gt_folder=self.gt_fol, seq=seq) + else: + file = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, seq + '.txt') + + # Ignore regions + if is_gt: + crowd_ignore_filter = {2: ['10']} + else: + crowd_ignore_filter = None + + # Load raw data from text file + read_data, ignore_data = self._load_simple_text_file(file, crowd_ignore_filter=crowd_ignore_filter, + is_zipped=self.data_is_zipped, zip_file=zip_file, + force_delimiters=' ') + + # Convert data to required format + num_timesteps = self.seq_lengths[seq] + data_keys = ['ids', 'classes', 'dets'] + if is_gt: + data_keys += ['gt_ignore_region'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + + # Check for any extra time keys + extra_time_keys = [x for x in read_data.keys() if x not in [str(t+1) for t in range(num_timesteps)]] + if len(extra_time_keys) > 0: + if is_gt: + text = 'Ground-truth' + else: + text = 'Tracking' + raise TrackEvalException( + text + ' data contains the following invalid timesteps in seq %s: ' % seq + ', '.join( + [str(x) + ', ' for x in extra_time_keys])) + + for t in range(num_timesteps): + time_key = str(t+1) + # list to collect all masks of a timestep to check for overlapping areas + all_masks = [] + if time_key in read_data.keys(): + try: + raw_data['dets'][t] = [{'size': [int(region[3]), int(region[4])], + 'counts': region[5].encode(encoding='UTF-8')} + for region in read_data[time_key]] + raw_data['ids'][t] = np.atleast_1d([region[1] for region in read_data[time_key]]).astype(int) + raw_data['classes'][t] = np.atleast_1d([region[2] for region in read_data[time_key]]).astype(int) + all_masks += raw_data['dets'][t] + except IndexError: + self._raise_index_error(is_gt, tracker, seq) + except ValueError: + self._raise_value_error(is_gt, tracker, seq) + else: + raw_data['dets'][t] = [] + raw_data['ids'][t] = np.empty(0).astype(int) + raw_data['classes'][t] = np.empty(0).astype(int) + if is_gt: + if time_key in ignore_data.keys(): + try: + time_ignore = [{'size': [int(region[3]), int(region[4])], + 'counts': region[5].encode(encoding='UTF-8')} + for region in ignore_data[time_key]] + raw_data['gt_ignore_region'][t] = mask_utils.merge([mask for mask in time_ignore], + intersect=False) + all_masks += [raw_data['gt_ignore_region'][t]] + except IndexError: + self._raise_index_error(is_gt, tracker, seq) + except ValueError: + self._raise_value_error(is_gt, tracker, seq) + else: + raw_data['gt_ignore_region'][t] = mask_utils.merge([], intersect=False) + + # check for overlapping masks + if all_masks: + masks_merged = all_masks[0] + for mask in all_masks[1:]: + if mask_utils.area(mask_utils.merge([masks_merged, mask], intersect=True)) != 0.0: + raise TrackEvalException( + 'Tracker has overlapping masks. Tracker: ' + tracker + ' Seq: ' + seq + ' Timestep: ' + str( + t)) + masks_merged = mask_utils.merge([masks_merged, mask], intersect=False) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'classes': 'gt_classes', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'classes': 'tracker_classes', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + raw_data['num_timesteps'] = num_timesteps + raw_data['seq'] = seq + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detection masks. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + + MOTS Challenge: + In MOTS Challenge, the 4 preproc steps are as follow: + 1) There is only one class (pedestrians) to be evaluated. + 2) There are no ground truth detections marked as to be removed/distractor classes. + Therefore also no matched tracker detections are removed. + 3) Ignore regions are used to remove unmatched detections (at least 50% overlap with ignore region). + 4) There are no ground truth detections (e.g. those of distractor classes) to be removed. + """ + # Check that input data has unique ids + self._check_unique_ids(raw_data) + + cls_id = int(self.class_name_to_class_id[cls]) + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + unique_gt_ids = [] + unique_tracker_ids = [] + num_gt_dets = 0 + num_tracker_dets = 0 + for t in range(raw_data['num_timesteps']): + + # Only extract relevant dets for this class for preproc and eval (cls) + gt_class_mask = np.atleast_1d(raw_data['gt_classes'][t] == cls_id) + gt_class_mask = gt_class_mask.astype(np.bool) + gt_ids = raw_data['gt_ids'][t][gt_class_mask] + gt_dets = [raw_data['gt_dets'][t][ind] for ind in range(len(gt_class_mask)) if gt_class_mask[ind]] + + tracker_class_mask = np.atleast_1d(raw_data['tracker_classes'][t] == cls_id) + tracker_class_mask = tracker_class_mask.astype(np.bool) + tracker_ids = raw_data['tracker_ids'][t][tracker_class_mask] + tracker_dets = [raw_data['tracker_dets'][t][ind] for ind in range(len(tracker_class_mask)) if + tracker_class_mask[ind]] + similarity_scores = raw_data['similarity_scores'][t][gt_class_mask, :][:, tracker_class_mask] + + # Match tracker and gt dets (with hungarian algorithm) + unmatched_indices = np.arange(tracker_ids.shape[0]) + if gt_ids.shape[0] > 0 and tracker_ids.shape[0] > 0: + matching_scores = similarity_scores.copy() + matching_scores[matching_scores < 0.5 - np.finfo('float').eps] = -10000 + match_rows, match_cols = linear_sum_assignment(-matching_scores) + actually_matched_mask = matching_scores[match_rows, match_cols] > 0 + np.finfo('float').eps + match_cols = match_cols[actually_matched_mask] + + unmatched_indices = np.delete(unmatched_indices, match_cols, axis=0) + + # For unmatched tracker dets, remove those that are greater than 50% within a crowd ignore region. + unmatched_tracker_dets = [tracker_dets[i] for i in range(len(tracker_dets)) if i in unmatched_indices] + ignore_region = raw_data['gt_ignore_region'][t] + intersection_with_ignore_region = self._calculate_mask_ious(unmatched_tracker_dets, [ignore_region], + is_encoded=True, do_ioa=True) + is_within_ignore_region = np.any(intersection_with_ignore_region > 0.5 + np.finfo('float').eps, axis=1) + + # Apply preprocessing to remove unwanted tracker dets. + to_remove_tracker = unmatched_indices[is_within_ignore_region] + data['tracker_ids'][t] = np.delete(tracker_ids, to_remove_tracker, axis=0) + data['tracker_dets'][t] = np.delete(tracker_dets, to_remove_tracker, axis=0) + similarity_scores = np.delete(similarity_scores, to_remove_tracker, axis=1) + + # Keep all ground truth detections + data['gt_ids'][t] = gt_ids + data['gt_dets'][t] = gt_dets + data['similarity_scores'][t] = similarity_scores + + unique_gt_ids += list(np.unique(data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(data['tracker_ids'][t])) + num_tracker_dets += len(data['tracker_ids'][t]) + num_gt_dets += len(data['gt_ids'][t]) + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = len(unique_tracker_ids) + data['num_gt_ids'] = len(unique_gt_ids) + data['num_timesteps'] = raw_data['num_timesteps'] + data['seq'] = raw_data['seq'] + + # Ensure again that ids are unique per timestep after preproc. + self._check_unique_ids(data, after_preproc=True) + + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_mask_ious(gt_dets_t, tracker_dets_t, is_encoded=True, do_ioa=False) + return similarity_scores + + @staticmethod + def _raise_index_error(is_gt, tracker, seq): + """ + Auxiliary method to raise an evaluation error in case of an index error while reading files. + :param is_gt: whether gt or tracker data is read + :param tracker: the name of the tracker + :param seq: the name of the seq + :return: None + """ + if is_gt: + err = 'Cannot load gt data from sequence %s, because there are not enough ' \ + 'columns in the data.' % seq + raise TrackEvalException(err) + else: + err = 'Cannot load tracker data from tracker %s, sequence %s, because there are not enough ' \ + 'columns in the data.' % (tracker, seq) + raise TrackEvalException(err) + + @staticmethod + def _raise_value_error(is_gt, tracker, seq): + """ + Auxiliary method to raise an evaluation error in case of an value error while reading files. + :param is_gt: whether gt or tracker data is read + :param tracker: the name of the tracker + :param seq: the name of the seq + :return: None + """ + if is_gt: + raise TrackEvalException( + 'GT data for sequence %s cannot be converted to the right format. Is data corrupted?' % seq) + else: + raise TrackEvalException( + 'Tracking data from tracker %s, sequence %s cannot be converted to the right format. ' + 'Is data corrupted?' % (tracker, seq)) diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/tao.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/tao.py new file mode 100644 index 0000000000000000000000000000000000000000..e8461676a82d8c8aaac071ae5f9a8b5db2723049 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/tao.py @@ -0,0 +1,566 @@ +import os +import numpy as np +import json +import itertools +from collections import defaultdict +from scipy.optimize import linear_sum_assignment +from ..utils import TrackEvalException +from ._base_dataset import _BaseDataset +from .. import utils +from .. import _timing + + +class TAO(_BaseDataset): + """Dataset class for TAO tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/tao/tao_training'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/tao/tao_training'), # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'CLASSES_TO_EVAL': None, # Classes to eval (if None, all classes) + 'SPLIT_TO_EVAL': 'training', # Valid: 'training', 'val' + 'PRINT_CONFIG': True, # Whether to print current config + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + 'MAX_DETECTIONS': 300, # Number of maximal allowed detections per image (0 for unlimited) + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + self.gt_fol = self.config['GT_FOLDER'] + self.tracker_fol = self.config['TRACKERS_FOLDER'] + self.should_classes_combine = True + self.use_super_categories = False + + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.tracker_fol + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + + gt_dir_files = [file for file in os.listdir(self.gt_fol) if file.endswith('.json')] + if len(gt_dir_files) != 1: + raise TrackEvalException(self.gt_fol + ' does not contain exactly one json file.') + + with open(os.path.join(self.gt_fol, gt_dir_files[0])) as f: + self.gt_data = json.load(f) + + # merge categories marked with a merged tag in TAO dataset + self._merge_categories(self.gt_data['annotations'] + self.gt_data['tracks']) + + # Get sequences to eval and sequence information + self.seq_list = [vid['name'].replace('/', '-') for vid in self.gt_data['videos']] + self.seq_name_to_seq_id = {vid['name'].replace('/', '-'): vid['id'] for vid in self.gt_data['videos']} + # compute mappings from videos to annotation data + self.videos_to_gt_tracks, self.videos_to_gt_images = self._compute_vid_mappings(self.gt_data['annotations']) + # compute sequence lengths + self.seq_lengths = {vid['id']: 0 for vid in self.gt_data['videos']} + for img in self.gt_data['images']: + self.seq_lengths[img['video_id']] += 1 + self.seq_to_images_to_timestep = self._compute_image_to_timestep_mappings() + self.seq_to_classes = {vid['id']: {'pos_cat_ids': list({track['category_id'] for track + in self.videos_to_gt_tracks[vid['id']]}), + 'neg_cat_ids': vid['neg_category_ids'], + 'not_exhaustively_labeled_cat_ids': vid['not_exhaustive_category_ids']} + for vid in self.gt_data['videos']} + + # Get classes to eval + considered_vid_ids = [self.seq_name_to_seq_id[vid] for vid in self.seq_list] + seen_cats = set([cat_id for vid_id in considered_vid_ids for cat_id + in self.seq_to_classes[vid_id]['pos_cat_ids']]) + # only classes with ground truth are evaluated in TAO + self.valid_classes = [cls['name'] for cls in self.gt_data['categories'] if cls['id'] in seen_cats] + cls_name_to_cls_id_map = {cls['name']: cls['id'] for cls in self.gt_data['categories']} + + if self.config['CLASSES_TO_EVAL']: + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. Only classes ' + + ', '.join(self.valid_classes) + + ' are valid (classes present in ground truth data).') + else: + self.class_list = [cls for cls in self.valid_classes] + self.class_name_to_class_id = {k: v for k, v in cls_name_to_cls_id_map.items() if k in self.class_list} + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + self.tracker_data = {tracker: dict() for tracker in self.tracker_list} + + for tracker in self.tracker_list: + tr_dir_files = [file for file in os.listdir(os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol)) + if file.endswith('.json')] + if len(tr_dir_files) != 1: + raise TrackEvalException(os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol) + + ' does not contain exactly one json file.') + with open(os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol, tr_dir_files[0])) as f: + curr_data = json.load(f) + + # limit detections if MAX_DETECTIONS > 0 + if self.config['MAX_DETECTIONS']: + curr_data = self._limit_dets_per_image(curr_data) + + # fill missing video ids + self._fill_video_ids_inplace(curr_data) + + # make track ids unique over whole evaluation set + self._make_track_ids_unique(curr_data) + + # merge categories marked with a merged tag in TAO dataset + self._merge_categories(curr_data) + + # get tracker sequence information + curr_videos_to_tracker_tracks, curr_videos_to_tracker_images = self._compute_vid_mappings(curr_data) + self.tracker_data[tracker]['vids_to_tracks'] = curr_videos_to_tracker_tracks + self.tracker_data[tracker]['vids_to_images'] = curr_videos_to_tracker_images + + def get_display_name(self, tracker): + return self.tracker_to_disp[tracker] + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the TAO format + + If is_gt, this returns a dict which contains the fields: + [gt_ids, gt_classes] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets]: list (for each timestep) of lists of detections. + [classes_to_gt_tracks]: dictionary with class values as keys and list of dictionaries (with frame indices as + keys and corresponding segmentations as values) for each track + [classes_to_gt_track_ids, classes_to_gt_track_areas, classes_to_gt_track_lengths]: dictionary with class values + as keys and lists (for each track) as values + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids, tracker_classes, tracker_confidences] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + [classes_to_dt_tracks]: dictionary with class values as keys and list of dictionaries (with frame indices as + keys and corresponding segmentations as values) for each track + [classes_to_dt_track_ids, classes_to_dt_track_areas, classes_to_dt_track_lengths]: dictionary with class values + as keys and lists as values + [classes_to_dt_track_scores]: dictionary with class values as keys and 1D numpy arrays as values + """ + seq_id = self.seq_name_to_seq_id[seq] + # File location + if is_gt: + imgs = self.videos_to_gt_images[seq_id] + else: + imgs = self.tracker_data[tracker]['vids_to_images'][seq_id] + + # Convert data to required format + num_timesteps = self.seq_lengths[seq_id] + img_to_timestep = self.seq_to_images_to_timestep[seq_id] + data_keys = ['ids', 'classes', 'dets'] + if not is_gt: + data_keys += ['tracker_confidences'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + for img in imgs: + # some tracker data contains images without any ground truth information, these are ignored + try: + t = img_to_timestep[img['id']] + except KeyError: + continue + annotations = img['annotations'] + raw_data['dets'][t] = np.atleast_2d([ann['bbox'] for ann in annotations]).astype(float) + raw_data['ids'][t] = np.atleast_1d([ann['track_id'] for ann in annotations]).astype(int) + raw_data['classes'][t] = np.atleast_1d([ann['category_id'] for ann in annotations]).astype(int) + if not is_gt: + raw_data['tracker_confidences'][t] = np.atleast_1d([ann['score'] for ann in annotations]).astype(float) + + for t, d in enumerate(raw_data['dets']): + if d is None: + raw_data['dets'][t] = np.empty((0, 4)).astype(float) + raw_data['ids'][t] = np.empty(0).astype(int) + raw_data['classes'][t] = np.empty(0).astype(int) + if not is_gt: + raw_data['tracker_confidences'][t] = np.empty(0) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'classes': 'gt_classes', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'classes': 'tracker_classes', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + + all_classes = [self.class_name_to_class_id[cls] for cls in self.class_list] + if is_gt: + classes_to_consider = all_classes + all_tracks = self.videos_to_gt_tracks[seq_id] + else: + classes_to_consider = self.seq_to_classes[seq_id]['pos_cat_ids'] \ + + self.seq_to_classes[seq_id]['neg_cat_ids'] + all_tracks = self.tracker_data[tracker]['vids_to_tracks'][seq_id] + + classes_to_tracks = {cls: [track for track in all_tracks if track['category_id'] == cls] + if cls in classes_to_consider else [] for cls in all_classes} + + # mapping from classes to track information + raw_data['classes_to_tracks'] = {cls: [{det['image_id']: np.atleast_1d(det['bbox']) + for det in track['annotations']} for track in tracks] + for cls, tracks in classes_to_tracks.items()} + raw_data['classes_to_track_ids'] = {cls: [track['id'] for track in tracks] + for cls, tracks in classes_to_tracks.items()} + raw_data['classes_to_track_areas'] = {cls: [track['area'] for track in tracks] + for cls, tracks in classes_to_tracks.items()} + raw_data['classes_to_track_lengths'] = {cls: [len(track['annotations']) for track in tracks] + for cls, tracks in classes_to_tracks.items()} + + if not is_gt: + raw_data['classes_to_dt_track_scores'] = {cls: np.array([np.mean([float(x['score']) + for x in track['annotations']]) + for track in tracks]) + for cls, tracks in classes_to_tracks.items()} + + if is_gt: + key_map = {'classes_to_tracks': 'classes_to_gt_tracks', + 'classes_to_track_ids': 'classes_to_gt_track_ids', + 'classes_to_track_lengths': 'classes_to_gt_track_lengths', + 'classes_to_track_areas': 'classes_to_gt_track_areas'} + else: + key_map = {'classes_to_tracks': 'classes_to_dt_tracks', + 'classes_to_track_ids': 'classes_to_dt_track_ids', + 'classes_to_track_lengths': 'classes_to_dt_track_lengths', + 'classes_to_track_areas': 'classes_to_dt_track_areas'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + + raw_data['num_timesteps'] = num_timesteps + raw_data['neg_cat_ids'] = self.seq_to_classes[seq_id]['neg_cat_ids'] + raw_data['not_exhaustively_labeled_cls'] = self.seq_to_classes[seq_id]['not_exhaustively_labeled_cat_ids'] + raw_data['seq'] = seq + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids, tracker_confidences]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detections. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + TAO: + In TAO, the 4 preproc steps are as follow: + 1) All classes present in the ground truth data are evaluated separately. + 2) No matched tracker detections are removed. + 3) Unmatched tracker detections are removed if there is not ground truth data and the class does not + belong to the categories marked as negative for this sequence. Additionally, unmatched tracker + detections for classes which are marked as not exhaustively labeled are removed. + 4) No gt detections are removed. + Further, for TrackMAP computation track representations for the given class are accessed from a dictionary + and the tracks from the tracker data are sorted according to the tracker confidence. + """ + cls_id = self.class_name_to_class_id[cls] + is_not_exhaustively_labeled = cls_id in raw_data['not_exhaustively_labeled_cls'] + is_neg_category = cls_id in raw_data['neg_cat_ids'] + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'tracker_confidences', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + unique_gt_ids = [] + unique_tracker_ids = [] + num_gt_dets = 0 + num_tracker_dets = 0 + for t in range(raw_data['num_timesteps']): + + # Only extract relevant dets for this class for preproc and eval (cls) + gt_class_mask = np.atleast_1d(raw_data['gt_classes'][t] == cls_id) + gt_class_mask = gt_class_mask.astype(np.bool) + gt_ids = raw_data['gt_ids'][t][gt_class_mask] + gt_dets = raw_data['gt_dets'][t][gt_class_mask] + + tracker_class_mask = np.atleast_1d(raw_data['tracker_classes'][t] == cls_id) + tracker_class_mask = tracker_class_mask.astype(np.bool) + tracker_ids = raw_data['tracker_ids'][t][tracker_class_mask] + tracker_dets = raw_data['tracker_dets'][t][tracker_class_mask] + tracker_confidences = raw_data['tracker_confidences'][t][tracker_class_mask] + similarity_scores = raw_data['similarity_scores'][t][gt_class_mask, :][:, tracker_class_mask] + + # Match tracker and gt dets (with hungarian algorithm). + unmatched_indices = np.arange(tracker_ids.shape[0]) + if gt_ids.shape[0] > 0 and tracker_ids.shape[0] > 0: + matching_scores = similarity_scores.copy() + matching_scores[matching_scores < 0.5 - np.finfo('float').eps] = 0 + match_rows, match_cols = linear_sum_assignment(-matching_scores) + actually_matched_mask = matching_scores[match_rows, match_cols] > 0 + np.finfo('float').eps + match_cols = match_cols[actually_matched_mask] + unmatched_indices = np.delete(unmatched_indices, match_cols, axis=0) + + if gt_ids.shape[0] == 0 and not is_neg_category: + to_remove_tracker = unmatched_indices + elif is_not_exhaustively_labeled: + to_remove_tracker = unmatched_indices + else: + to_remove_tracker = np.array([], dtype=np.int) + + # remove all unwanted unmatched tracker detections + data['tracker_ids'][t] = np.delete(tracker_ids, to_remove_tracker, axis=0) + data['tracker_dets'][t] = np.delete(tracker_dets, to_remove_tracker, axis=0) + data['tracker_confidences'][t] = np.delete(tracker_confidences, to_remove_tracker, axis=0) + similarity_scores = np.delete(similarity_scores, to_remove_tracker, axis=1) + + data['gt_ids'][t] = gt_ids + data['gt_dets'][t] = gt_dets + data['similarity_scores'][t] = similarity_scores + + unique_gt_ids += list(np.unique(data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(data['tracker_ids'][t])) + num_tracker_dets += len(data['tracker_ids'][t]) + num_gt_dets += len(data['gt_ids'][t]) + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = len(unique_tracker_ids) + data['num_gt_ids'] = len(unique_gt_ids) + data['num_timesteps'] = raw_data['num_timesteps'] + data['seq'] = raw_data['seq'] + + # get track representations + data['gt_tracks'] = raw_data['classes_to_gt_tracks'][cls_id] + data['gt_track_ids'] = raw_data['classes_to_gt_track_ids'][cls_id] + data['gt_track_lengths'] = raw_data['classes_to_gt_track_lengths'][cls_id] + data['gt_track_areas'] = raw_data['classes_to_gt_track_areas'][cls_id] + data['dt_tracks'] = raw_data['classes_to_dt_tracks'][cls_id] + data['dt_track_ids'] = raw_data['classes_to_dt_track_ids'][cls_id] + data['dt_track_lengths'] = raw_data['classes_to_dt_track_lengths'][cls_id] + data['dt_track_areas'] = raw_data['classes_to_dt_track_areas'][cls_id] + data['dt_track_scores'] = raw_data['classes_to_dt_track_scores'][cls_id] + data['not_exhaustively_labeled'] = is_not_exhaustively_labeled + data['iou_type'] = 'bbox' + + # sort tracker data tracks by tracker confidence scores + if data['dt_tracks']: + idx = np.argsort([-score for score in data['dt_track_scores']], kind="mergesort") + data['dt_track_scores'] = [data['dt_track_scores'][i] for i in idx] + data['dt_tracks'] = [data['dt_tracks'][i] for i in idx] + data['dt_track_ids'] = [data['dt_track_ids'][i] for i in idx] + data['dt_track_lengths'] = [data['dt_track_lengths'][i] for i in idx] + data['dt_track_areas'] = [data['dt_track_areas'][i] for i in idx] + # Ensure that ids are unique per timestep. + self._check_unique_ids(data) + + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_box_ious(gt_dets_t, tracker_dets_t) + return similarity_scores + + def _merge_categories(self, annotations): + """ + Merges categories with a merged tag. Adapted from https://github.com/TAO-Dataset + :param annotations: the annotations in which the classes should be merged + :return: None + """ + merge_map = {} + for category in self.gt_data['categories']: + if 'merged' in category: + for to_merge in category['merged']: + merge_map[to_merge['id']] = category['id'] + + for ann in annotations: + ann['category_id'] = merge_map.get(ann['category_id'], ann['category_id']) + + def _compute_vid_mappings(self, annotations): + """ + Computes mappings from Videos to corresponding tracks and images. + :param annotations: the annotations for which the mapping should be generated + :return: the video-to-track-mapping, the video-to-image-mapping + """ + vids_to_tracks = {} + vids_to_imgs = {} + vid_ids = [vid['id'] for vid in self.gt_data['videos']] + + # compute an mapping from image IDs to images + images = {} + for image in self.gt_data['images']: + images[image['id']] = image + + for ann in annotations: + ann["area"] = ann["bbox"][2] * ann["bbox"][3] + + vid = ann["video_id"] + if ann["video_id"] not in vids_to_tracks.keys(): + vids_to_tracks[ann["video_id"]] = list() + if ann["video_id"] not in vids_to_imgs.keys(): + vids_to_imgs[ann["video_id"]] = list() + + # Fill in vids_to_tracks + tid = ann["track_id"] + exist_tids = [track["id"] for track in vids_to_tracks[vid]] + try: + index1 = exist_tids.index(tid) + except ValueError: + index1 = -1 + if tid not in exist_tids: + curr_track = {"id": tid, "category_id": ann['category_id'], + "video_id": vid, "annotations": [ann]} + vids_to_tracks[vid].append(curr_track) + else: + vids_to_tracks[vid][index1]["annotations"].append(ann) + + # Fill in vids_to_imgs + img_id = ann['image_id'] + exist_img_ids = [img["id"] for img in vids_to_imgs[vid]] + try: + index2 = exist_img_ids.index(img_id) + except ValueError: + index2 = -1 + if index2 == -1: + curr_img = {"id": img_id, "annotations": [ann]} + vids_to_imgs[vid].append(curr_img) + else: + vids_to_imgs[vid][index2]["annotations"].append(ann) + + # sort annotations by frame index and compute track area + for vid, tracks in vids_to_tracks.items(): + for track in tracks: + track["annotations"] = sorted( + track['annotations'], + key=lambda x: images[x['image_id']]['frame_index']) + # Computer average area + track["area"] = (sum(x['area'] for x in track['annotations']) / len(track['annotations'])) + + # Ensure all videos are present + for vid_id in vid_ids: + if vid_id not in vids_to_tracks.keys(): + vids_to_tracks[vid_id] = [] + if vid_id not in vids_to_imgs.keys(): + vids_to_imgs[vid_id] = [] + + return vids_to_tracks, vids_to_imgs + + def _compute_image_to_timestep_mappings(self): + """ + Computes a mapping from images to the corresponding timestep in the sequence. + :return: the image-to-timestep-mapping + """ + images = {} + for image in self.gt_data['images']: + images[image['id']] = image + + seq_to_imgs_to_timestep = {vid['id']: dict() for vid in self.gt_data['videos']} + for vid in seq_to_imgs_to_timestep: + curr_imgs = [img['id'] for img in self.videos_to_gt_images[vid]] + curr_imgs = sorted(curr_imgs, key=lambda x: images[x]['frame_index']) + seq_to_imgs_to_timestep[vid] = {curr_imgs[i]: i for i in range(len(curr_imgs))} + + return seq_to_imgs_to_timestep + + def _limit_dets_per_image(self, annotations): + """ + Limits the number of detections for each image to config['MAX_DETECTIONS']. Adapted from + https://github.com/TAO-Dataset/ + :param annotations: the annotations in which the detections should be limited + :return: the annotations with limited detections + """ + max_dets = self.config['MAX_DETECTIONS'] + img_ann = defaultdict(list) + for ann in annotations: + img_ann[ann["image_id"]].append(ann) + + for img_id, _anns in img_ann.items(): + if len(_anns) <= max_dets: + continue + _anns = sorted(_anns, key=lambda x: x["score"], reverse=True) + img_ann[img_id] = _anns[:max_dets] + + return [ann for anns in img_ann.values() for ann in anns] + + def _fill_video_ids_inplace(self, annotations): + """ + Fills in missing video IDs inplace. Adapted from https://github.com/TAO-Dataset/ + :param annotations: the annotations for which the videos IDs should be filled inplace + :return: None + """ + missing_video_id = [x for x in annotations if 'video_id' not in x] + if missing_video_id: + image_id_to_video_id = { + x['id']: x['video_id'] for x in self.gt_data['images'] + } + for x in missing_video_id: + x['video_id'] = image_id_to_video_id[x['image_id']] + + @staticmethod + def _make_track_ids_unique(annotations): + """ + Makes the track IDs unqiue over the whole annotation set. Adapted from https://github.com/TAO-Dataset/ + :param annotations: the annotation set + :return: the number of updated IDs + """ + track_id_videos = {} + track_ids_to_update = set() + max_track_id = 0 + for ann in annotations: + t = ann['track_id'] + if t not in track_id_videos: + track_id_videos[t] = ann['video_id'] + + if ann['video_id'] != track_id_videos[t]: + # Track id is assigned to multiple videos + track_ids_to_update.add(t) + max_track_id = max(max_track_id, t) + + if track_ids_to_update: + print('true') + next_id = itertools.count(max_track_id + 1) + new_track_ids = defaultdict(lambda: next(next_id)) + for ann in annotations: + t = ann['track_id'] + v = ann['video_id'] + if t in track_ids_to_update: + ann['track_id'] = new_track_ids[t, v] + return len(track_ids_to_update) diff --git a/OpenPVSG/models/unitrack/eval/trackeval/datasets/youtube_vis.py b/OpenPVSG/models/unitrack/eval/trackeval/datasets/youtube_vis.py new file mode 100644 index 0000000000000000000000000000000000000000..39ac49a4913b3394bcf81a12b903fa7056150313 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/datasets/youtube_vis.py @@ -0,0 +1,365 @@ +import os +import numpy as np +import json +from ._base_dataset import _BaseDataset +from ..utils import TrackEvalException +from .. import utils +from .. import _timing + + +class YouTubeVIS(_BaseDataset): + """Dataset class for YouTubeVIS tracking""" + + @staticmethod + def get_default_dataset_config(): + """Default class config values""" + code_path = utils.get_code_path() + default_config = { + 'GT_FOLDER': os.path.join(code_path, 'data/gt/youtube_vis/'), # Location of GT data + 'TRACKERS_FOLDER': os.path.join(code_path, 'data/trackers/youtube_vis/'), + # Trackers location + 'OUTPUT_FOLDER': None, # Where to save eval results (if None, same as TRACKERS_FOLDER) + 'TRACKERS_TO_EVAL': None, # Filenames of trackers to eval (if None, all in folder) + 'CLASSES_TO_EVAL': None, # Classes to eval (if None, all classes) + 'SPLIT_TO_EVAL': 'train_sub_split', # Valid: 'train', 'val', 'train_sub_split' + 'PRINT_CONFIG': True, # Whether to print current config + 'OUTPUT_SUB_FOLDER': '', # Output files are saved in OUTPUT_FOLDER/tracker_name/OUTPUT_SUB_FOLDER + 'TRACKER_SUB_FOLDER': 'data', # Tracker files are in TRACKER_FOLDER/tracker_name/TRACKER_SUB_FOLDER + 'TRACKER_DISPLAY_NAMES': None, # Names of trackers to display, if None: TRACKERS_TO_EVAL + } + return default_config + + def __init__(self, config=None): + """Initialise dataset, checking that all required files are present""" + super().__init__() + # Fill non-given config values with defaults + self.config = utils.init_config(config, self.get_default_dataset_config(), self.get_name()) + self.gt_fol = self.config['GT_FOLDER'] + 'youtube_vis_' + self.config['SPLIT_TO_EVAL'] + self.tracker_fol = self.config['TRACKERS_FOLDER'] + self.use_super_categories = False + self.should_classes_combine = True + + self.output_fol = self.config['OUTPUT_FOLDER'] + if self.output_fol is None: + self.output_fol = self.tracker_fol + self.output_sub_fol = self.config['OUTPUT_SUB_FOLDER'] + self.tracker_sub_fol = self.config['TRACKER_SUB_FOLDER'] + + if not os.path.exists(self.gt_fol): + print("GT folder not found: " + self.gt_fol) + raise TrackEvalException("GT folder not found: " + os.path.basename(self.gt_fol)) + gt_dir_files = [file for file in os.listdir(self.gt_fol) if file.endswith('.json')] + if len(gt_dir_files) != 1: + raise TrackEvalException(self.gt_fol + ' does not contain exactly one json file.') + + with open(os.path.join(self.gt_fol, gt_dir_files[0])) as f: + self.gt_data = json.load(f) + + # Get classes to eval + self.valid_classes = [cls['name'] for cls in self.gt_data['categories']] + cls_name_to_cls_id_map = {cls['name']: cls['id'] for cls in self.gt_data['categories']} + + if self.config['CLASSES_TO_EVAL']: + self.class_list = [cls.lower() if cls.lower() in self.valid_classes else None + for cls in self.config['CLASSES_TO_EVAL']] + if not all(self.class_list): + raise TrackEvalException('Attempted to evaluate an invalid class. Only classes ' + + ', '.join(self.valid_classes) + ' are valid.') + else: + self.class_list = [cls['name'] for cls in self.gt_data['categories']] + self.class_name_to_class_id = {k: v for k, v in cls_name_to_cls_id_map.items() if k in self.class_list} + + # Get sequences to eval and check gt files exist + self.seq_list = [vid['file_names'][0].split('/')[0] for vid in self.gt_data['videos']] + self.seq_name_to_seq_id = {vid['file_names'][0].split('/')[0]: vid['id'] for vid in self.gt_data['videos']} + self.seq_lengths = {vid['id']: len(vid['file_names']) for vid in self.gt_data['videos']} + + # encode masks and compute track areas + self._prepare_gt_annotations() + + # Get trackers to eval + if self.config['TRACKERS_TO_EVAL'] is None: + self.tracker_list = os.listdir(self.tracker_fol) + else: + self.tracker_list = self.config['TRACKERS_TO_EVAL'] + + if self.config['TRACKER_DISPLAY_NAMES'] is None: + self.tracker_to_disp = dict(zip(self.tracker_list, self.tracker_list)) + elif (self.config['TRACKERS_TO_EVAL'] is not None) and ( + len(self.config['TRACKER_DISPLAY_NAMES']) == len(self.tracker_list)): + self.tracker_to_disp = dict(zip(self.tracker_list, self.config['TRACKER_DISPLAY_NAMES'])) + else: + raise TrackEvalException('List of tracker files and tracker display names do not match.') + + # counter for globally unique track IDs + self.global_tid_counter = 0 + + self.tracker_data = dict() + for tracker in self.tracker_list: + tracker_dir_path = os.path.join(self.tracker_fol, tracker, self.tracker_sub_fol) + #tr_dir_files = [file for file in os.listdir(tracker_dir_path) if file.endswith('.json')] + tr_dir_files = [tracker+'.json', ] + if len(tr_dir_files) != 1: + raise TrackEvalException(tracker_dir_path + ' does not contain exactly one json file.') + + with open(os.path.join(tracker_dir_path, '..', tr_dir_files[0])) as f: + curr_data = json.load(f) + + self.tracker_data[tracker] = curr_data + + def get_display_name(self, tracker): + return self.tracker_to_disp[tracker] + + def _load_raw_file(self, tracker, seq, is_gt): + """Load a file (gt or tracker) in the YouTubeVIS format + If is_gt, this returns a dict which contains the fields: + [gt_ids, gt_classes] : list (for each timestep) of 1D NDArrays (for each det). + [gt_dets]: list (for each timestep) of lists of detections. + [classes_to_gt_tracks]: dictionary with class values as keys and list of dictionaries (with frame indices as + keys and corresponding segmentations as values) for each track + [classes_to_gt_track_ids, classes_to_gt_track_areas, classes_to_gt_track_iscrowd]: dictionary with class values + as keys and lists (for each track) as values + + if not is_gt, this returns a dict which contains the fields: + [tracker_ids, tracker_classes, tracker_confidences] : list (for each timestep) of 1D NDArrays (for each det). + [tracker_dets]: list (for each timestep) of lists of detections. + [classes_to_dt_tracks]: dictionary with class values as keys and list of dictionaries (with frame indices as + keys and corresponding segmentations as values) for each track + [classes_to_dt_track_ids, classes_to_dt_track_areas]: dictionary with class values as keys and lists as values + [classes_to_dt_track_scores]: dictionary with class values as keys and 1D numpy arrays as values + """ + # select sequence tracks + seq_id = self.seq_name_to_seq_id[seq] + if is_gt: + tracks = [ann for ann in self.gt_data['annotations'] if ann['video_id'] == seq_id] + else: + tracks = self._get_tracker_seq_tracks(tracker, seq_id) + + # Convert data to required format + num_timesteps = self.seq_lengths[seq_id] + data_keys = ['ids', 'classes', 'dets'] + if not is_gt: + data_keys += ['tracker_confidences'] + raw_data = {key: [None] * num_timesteps for key in data_keys} + for t in range(num_timesteps): + raw_data['dets'][t] = [track['segmentations'][t] for track in tracks if track['segmentations'][t]] + raw_data['ids'][t] = np.atleast_1d([track['id'] for track in tracks + if track['segmentations'][t]]).astype(int) + raw_data['classes'][t] = np.atleast_1d([track['category_id'] for track in tracks + if track['segmentations'][t]]).astype(int) + if not is_gt: + raw_data['tracker_confidences'][t] = np.atleast_1d([track['score'] for track in tracks + if track['segmentations'][t]]).astype(float) + + if is_gt: + key_map = {'ids': 'gt_ids', + 'classes': 'gt_classes', + 'dets': 'gt_dets'} + else: + key_map = {'ids': 'tracker_ids', + 'classes': 'tracker_classes', + 'dets': 'tracker_dets'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + + all_cls_ids = {self.class_name_to_class_id[cls] for cls in self.class_list} + classes_to_tracks = {cls: [track for track in tracks if track['category_id'] == cls] for cls in all_cls_ids} + + # mapping from classes to track representations and track information + raw_data['classes_to_tracks'] = {cls: [{i: track['segmentations'][i] + for i in range(len(track['segmentations']))} for track in tracks] + for cls, tracks in classes_to_tracks.items()} + raw_data['classes_to_track_ids'] = {cls: [track['id'] for track in tracks] + for cls, tracks in classes_to_tracks.items()} + raw_data['classes_to_track_areas'] = {cls: [track['area'] for track in tracks] + for cls, tracks in classes_to_tracks.items()} + + if is_gt: + raw_data['classes_to_gt_track_iscrowd'] = {cls: [track['iscrowd'] for track in tracks] + for cls, tracks in classes_to_tracks.items()} + else: + raw_data['classes_to_dt_track_scores'] = {cls: np.array([track['score'] for track in tracks]) + for cls, tracks in classes_to_tracks.items()} + + if is_gt: + key_map = {'classes_to_tracks': 'classes_to_gt_tracks', + 'classes_to_track_ids': 'classes_to_gt_track_ids', + 'classes_to_track_areas': 'classes_to_gt_track_areas'} + else: + key_map = {'classes_to_tracks': 'classes_to_dt_tracks', + 'classes_to_track_ids': 'classes_to_dt_track_ids', + 'classes_to_track_areas': 'classes_to_dt_track_areas'} + for k, v in key_map.items(): + raw_data[v] = raw_data.pop(k) + + raw_data['num_timesteps'] = num_timesteps + raw_data['seq'] = seq + return raw_data + + @_timing.time + def get_preprocessed_seq_data(self, raw_data, cls): + """ Preprocess data for a single sequence for a single class ready for evaluation. + Inputs: + - raw_data is a dict containing the data for the sequence already read in by get_raw_seq_data(). + - cls is the class to be evaluated. + Outputs: + - data is a dict containing all of the information that metrics need to perform evaluation. + It contains the following fields: + [num_timesteps, num_gt_ids, num_tracker_ids, num_gt_dets, num_tracker_dets] : integers. + [gt_ids, tracker_ids, tracker_confidences]: list (for each timestep) of 1D NDArrays (for each det). + [gt_dets, tracker_dets]: list (for each timestep) of lists of detections. + [similarity_scores]: list (for each timestep) of 2D NDArrays. + Notes: + General preprocessing (preproc) occurs in 4 steps. Some datasets may not use all of these steps. + 1) Extract only detections relevant for the class to be evaluated (including distractor detections). + 2) Match gt dets and tracker dets. Remove tracker dets that are matched to a gt det that is of a + distractor class, or otherwise marked as to be removed. + 3) Remove unmatched tracker dets if they fall within a crowd ignore region or don't meet a certain + other criteria (e.g. are too small). + 4) Remove gt dets that were only useful for preprocessing and not for actual evaluation. + After the above preprocessing steps, this function also calculates the number of gt and tracker detections + and unique track ids. It also relabels gt and tracker ids to be contiguous and checks that ids are + unique within each timestep. + YouTubeVIS: + In YouTubeVIS, the 4 preproc steps are as follow: + 1) There are 40 classes which are evaluated separately. + 2) No matched tracker dets are removed. + 3) No unmatched tracker dets are removed. + 4) No gt dets are removed. + Further, for TrackMAP computation track representations for the given class are accessed from a dictionary + and the tracks from the tracker data are sorted according to the tracker confidence. + """ + cls_id = self.class_name_to_class_id[cls] + + data_keys = ['gt_ids', 'tracker_ids', 'gt_dets', 'tracker_dets', 'similarity_scores'] + data = {key: [None] * raw_data['num_timesteps'] for key in data_keys} + unique_gt_ids = [] + unique_tracker_ids = [] + num_gt_dets = 0 + num_tracker_dets = 0 + + for t in range(raw_data['num_timesteps']): + + # Only extract relevant dets for this class for eval (cls) + gt_class_mask = np.atleast_1d(raw_data['gt_classes'][t] == cls_id) + gt_class_mask = gt_class_mask.astype(np.bool) + gt_ids = raw_data['gt_ids'][t][gt_class_mask] + gt_dets = [raw_data['gt_dets'][t][ind] for ind in range(len(gt_class_mask)) if gt_class_mask[ind]] + + tracker_class_mask = np.atleast_1d(raw_data['tracker_classes'][t] == cls_id) + tracker_class_mask = tracker_class_mask.astype(np.bool) + tracker_ids = raw_data['tracker_ids'][t][tracker_class_mask] + tracker_dets = [raw_data['tracker_dets'][t][ind] for ind in range(len(tracker_class_mask)) if + tracker_class_mask[ind]] + similarity_scores = raw_data['similarity_scores'][t][gt_class_mask, :][:, tracker_class_mask] + + data['tracker_ids'][t] = tracker_ids + data['tracker_dets'][t] = tracker_dets + data['gt_ids'][t] = gt_ids + data['gt_dets'][t] = gt_dets + data['similarity_scores'][t] = similarity_scores + + unique_gt_ids += list(np.unique(data['gt_ids'][t])) + unique_tracker_ids += list(np.unique(data['tracker_ids'][t])) + num_tracker_dets += len(data['tracker_ids'][t]) + num_gt_dets += len(data['gt_ids'][t]) + + # Re-label IDs such that there are no empty IDs + if len(unique_gt_ids) > 0: + unique_gt_ids = np.unique(unique_gt_ids) + gt_id_map = np.nan * np.ones((np.max(unique_gt_ids) + 1)) + gt_id_map[unique_gt_ids] = np.arange(len(unique_gt_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['gt_ids'][t]) > 0: + data['gt_ids'][t] = gt_id_map[data['gt_ids'][t]].astype(np.int) + if len(unique_tracker_ids) > 0: + unique_tracker_ids = np.unique(unique_tracker_ids) + tracker_id_map = np.nan * np.ones((np.max(unique_tracker_ids) + 1)) + tracker_id_map[unique_tracker_ids] = np.arange(len(unique_tracker_ids)) + for t in range(raw_data['num_timesteps']): + if len(data['tracker_ids'][t]) > 0: + data['tracker_ids'][t] = tracker_id_map[data['tracker_ids'][t]].astype(np.int) + + # Ensure that ids are unique per timestep. + self._check_unique_ids(data) + + # Record overview statistics. + data['num_tracker_dets'] = num_tracker_dets + data['num_gt_dets'] = num_gt_dets + data['num_tracker_ids'] = len(unique_tracker_ids) + data['num_gt_ids'] = len(unique_gt_ids) + data['num_timesteps'] = raw_data['num_timesteps'] + data['seq'] = raw_data['seq'] + + # get track representations + data['gt_tracks'] = raw_data['classes_to_gt_tracks'][cls_id] + data['gt_track_ids'] = raw_data['classes_to_gt_track_ids'][cls_id] + data['gt_track_areas'] = raw_data['classes_to_gt_track_areas'][cls_id] + data['gt_track_iscrowd'] = raw_data['classes_to_gt_track_iscrowd'][cls_id] + data['dt_tracks'] = raw_data['classes_to_dt_tracks'][cls_id] + data['dt_track_ids'] = raw_data['classes_to_dt_track_ids'][cls_id] + data['dt_track_areas'] = raw_data['classes_to_dt_track_areas'][cls_id] + data['dt_track_scores'] = raw_data['classes_to_dt_track_scores'][cls_id] + data['iou_type'] = 'mask' + + # sort tracker data tracks by tracker confidence scores + if data['dt_tracks']: + idx = np.argsort([-score for score in data['dt_track_scores']], kind="mergesort") + data['dt_track_scores'] = [data['dt_track_scores'][i] for i in idx] + data['dt_tracks'] = [data['dt_tracks'][i] for i in idx] + data['dt_track_ids'] = [data['dt_track_ids'][i] for i in idx] + data['dt_track_areas'] = [data['dt_track_areas'][i] for i in idx] + + return data + + def _calculate_similarities(self, gt_dets_t, tracker_dets_t): + similarity_scores = self._calculate_mask_ious(gt_dets_t, tracker_dets_t, is_encoded=True, do_ioa=False) + return similarity_scores + + def _prepare_gt_annotations(self): + """ + Prepares GT data by rle encoding segmentations and computing the average track area. + :return: None + """ + # only loaded when needed to reduce minimum requirements + from pycocotools import mask as mask_utils + + for track in self.gt_data['annotations']: + h = track['height'] + w = track['width'] + for i, seg in enumerate(track['segmentations']): + if seg: + track['segmentations'][i] = mask_utils.frPyObjects(seg, h, w) + areas = [a for a in track['areas'] if a] + if len(areas) == 0: + track['area'] = 0 + else: + track['area'] = np.array(areas).mean() + + def _get_tracker_seq_tracks(self, tracker, seq_id): + """ + Prepares tracker data for a given sequence. Extracts all annotations for given sequence ID, computes + average track area and assigns a track ID. + :param tracker: the given tracker + :param seq_id: the sequence ID + :return: the extracted tracks + """ + # only loaded when needed to reduce minimum requirements + from pycocotools import mask as mask_utils + + tracks = [ann for ann in self.tracker_data[tracker] if ann['video_id'] == seq_id] + for track in tracks: + track['areas'] = [] + for seg in track['segmentations']: + if seg: + track['areas'].append(mask_utils.area(seg)) + else: + track['areas'].append(None) + areas = [a for a in track['areas'] if a] + if len(areas) == 0: + track['area'] = 0 + else: + track['area'] = np.array(areas).mean() + track['id'] = self.global_tid_counter + self.global_tid_counter += 1 + return tracks diff --git a/OpenPVSG/models/unitrack/eval/trackeval/eval.py b/OpenPVSG/models/unitrack/eval/trackeval/eval.py new file mode 100644 index 0000000000000000000000000000000000000000..a4bef239f9f2dd66cc761b03915ee353be33fc28 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/eval.py @@ -0,0 +1,194 @@ +import time +import traceback +from multiprocessing.pool import Pool +from functools import partial +import os +from . import utils +from .utils import TrackEvalException +from . import _timing +from .metrics import Count + + +class Evaluator: + """Evaluator class for evaluating different metrics for different datasets""" + + @staticmethod + def get_default_eval_config(): + """Returns the default config values for evaluation""" + code_path = utils.get_code_path() + default_config = { + 'USE_PARALLEL': False, + 'NUM_PARALLEL_CORES': 8, + 'BREAK_ON_ERROR': True, # Raises exception and exits with error + 'RETURN_ON_ERROR': False, # if not BREAK_ON_ERROR, then returns from function on error + 'LOG_ON_ERROR': os.path.join(code_path, 'error_log.txt'), # if not None, save any errors into a log file. + + 'PRINT_RESULTS': True, + 'PRINT_ONLY_COMBINED': False, + 'PRINT_CONFIG': True, + 'TIME_PROGRESS': True, + 'DISPLAY_LESS_PROGRESS': True, + + 'OUTPUT_SUMMARY': True, + 'OUTPUT_EMPTY_CLASSES': True, # If False, summary files are not output for classes with no detections + 'OUTPUT_DETAILED': True, + 'PLOT_CURVES': True, + } + return default_config + + def __init__(self, config=None): + """Initialise the evaluator with a config file""" + self.config = utils.init_config(config, self.get_default_eval_config(), 'Eval') + # Only run timing analysis if not run in parallel. + if self.config['TIME_PROGRESS'] and not self.config['USE_PARALLEL']: + _timing.DO_TIMING = True + if self.config['DISPLAY_LESS_PROGRESS']: + _timing.DISPLAY_LESS_PROGRESS = True + + @_timing.time + def evaluate(self, dataset_list, metrics_list): + """Evaluate a set of metrics on a set of datasets""" + config = self.config + metrics_list = metrics_list + [Count()] # Count metrics are always run + metric_names = utils.validate_metrics_list(metrics_list) + dataset_names = [dataset.get_name() for dataset in dataset_list] + output_res = {} + output_msg = {} + + for dataset, dataset_name in zip(dataset_list, dataset_names): + # Get dataset info about what to evaluate + output_res[dataset_name] = {} + output_msg[dataset_name] = {} + tracker_list, seq_list, class_list = dataset.get_eval_info() + print('\nEvaluating %i tracker(s) on %i sequence(s) for %i class(es) on %s dataset using the following ' + 'metrics: %s\n' % (len(tracker_list), len(seq_list), len(class_list), dataset_name, + ', '.join(metric_names))) + + # Evaluate each tracker + for tracker in tracker_list: + # if not config['BREAK_ON_ERROR'] then go to next tracker without breaking + try: + # Evaluate each sequence in parallel or in series. + # returns a nested dict (res), indexed like: res[seq][class][metric_name][sub_metric field] + # e.g. res[seq_0001][pedestrian][hota][DetA] + print('\nEvaluating %s\n' % tracker) + time_start = time.time() + if config['USE_PARALLEL']: + with Pool(config['NUM_PARALLEL_CORES']) as pool: + _eval_sequence = partial(eval_sequence, dataset=dataset, tracker=tracker, + class_list=class_list, metrics_list=metrics_list, + metric_names=metric_names) + results = pool.map(_eval_sequence, seq_list) + res = dict(zip(seq_list, results)) + else: + res = {} + for curr_seq in sorted(seq_list): + res[curr_seq] = eval_sequence(curr_seq, dataset, tracker, class_list, metrics_list, + metric_names) + + # Combine results over all sequences and then over all classes + + # collecting combined cls keys (cls averaged, det averaged, super classes) + combined_cls_keys = [] + res['COMBINED_SEQ'] = {} + # combine sequences for each class + for c_cls in class_list: + res['COMBINED_SEQ'][c_cls] = {} + for metric, metric_name in zip(metrics_list, metric_names): + curr_res = {seq_key: seq_value[c_cls][metric_name] for seq_key, seq_value in res.items() if + seq_key is not 'COMBINED_SEQ'} + res['COMBINED_SEQ'][c_cls][metric_name] = metric.combine_sequences(curr_res) + # combine classes + if dataset.should_classes_combine: + combined_cls_keys += ['cls_comb_cls_av', 'cls_comb_det_av'] + res['COMBINED_SEQ']['cls_comb_cls_av'] = {} + res['COMBINED_SEQ']['cls_comb_det_av'] = {} + for metric, metric_name in zip(metrics_list, metric_names): + cls_res = {cls_key: cls_value[metric_name] for cls_key, cls_value in + res['COMBINED_SEQ'].items() if cls_key not in combined_cls_keys} + res['COMBINED_SEQ']['cls_comb_cls_av'][metric_name] = \ + metric.combine_classes_class_averaged(cls_res) + res['COMBINED_SEQ']['cls_comb_det_av'][metric_name] = \ + metric.combine_classes_det_averaged(cls_res) + # combine classes to super classes + if dataset.use_super_categories: + for cat, sub_cats in dataset.super_categories.items(): + combined_cls_keys.append(cat) + res['COMBINED_SEQ'][cat] = {} + for metric, metric_name in zip(metrics_list, metric_names): + cat_res = {cls_key: cls_value[metric_name] for cls_key, cls_value in + res['COMBINED_SEQ'].items() if cls_key in sub_cats} + res['COMBINED_SEQ'][cat][metric_name] = metric.combine_classes_det_averaged(cat_res) + + # Print and output results in various formats + if config['TIME_PROGRESS']: + print('\nAll sequences for %s finished in %.2f seconds' % (tracker, time.time() - time_start)) + output_fol = dataset.get_output_fol(tracker) + tracker_display_name = dataset.get_display_name(tracker) + for c_cls in res['COMBINED_SEQ'].keys(): # class_list + combined classes if calculated + summaries = [] + details = [] + num_dets = res['COMBINED_SEQ'][c_cls]['Count']['Dets'] + if config['OUTPUT_EMPTY_CLASSES'] or num_dets > 0: + for metric, metric_name in zip(metrics_list, metric_names): + # for combined classes there is no per sequence evaluation + if c_cls in combined_cls_keys: + table_res = {'COMBINED_SEQ': res['COMBINED_SEQ'][c_cls][metric_name]} + else: + table_res = {seq_key: seq_value[c_cls][metric_name] for seq_key, seq_value + in res.items()} + if config['PRINT_RESULTS'] and config['PRINT_ONLY_COMBINED']: + metric.print_table({'COMBINED_SEQ': table_res['COMBINED_SEQ']}, + tracker_display_name, c_cls) + elif config['PRINT_RESULTS']: + metric.print_table(table_res, tracker_display_name, c_cls) + if config['OUTPUT_SUMMARY']: + summaries.append(metric.summary_results(table_res)) + if config['OUTPUT_DETAILED']: + details.append(metric.detailed_results(table_res)) + if config['PLOT_CURVES']: + metric.plot_single_tracker_results(table_res, tracker_display_name, c_cls, + output_fol) + if config['OUTPUT_SUMMARY']: + utils.write_summary_results(summaries, c_cls, output_fol) + if config['OUTPUT_DETAILED']: + utils.write_detailed_results(details, c_cls, output_fol) + + # Output for returning from function + output_res[dataset_name][tracker] = res + output_msg[dataset_name][tracker] = 'Success' + + except Exception as err: + output_res[dataset_name][tracker] = None + if type(err) == TrackEvalException: + output_msg[dataset_name][tracker] = str(err) + else: + output_msg[dataset_name][tracker] = 'Unknown error occurred.' + print('Tracker %s was unable to be evaluated.' % tracker) + print(err) + traceback.print_exc() + if config['LOG_ON_ERROR'] is not None: + with open(config['LOG_ON_ERROR'], 'a') as f: + print(dataset_name, file=f) + print(tracker, file=f) + print(traceback.format_exc(), file=f) + print('\n\n\n', file=f) + if config['BREAK_ON_ERROR']: + raise err + elif config['RETURN_ON_ERROR']: + return output_res, output_msg + + return output_res, output_msg + + +@_timing.time +def eval_sequence(seq, dataset, tracker, class_list, metrics_list, metric_names): + """Function for evaluating a single sequence""" + raw_data = dataset.get_raw_seq_data(tracker, seq) + seq_res = {} + for cls in class_list: + seq_res[cls] = {} + data = dataset.get_preprocessed_seq_data(raw_data, cls) + for metric, met_name in zip(metrics_list, metric_names): + seq_res[cls][met_name] = metric.eval_sequence(data) + return seq_res diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/__init__.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cdc02a0d9ac542120388b802be4fc81398820fa7 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/__init__.py @@ -0,0 +1,7 @@ +from .hota import HOTA +from .clear import CLEAR +from .identity import Identity +from .count import Count +from .j_and_f import JAndF +from .track_map import TrackMAP +from .vace import VACE diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/_base_metric.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/_base_metric.py new file mode 100644 index 0000000000000000000000000000000000000000..5e49a7093617caf7061f65188c076832f74e62f7 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/_base_metric.py @@ -0,0 +1,133 @@ + +import numpy as np +from abc import ABC, abstractmethod +from .. import _timing +from ..utils import TrackEvalException + + +class _BaseMetric(ABC): + @abstractmethod + def __init__(self): + self.plottable = False + self.integer_fields = [] + self.float_fields = [] + self.array_labels = [] + self.integer_array_fields = [] + self.float_array_fields = [] + self.fields = [] + self.summary_fields = [] + self.registered = False + + ##################################################################### + # Abstract functions for subclasses to implement + + @_timing.time + @abstractmethod + def eval_sequence(self, data): + ... + + @abstractmethod + def combine_sequences(self, all_res): + ... + + @abstractmethod + def combine_classes_class_averaged(self, all_res): + ... + + @ abstractmethod + def combine_classes_det_averaged(self, all_res): + ... + + def plot_single_tracker_results(self, all_res, tracker, output_folder, cls): + """Plot results of metrics, only valid for metrics with self.plottable""" + if self.plottable: + raise NotImplementedError('plot_results is not implemented for metric %s' % self.get_name()) + else: + pass + + ##################################################################### + # Helper functions which are useful for all metrics: + + @classmethod + def get_name(cls): + return cls.__name__ + + @staticmethod + def _combine_sum(all_res, field): + """Combine sequence results via sum""" + return sum([all_res[k][field] for k in all_res.keys()]) + + @staticmethod + def _combine_weighted_av(all_res, field, comb_res, weight_field): + """Combine sequence results via weighted average""" + return sum([all_res[k][field] * all_res[k][weight_field] for k in all_res.keys()]) / np.maximum(1.0, comb_res[ + weight_field]) + + def print_table(self, table_res, tracker, cls): + """Prints table of results for all sequences""" + print('') + metric_name = self.get_name() + self._row_print([metric_name + ': ' + tracker + '-' + cls] + self.summary_fields) + for seq, results in sorted(table_res.items()): + if seq == 'COMBINED_SEQ': + continue + summary_res = self._summary_row(results) + self._row_print([seq] + summary_res) + summary_res = self._summary_row(table_res['COMBINED_SEQ']) + self._row_print(['COMBINED'] + summary_res) + + def _summary_row(self, results_): + vals = [] + for h in self.summary_fields: + if h in self.float_array_fields: + vals.append("{0:1.5g}".format(100 * np.mean(results_[h]))) + elif h in self.float_fields: + vals.append("{0:1.5g}".format(100 * float(results_[h]))) + elif h in self.integer_fields: + vals.append("{0:d}".format(int(results_[h]))) + else: + raise NotImplementedError("Summary function not implemented for this field type.") + return vals + + @staticmethod + def _row_print(*argv): + """Prints results in an evenly spaced rows, with more space in first row""" + if len(argv) == 1: + argv = argv[0] + to_print = '%-35s' % argv[0] + for v in argv[1:]: + to_print += '%-10s' % str(v) + print(to_print) + + def summary_results(self, table_res): + """Returns a simple summary of final results for a tracker""" + return dict(zip(self.summary_fields, self._summary_row(table_res['COMBINED_SEQ']))) + + def detailed_results(self, table_res): + """Returns detailed final results for a tracker""" + # Get detailed field information + detailed_fields = self.float_fields + self.integer_fields + for h in self.float_array_fields + self.integer_array_fields: + for alpha in [int(100*x) for x in self.array_labels]: + detailed_fields.append(h + '___' + str(alpha)) + detailed_fields.append(h + '___AUC') + + # Get detailed results + detailed_results = {} + for seq, res in table_res.items(): + detailed_row = self._detailed_row(res) + if len(detailed_row) != len(detailed_fields): + raise TrackEvalException( + 'Field names and data have different sizes (%i and %i)' % (len(detailed_row), len(detailed_fields))) + detailed_results[seq] = dict(zip(detailed_fields, detailed_row)) + return detailed_results + + def _detailed_row(self, res): + detailed_row = [] + for h in self.float_fields + self.integer_fields: + detailed_row.append(res[h]) + for h in self.float_array_fields + self.integer_array_fields: + for i, alpha in enumerate([int(100 * x) for x in self.array_labels]): + detailed_row.append(res[h][i]) + detailed_row.append(np.mean(res[h])) + return detailed_row diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/clear.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/clear.py new file mode 100644 index 0000000000000000000000000000000000000000..990a5af16a31b35924d63d495246f2a4f56b700c --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/clear.py @@ -0,0 +1,165 @@ + +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_metric import _BaseMetric +from .. import _timing + + +class CLEAR(_BaseMetric): + """Class which implements the CLEAR metrics""" + def __init__(self): + super().__init__() + main_integer_fields = ['CLR_TP', 'CLR_FN', 'CLR_FP', 'IDSW', 'MT', 'PT', 'ML', 'Frag'] + extra_integer_fields = ['CLR_Frames'] + self.integer_fields = main_integer_fields + extra_integer_fields + main_float_fields = ['MOTA', 'MOTP', 'MODA', 'CLR_Re', 'CLR_Pr', 'MTR', 'PTR', 'MLR', 'sMOTA'] + extra_float_fields = ['CLR_F1', 'FP_per_frame', 'MOTAL', 'MOTP_sum'] + self.float_fields = main_float_fields + extra_float_fields + self.fields = self.float_fields + self.integer_fields + self.summed_fields = self.integer_fields + ['MOTP_sum'] + self.summary_fields = main_float_fields + main_integer_fields + + self.threshold = 0.5 + + @_timing.time + def eval_sequence(self, data): + """Calculates CLEAR metrics for one sequence""" + # Initialise results + res = {} + for field in self.fields: + res[field] = 0 + + # Return result quickly if tracker or gt sequence is empty + if data['num_tracker_dets'] == 0: + res['CLR_FN'] = data['num_gt_dets'] + res['ML'] = data['num_gt_ids'] + res['MLR'] = 1.0 + return res + if data['num_gt_dets'] == 0: + res['CLR_FP'] = data['num_tracker_dets'] + res['MLR'] = 1.0 + return res + + # Variables counting global association + num_gt_ids = data['num_gt_ids'] + gt_id_count = np.zeros(num_gt_ids) # For MT/ML/PT + gt_matched_count = np.zeros(num_gt_ids) # For MT/ML/PT + gt_frag_count = np.zeros(num_gt_ids) # For Frag + + # Note that IDSWs are counted based on the last time each gt_id was present (any number of frames previously), + # but are only used in matching to continue current tracks based on the gt_id in the single previous timestep. + prev_tracker_id = np.nan * np.zeros(num_gt_ids) # For scoring IDSW + prev_timestep_tracker_id = np.nan * np.zeros(num_gt_ids) # For matching IDSW + + # Calculate scores for each timestep + for t, (gt_ids_t, tracker_ids_t) in enumerate(zip(data['gt_ids'], data['tracker_ids'])): + # Deal with the case that there are no gt_det/tracker_det in a timestep. + if len(gt_ids_t) == 0: + res['CLR_FP'] += len(tracker_ids_t) + continue + if len(tracker_ids_t) == 0: + res['CLR_FN'] += len(gt_ids_t) + gt_id_count[gt_ids_t] += 1 + continue + + # Calc score matrix to first minimise IDSWs from previous frame, and then maximise MOTP secondarily + similarity = data['similarity_scores'][t] + score_mat = (tracker_ids_t[np.newaxis, :] == prev_timestep_tracker_id[gt_ids_t[:, np.newaxis]]) + score_mat = 1000 * score_mat + similarity + score_mat[similarity < self.threshold - np.finfo('float').eps] = 0 + + # Hungarian algorithm to find best matches + match_rows, match_cols = linear_sum_assignment(-score_mat) + actually_matched_mask = score_mat[match_rows, match_cols] > 0 + np.finfo('float').eps + match_rows = match_rows[actually_matched_mask] + match_cols = match_cols[actually_matched_mask] + + matched_gt_ids = gt_ids_t[match_rows] + matched_tracker_ids = tracker_ids_t[match_cols] + + # Calc IDSW for MOTA + prev_matched_tracker_ids = prev_tracker_id[matched_gt_ids] + is_idsw = (np.logical_not(np.isnan(prev_matched_tracker_ids))) & ( + np.not_equal(matched_tracker_ids, prev_matched_tracker_ids)) + res['IDSW'] += np.sum(is_idsw) + + # Update counters for MT/ML/PT/Frag and record for IDSW/Frag for next timestep + gt_id_count[gt_ids_t] += 1 + gt_matched_count[matched_gt_ids] += 1 + not_previously_tracked = np.isnan(prev_timestep_tracker_id) + prev_tracker_id[matched_gt_ids] = matched_tracker_ids + prev_timestep_tracker_id[:] = np.nan + prev_timestep_tracker_id[matched_gt_ids] = matched_tracker_ids + currently_tracked = np.logical_not(np.isnan(prev_timestep_tracker_id)) + gt_frag_count += np.logical_and(not_previously_tracked, currently_tracked) + + # Calculate and accumulate basic statistics + num_matches = len(matched_gt_ids) + res['CLR_TP'] += num_matches + res['CLR_FN'] += len(gt_ids_t) - num_matches + res['CLR_FP'] += len(tracker_ids_t) - num_matches + if num_matches > 0: + res['MOTP_sum'] += sum(similarity[match_rows, match_cols]) + + # Calculate MT/ML/PT/Frag/MOTP + tracked_ratio = gt_matched_count[gt_id_count > 0] / gt_id_count[gt_id_count > 0] + res['MT'] = np.sum(np.greater(tracked_ratio, 0.8)) + res['PT'] = np.sum(np.greater_equal(tracked_ratio, 0.2)) - res['MT'] + res['ML'] = num_gt_ids - res['MT'] - res['PT'] + res['Frag'] = np.sum(np.subtract(gt_frag_count[gt_frag_count > 0], 1)) + res['MOTP'] = res['MOTP_sum'] / np.maximum(1.0, res['CLR_TP']) + + res['CLR_Frames'] = data['num_timesteps'] + + # Calculate final CLEAR scores + res = self._compute_final_fields(res) + return res + + def combine_sequences(self, all_res): + """Combines metrics across all sequences""" + res = {} + for field in self.summed_fields: + res[field] = self._combine_sum(all_res, field) + res = self._compute_final_fields(res) + return res + + def combine_classes_det_averaged(self, all_res): + """Combines metrics across all classes by averaging over the detection values""" + res = {} + for field in self.summed_fields: + res[field] = self._combine_sum(all_res, field) + res = self._compute_final_fields(res) + return res + + def combine_classes_class_averaged(self, all_res): + """Combines metrics across all classes by averaging over the class values""" + res = {} + for field in self.integer_fields: + res[field] = self._combine_sum( + {k: v for k, v in all_res.items() if v['CLR_TP'] + v['CLR_FN'] + v['CLR_FP'] > 0}, field) + for field in self.float_fields: + res[field] = np.mean( + [v[field] for v in all_res.values() if v['CLR_TP'] + v['CLR_FN'] + v['CLR_FP'] > 0], axis=0) + return res + + @staticmethod + def _compute_final_fields(res): + """Calculate sub-metric ('field') values which only depend on other sub-metric values. + This function is used both for both per-sequence calculation, and in combining values across sequences. + """ + num_gt_ids = res['MT'] + res['ML'] + res['PT'] + res['MTR'] = res['MT'] / np.maximum(1.0, num_gt_ids) + res['MLR'] = res['ML'] / np.maximum(1.0, num_gt_ids) + res['PTR'] = res['PT'] / np.maximum(1.0, num_gt_ids) + res['CLR_Re'] = res['CLR_TP'] / np.maximum(1.0, res['CLR_TP'] + res['CLR_FN']) + res['CLR_Pr'] = res['CLR_TP'] / np.maximum(1.0, res['CLR_TP'] + res['CLR_FP']) + res['MODA'] = (res['CLR_TP'] - res['CLR_FP']) / np.maximum(1.0, res['CLR_TP'] + res['CLR_FN']) + res['MOTA'] = (res['CLR_TP'] - res['CLR_FP'] - res['IDSW']) / np.maximum(1.0, res['CLR_TP'] + res['CLR_FN']) + res['MOTP'] = res['MOTP_sum'] / np.maximum(1.0, res['CLR_TP']) + res['sMOTA'] = (res['MOTP_sum'] - res['CLR_FP'] - res['IDSW']) / np.maximum(1.0, res['CLR_TP'] + res['CLR_FN']) + + res['CLR_F1'] = res['CLR_TP'] / np.maximum(1.0, res['CLR_TP'] + 0.5*res['CLR_FN'] + 0.5*res['CLR_FP']) + res['FP_per_frame'] = res['CLR_FP'] / np.maximum(1.0, res['CLR_Frames']) + safe_log_idsw = np.log10(res['IDSW']) if res['IDSW'] > 0 else res['IDSW'] + res['MOTAL'] = (res['CLR_TP'] - res['CLR_FP'] - safe_log_idsw) / np.maximum(1.0, res['CLR_TP'] + res['CLR_FN']) + return res diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/count.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/count.py new file mode 100644 index 0000000000000000000000000000000000000000..398b497c10cf81344d6b498336ab126010618dfa --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/count.py @@ -0,0 +1,44 @@ + +from ._base_metric import _BaseMetric +from .. import _timing + + +class Count(_BaseMetric): + """Class which simply counts the number of tracker and gt detections and ids.""" + def __init__(self): + super().__init__() + self.integer_fields = ['Dets', 'GT_Dets', 'IDs', 'GT_IDs'] + self.fields = self.integer_fields + self.summary_fields = self.fields + + @_timing.time + def eval_sequence(self, data): + """Returns counts for one sequence""" + # Get results + res = {'Dets': data['num_tracker_dets'], + 'GT_Dets': data['num_gt_dets'], + 'IDs': data['num_tracker_ids'], + 'GT_IDs': data['num_gt_ids'], + 'Frames': data['num_timesteps']} + return res + + def combine_sequences(self, all_res): + """Combines metrics across all sequences""" + res = {} + for field in self.integer_fields: + res[field] = self._combine_sum(all_res, field) + return res + + def combine_classes_class_averaged(self, all_res): + """Combines metrics across all classes by averaging over the class values""" + res = {} + for field in self.integer_fields: + res[field] = self._combine_sum(all_res, field) + return res + + def combine_classes_det_averaged(self, all_res): + """Combines metrics across all classes by averaging over the detection values""" + res = {} + for field in self.integer_fields: + res[field] = self._combine_sum(all_res, field) + return res diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/hota.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/hota.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c500c0caa0271e251fe039d3949f7660b93c72 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/hota.py @@ -0,0 +1,197 @@ + +import os +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_metric import _BaseMetric +from .. import _timing + + +class HOTA(_BaseMetric): + """Class which implements the HOTA metrics. + See: https://link.springer.com/article/10.1007/s11263-020-01375-2 + """ + def __init__(self): + super().__init__() + self.plottable = True + self.array_labels = np.arange(0.05, 0.99, 0.05) + self.integer_array_fields = ['HOTA_TP', 'HOTA_FN', 'HOTA_FP'] + self.float_array_fields = ['HOTA', 'DetA', 'AssA', 'DetRe', 'DetPr', 'AssRe', 'AssPr', 'LocA', 'RHOTA'] + self.float_fields = ['HOTA(0)', 'LocA(0)', 'HOTALocA(0)'] + self.fields = self.float_array_fields + self.integer_array_fields + self.float_fields + self.summary_fields = self.float_array_fields + self.float_fields + + @_timing.time + def eval_sequence(self, data): + """Calculates the HOTA metrics for one sequence""" + + # Initialise results + res = {} + for field in self.float_array_fields + self.integer_array_fields: + res[field] = np.zeros((len(self.array_labels)), dtype=np.float) + for field in self.float_fields: + res[field] = 0 + + # Return result quickly if tracker or gt sequence is empty + if data['num_tracker_dets'] == 0: + res['HOTA_FN'] = data['num_gt_dets'] * np.ones((len(self.array_labels)), dtype=np.float) + res['LocA'] = np.ones((len(self.array_labels)), dtype=np.float) + res['LocA(0)'] = 1.0 + return res + if data['num_gt_dets'] == 0: + res['HOTA_FP'] = data['num_tracker_dets'] * np.ones((len(self.array_labels)), dtype=np.float) + res['LocA'] = np.ones((len(self.array_labels)), dtype=np.float) + res['LocA(0)'] = 1.0 + return res + + # Variables counting global association + potential_matches_count = np.zeros((data['num_gt_ids'], data['num_tracker_ids'])) + gt_id_count = np.zeros((data['num_gt_ids'], 1)) + tracker_id_count = np.zeros((1, data['num_tracker_ids'])) + + # First loop through each timestep and accumulate global track information. + for t, (gt_ids_t, tracker_ids_t) in enumerate(zip(data['gt_ids'], data['tracker_ids'])): + # Count the potential matches between ids in each timestep + # These are normalised, weighted by the match similarity. + similarity = data['similarity_scores'][t] + sim_iou_denom = similarity.sum(0)[np.newaxis, :] + similarity.sum(1)[:, np.newaxis] - similarity + sim_iou = np.zeros_like(similarity) + sim_iou_mask = sim_iou_denom > 0 + np.finfo('float').eps + sim_iou[sim_iou_mask] = similarity[sim_iou_mask] / sim_iou_denom[sim_iou_mask] + potential_matches_count[gt_ids_t[:, np.newaxis], tracker_ids_t[np.newaxis, :]] += sim_iou + + # Calculate the total number of dets for each gt_id and tracker_id. + gt_id_count[gt_ids_t] += 1 + tracker_id_count[0, tracker_ids_t] += 1 + + # Calculate overall jaccard alignment score (before unique matching) between IDs + global_alignment_score = potential_matches_count / (gt_id_count + tracker_id_count - potential_matches_count) + matches_counts = [np.zeros_like(potential_matches_count) for _ in self.array_labels] + + # Calculate scores for each timestep + for t, (gt_ids_t, tracker_ids_t) in enumerate(zip(data['gt_ids'], data['tracker_ids'])): + # Deal with the case that there are no gt_det/tracker_det in a timestep. + if len(gt_ids_t) == 0: + for a, alpha in enumerate(self.array_labels): + res['HOTA_FP'][a] += len(tracker_ids_t) + continue + if len(tracker_ids_t) == 0: + for a, alpha in enumerate(self.array_labels): + res['HOTA_FN'][a] += len(gt_ids_t) + continue + + # Get matching scores between pairs of dets for optimizing HOTA + similarity = data['similarity_scores'][t] + score_mat = global_alignment_score[gt_ids_t[:, np.newaxis], tracker_ids_t[np.newaxis, :]] * similarity + + # Hungarian algorithm to find best matches + match_rows, match_cols = linear_sum_assignment(-score_mat) + + # Calculate and accumulate basic statistics + for a, alpha in enumerate(self.array_labels): + actually_matched_mask = similarity[match_rows, match_cols] >= alpha - np.finfo('float').eps + alpha_match_rows = match_rows[actually_matched_mask] + alpha_match_cols = match_cols[actually_matched_mask] + num_matches = len(alpha_match_rows) + res['HOTA_TP'][a] += num_matches + res['HOTA_FN'][a] += len(gt_ids_t) - num_matches + res['HOTA_FP'][a] += len(tracker_ids_t) - num_matches + if num_matches > 0: + res['LocA'][a] += sum(similarity[alpha_match_rows, alpha_match_cols]) + matches_counts[a][gt_ids_t[alpha_match_rows], tracker_ids_t[alpha_match_cols]] += 1 + + # Calculate association scores (AssA, AssRe, AssPr) for the alpha value. + # First calculate scores per gt_id/tracker_id combo and then average over the number of detections. + for a, alpha in enumerate(self.array_labels): + matches_count = matches_counts[a] + ass_a = matches_count / np.maximum(1, gt_id_count + tracker_id_count - matches_count) + res['AssA'][a] = np.sum(matches_count * ass_a) / np.maximum(1, res['HOTA_TP'][a]) + ass_re = matches_count / np.maximum(1, gt_id_count) + res['AssRe'][a] = np.sum(matches_count * ass_re) / np.maximum(1, res['HOTA_TP'][a]) + ass_pr = matches_count / np.maximum(1, tracker_id_count) + res['AssPr'][a] = np.sum(matches_count * ass_pr) / np.maximum(1, res['HOTA_TP'][a]) + + # Calculate final scores + res['LocA'] = np.maximum(1e-10, res['LocA']) / np.maximum(1e-10, res['HOTA_TP']) + res = self._compute_final_fields(res) + return res + + def combine_sequences(self, all_res): + """Combines metrics across all sequences""" + res = {} + for field in self.integer_array_fields: + res[field] = self._combine_sum(all_res, field) + for field in ['AssRe', 'AssPr', 'AssA']: + res[field] = self._combine_weighted_av(all_res, field, res, weight_field='HOTA_TP') + loca_weighted_sum = sum([all_res[k]['LocA'] * all_res[k]['HOTA_TP'] for k in all_res.keys()]) + res['LocA'] = np.maximum(1e-10, loca_weighted_sum) / np.maximum(1e-10, res['HOTA_TP']) + res = self._compute_final_fields(res) + return res + + def combine_classes_class_averaged(self, all_res): + """Combines metrics across all classes by averaging over the class values""" + res = {} + for field in self.integer_array_fields: + res[field] = self._combine_sum( + {k: v for k, v in all_res.items() + if (v['HOTA_TP'] + v['HOTA_FN'] + v['HOTA_FP'] > 0 + np.finfo('float').eps).any()}, field) + for field in self.float_fields: + res[field] = np.mean([v[field] for v in all_res.values() + if (v['HOTA_TP'] + v['HOTA_FN'] + v['HOTA_FP'] > 0 + np.finfo('float').eps).any()], + axis=0) + for field in self.float_array_fields: + res[field] = np.mean([v[field] for v in all_res.values() + if (v['HOTA_TP'] + v['HOTA_FN'] + v['HOTA_FP'] > 0 + np.finfo('float').eps).any()], + axis=0) + return res + + def combine_classes_det_averaged(self, all_res): + """Combines metrics across all classes by averaging over the detection values""" + res = {} + for field in self.integer_array_fields: + res[field] = self._combine_sum(all_res, field) + for field in ['AssRe', 'AssPr', 'AssA']: + res[field] = self._combine_weighted_av(all_res, field, res, weight_field='HOTA_TP') + loca_weighted_sum = sum([all_res[k]['LocA'] * all_res[k]['HOTA_TP'] for k in all_res.keys()]) + res['LocA'] = np.maximum(1e-10, loca_weighted_sum) / np.maximum(1e-10, res['HOTA_TP']) + res = self._compute_final_fields(res) + return res + + @staticmethod + def _compute_final_fields(res): + """Calculate sub-metric ('field') values which only depend on other sub-metric values. + This function is used both for both per-sequence calculation, and in combining values across sequences. + """ + res['DetRe'] = res['HOTA_TP'] / np.maximum(1, res['HOTA_TP'] + res['HOTA_FN']) + res['DetPr'] = res['HOTA_TP'] / np.maximum(1, res['HOTA_TP'] + res['HOTA_FP']) + res['DetA'] = res['HOTA_TP'] / np.maximum(1, res['HOTA_TP'] + res['HOTA_FN'] + res['HOTA_FP']) + res['HOTA'] = np.sqrt(res['DetA'] * res['AssA']) + res['RHOTA'] = np.sqrt(res['DetRe'] * res['AssA']) + + res['HOTA(0)'] = res['HOTA'][0] + res['LocA(0)'] = res['LocA'][0] + res['HOTALocA(0)'] = res['HOTA(0)']*res['LocA(0)'] + return res + + def plot_single_tracker_results(self, table_res, tracker, cls, output_folder): + """Create plot of results""" + + # Only loaded when run to reduce minimum requirements + from matplotlib import pyplot as plt + + res = table_res['COMBINED_SEQ'] + styles_to_plot = ['r', 'b', 'g', 'b--', 'b:', 'g--', 'g:', 'm'] + for name, style in zip(self.float_array_fields, styles_to_plot): + plt.plot(self.array_labels, res[name], style) + plt.xlabel('alpha') + plt.ylabel('score') + plt.title(tracker + ' - ' + cls) + plt.axis([0, 1, 0, 1]) + legend = [] + for name in self.float_array_fields: + legend += [name + ' (' + str(np.round(np.mean(res[name]), 2)) + ')'] + plt.legend(legend, loc='lower left') + out_file = os.path.join(output_folder, cls + '_plot.pdf') + os.makedirs(os.path.dirname(out_file), exist_ok=True) + plt.savefig(out_file) + plt.savefig(out_file.replace('.pdf', '.png')) + plt.clf() diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/identity.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/identity.py new file mode 100644 index 0000000000000000000000000000000000000000..d5086a520fa89f1407ffba5b9ed5b0cc89243a44 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/identity.py @@ -0,0 +1,114 @@ + +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_metric import _BaseMetric +from .. import _timing + + +class Identity(_BaseMetric): + """Class which implements the ID metrics""" + def __init__(self): + super().__init__() + self.integer_fields = ['IDTP', 'IDFN', 'IDFP'] + self.float_fields = ['IDF1', 'IDR', 'IDP'] + self.fields = self.float_fields + self.integer_fields + self.summary_fields = self.fields + + self.threshold = 0.5 + + @_timing.time + def eval_sequence(self, data): + """Calculates ID metrics for one sequence""" + # Initialise results + res = {} + for field in self.fields: + res[field] = 0 + + # Return result quickly if tracker or gt sequence is empty + if data['num_tracker_dets'] == 0: + res['IDFN'] = data['num_gt_dets'] + return res + if data['num_gt_dets'] == 0: + res['IDFP'] = data['num_tracker_dets'] + return res + + # Variables counting global association + potential_matches_count = np.zeros((data['num_gt_ids'], data['num_tracker_ids'])) + gt_id_count = np.zeros(data['num_gt_ids']) + tracker_id_count = np.zeros(data['num_tracker_ids']) + + # First loop through each timestep and accumulate global track information. + for t, (gt_ids_t, tracker_ids_t) in enumerate(zip(data['gt_ids'], data['tracker_ids'])): + # Count the potential matches between ids in each timestep + matches_mask = np.greater_equal(data['similarity_scores'][t], self.threshold) + match_idx_gt, match_idx_tracker = np.nonzero(matches_mask) + potential_matches_count[gt_ids_t[match_idx_gt], tracker_ids_t[match_idx_tracker]] += 1 + + # Calculate the total number of dets for each gt_id and tracker_id. + gt_id_count[gt_ids_t] += 1 + tracker_id_count[tracker_ids_t] += 1 + + # Calculate optimal assignment cost matrix for ID metrics + num_gt_ids = data['num_gt_ids'] + num_tracker_ids = data['num_tracker_ids'] + fp_mat = np.zeros((num_gt_ids + num_tracker_ids, num_gt_ids + num_tracker_ids)) + fn_mat = np.zeros((num_gt_ids + num_tracker_ids, num_gt_ids + num_tracker_ids)) + fp_mat[num_gt_ids:, :num_tracker_ids] = 1e10 + fn_mat[:num_gt_ids, num_tracker_ids:] = 1e10 + for gt_id in range(num_gt_ids): + fn_mat[gt_id, :num_tracker_ids] = gt_id_count[gt_id] + fn_mat[gt_id, num_tracker_ids + gt_id] = gt_id_count[gt_id] + for tracker_id in range(num_tracker_ids): + fp_mat[:num_gt_ids, tracker_id] = tracker_id_count[tracker_id] + fp_mat[tracker_id + num_gt_ids, tracker_id] = tracker_id_count[tracker_id] + fn_mat[:num_gt_ids, :num_tracker_ids] -= potential_matches_count + fp_mat[:num_gt_ids, :num_tracker_ids] -= potential_matches_count + + # Hungarian algorithm + match_rows, match_cols = linear_sum_assignment(fn_mat + fp_mat) + + # Accumulate basic statistics + res['IDFN'] = fn_mat[match_rows, match_cols].sum().astype(np.int) + res['IDFP'] = fp_mat[match_rows, match_cols].sum().astype(np.int) + res['IDTP'] = (gt_id_count.sum() - res['IDFN']).astype(np.int) + + # Calculate final ID scores + res = self._compute_final_fields(res) + return res + + def combine_classes_class_averaged(self, all_res): + """Combines metrics across all classes by averaging over the class values""" + res = {} + for field in self.integer_fields: + res[field] = self._combine_sum({k: v for k, v in all_res.items() + if v['IDTP'] + v['IDFN'] + v['IDFP'] > 0 + np.finfo('float').eps}, field) + for field in self.float_fields: + res[field] = np.mean([v[field] for v in all_res.values() + if v['IDTP'] + v['IDFN'] + v['IDFP'] > 0 + np.finfo('float').eps], axis=0) + return res + + def combine_classes_det_averaged(self, all_res): + """Combines metrics across all classes by averaging over the detection values""" + res = {} + for field in self.integer_fields: + res[field] = self._combine_sum(all_res, field) + res = self._compute_final_fields(res) + return res + + def combine_sequences(self, all_res): + """Combines metrics across all sequences""" + res = {} + for field in self.integer_fields: + res[field] = self._combine_sum(all_res, field) + res = self._compute_final_fields(res) + return res + + @staticmethod + def _compute_final_fields(res): + """Calculate sub-metric ('field') values which only depend on other sub-metric values. + This function is used both for both per-sequence calculation, and in combining values across sequences. + """ + res['IDR'] = res['IDTP'] / np.maximum(1.0, res['IDTP'] + res['IDFN']) + res['IDP'] = res['IDTP'] / np.maximum(1.0, res['IDTP'] + res['IDFP']) + res['IDF1'] = res['IDTP'] / np.maximum(1.0, res['IDTP'] + 0.5*res['IDFP'] + 0.5*res['IDFN']) + return res diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/j_and_f.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/j_and_f.py new file mode 100644 index 0000000000000000000000000000000000000000..eeec16061248b7f684149ca4555fd03051e0ab26 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/j_and_f.py @@ -0,0 +1,307 @@ + +import numpy as np +import math +from scipy.optimize import linear_sum_assignment +from ..utils import TrackEvalException +from ._base_metric import _BaseMetric +from .. import _timing + + +class JAndF(_BaseMetric): + """Class which implements the J&F metrics""" + def __init__(self): + super().__init__() + self.integer_fields = ['num_gt_tracks'] + self.float_fields = ['J-Mean', 'J-Recall', 'J-Decay', 'F-Mean', 'F-Recall', 'F-Decay', 'J&F'] + self.fields = self.float_fields + self.integer_fields + self.summary_fields = self.float_fields + self.optim_type = 'J' # possible values J, J&F + + @_timing.time + def eval_sequence(self, data): + """Returns J&F metrics for one sequence""" + + # Only loaded when run to reduce minimum requirements + from pycocotools import mask as mask_utils + + num_timesteps = data['num_timesteps'] + num_tracker_ids = data['num_tracker_ids'] + num_gt_ids = data['num_gt_ids'] + gt_dets = data['gt_dets'] + tracker_dets = data['tracker_dets'] + gt_ids = data['gt_ids'] + tracker_ids = data['tracker_ids'] + + # get shape of frames + frame_shape = None + if num_gt_ids > 0: + for t in range(num_timesteps): + if len(gt_ids[t]) > 0: + frame_shape = gt_dets[t][0]['size'] + break + elif num_tracker_ids > 0: + for t in range(num_timesteps): + if len(tracker_ids[t]) > 0: + frame_shape = tracker_dets[t][0]['size'] + break + + if frame_shape: + # append all zero masks for timesteps in which tracks do not have a detection + zero_padding = np.zeros((frame_shape), order= 'F').astype(np.uint8) + padding_mask = mask_utils.encode(zero_padding) + for t in range(num_timesteps): + gt_id_det_mapping = {gt_ids[t][i]: gt_dets[t][i] for i in range(len(gt_ids[t]))} + gt_dets[t] = [gt_id_det_mapping[index] if index in gt_ids[t] else padding_mask for index + in range(num_gt_ids)] + tracker_id_det_mapping = {tracker_ids[t][i]: tracker_dets[t][i] for i in range(len(tracker_ids[t]))} + tracker_dets[t] = [tracker_id_det_mapping[index] if index in tracker_ids[t] else padding_mask for index + in range(num_tracker_ids)] + # also perform zero padding if number of tracker IDs < number of ground truth IDs + if num_tracker_ids < num_gt_ids: + diff = num_gt_ids - num_tracker_ids + for t in range(num_timesteps): + tracker_dets[t] = tracker_dets[t] + [padding_mask for _ in range(diff)] + num_tracker_ids += diff + + j = self._compute_j(gt_dets, tracker_dets, num_gt_ids, num_tracker_ids, num_timesteps) + + # boundary threshold for F computation + bound_th = 0.008 + + # perform matching + if self.optim_type == 'J&F': + f = np.zeros_like(j) + for k in range(num_tracker_ids): + for i in range(num_gt_ids): + f[k, i, :] = self._compute_f(gt_dets, tracker_dets, k, i, bound_th) + optim_metrics = (np.mean(j, axis=2) + np.mean(f, axis=2)) / 2 + row_ind, col_ind = linear_sum_assignment(- optim_metrics) + j_m = j[row_ind, col_ind, :] + f_m = f[row_ind, col_ind, :] + elif self.optim_type == 'J': + optim_metrics = np.mean(j, axis=2) + row_ind, col_ind = linear_sum_assignment(- optim_metrics) + j_m = j[row_ind, col_ind, :] + f_m = np.zeros_like(j_m) + for i, (tr_ind, gt_ind) in enumerate(zip(row_ind, col_ind)): + f_m[i] = self._compute_f(gt_dets, tracker_dets, tr_ind, gt_ind, bound_th) + else: + raise TrackEvalException('Unsupported optimization type %s for J&F metric.' % self.optim_type) + + # append zeros for false negatives + if j_m.shape[0] < data['num_gt_ids']: + diff = data['num_gt_ids'] - j_m.shape[0] + j_m = np.concatenate((j_m, np.zeros((diff, j_m.shape[1]))), axis=0) + f_m = np.concatenate((f_m, np.zeros((diff, f_m.shape[1]))), axis=0) + + # compute the metrics for each ground truth track + res = { + 'J-Mean': [np.nanmean(j_m[i, :]) for i in range(j_m.shape[0])], + 'J-Recall': [np.nanmean(j_m[i, :] > 0.5 + np.finfo('float').eps) for i in range(j_m.shape[0])], + 'F-Mean': [np.nanmean(f_m[i, :]) for i in range(f_m.shape[0])], + 'F-Recall': [np.nanmean(f_m[i, :] > 0.5 + np.finfo('float').eps) for i in range(f_m.shape[0])], + 'J-Decay': [], + 'F-Decay': [] + } + n_bins = 4 + ids = np.round(np.linspace(1, data['num_timesteps'], n_bins + 1) + 1e-10) - 1 + ids = ids.astype(np.uint8) + + for k in range(j_m.shape[0]): + d_bins_j = [j_m[k][ids[i]:ids[i + 1] + 1] for i in range(0, n_bins)] + res['J-Decay'].append(np.nanmean(d_bins_j[0]) - np.nanmean(d_bins_j[3])) + for k in range(f_m.shape[0]): + d_bins_f = [f_m[k][ids[i]:ids[i + 1] + 1] for i in range(0, n_bins)] + res['F-Decay'].append(np.nanmean(d_bins_f[0]) - np.nanmean(d_bins_f[3])) + + # count number of tracks for weighting of the result + res['num_gt_tracks'] = len(res['J-Mean']) + for field in ['J-Mean', 'J-Recall', 'J-Decay', 'F-Mean', 'F-Recall', 'F-Decay']: + res[field] = np.mean(res[field]) + res['J&F'] = (res['J-Mean'] + res['F-Mean']) / 2 + return res + + def combine_sequences(self, all_res): + """Combines metrics across all sequences""" + res = {'num_gt_tracks': self._combine_sum(all_res, 'num_gt_tracks')} + for field in self.summary_fields: + res[field] = self._combine_weighted_av(all_res, field, res, weight_field='num_gt_tracks') + return res + + def combine_classes_class_averaged(self, all_res): + """Combines metrics across all classes by averaging over the class values""" + res = {'num_gt_tracks': self._combine_sum(all_res, 'num_gt_tracks')} + for field in self.float_fields: + res[field] = np.mean([v[field] for v in all_res.values()]) + return res + + def combine_classes_det_averaged(self, all_res): + """Combines metrics across all classes by averaging over the detection values""" + res = {'num_gt_tracks': self._combine_sum(all_res, 'num_gt_tracks')} + for field in self.float_fields: + res[field] = np.mean([v[field] for v in all_res.values()]) + return res + + @staticmethod + def _seg2bmap(seg, width=None, height=None): + """ + From a segmentation, compute a binary boundary map with 1 pixel wide + boundaries. The boundary pixels are offset by 1/2 pixel towards the + origin from the actual segment boundary. + Arguments: + seg : Segments labeled from 1..k. + width : Width of desired bmap <= seg.shape[1] + height : Height of desired bmap <= seg.shape[0] + Returns: + bmap (ndarray): Binary boundary map. + David Martin + January 2003 + """ + + seg = seg.astype(np.bool) + seg[seg > 0] = 1 + + assert np.atleast_3d(seg).shape[2] == 1 + + width = seg.shape[1] if width is None else width + height = seg.shape[0] if height is None else height + + h, w = seg.shape[:2] + + ar1 = float(width) / float(height) + ar2 = float(w) / float(h) + + assert not ( + width > w | height > h | abs(ar1 - ar2) > 0.01 + ), "Can" "t convert %dx%d seg to %dx%d bmap." % (w, h, width, height) + + e = np.zeros_like(seg) + s = np.zeros_like(seg) + se = np.zeros_like(seg) + + e[:, :-1] = seg[:, 1:] + s[:-1, :] = seg[1:, :] + se[:-1, :-1] = seg[1:, 1:] + + b = seg ^ e | seg ^ s | seg ^ se + b[-1, :] = seg[-1, :] ^ e[-1, :] + b[:, -1] = seg[:, -1] ^ s[:, -1] + b[-1, -1] = 0 + + if w == width and h == height: + bmap = b + else: + bmap = np.zeros((height, width)) + for x in range(w): + for y in range(h): + if b[y, x]: + j = 1 + math.floor((y - 1) + height / h) + i = 1 + math.floor((x - 1) + width / h) + bmap[j, i] = 1 + + return bmap + + @staticmethod + def _compute_f(gt_data, tracker_data, tracker_data_id, gt_id, bound_th): + """ + Perform F computation for a given gt and a given tracker ID. Adapted from + https://github.com/davisvideochallenge/davis2017-evaluation + :param gt_data: the encoded gt masks + :param tracker_data: the encoded tracker masks + :param tracker_data_id: the tracker ID + :param gt_id: the ground truth ID + :param bound_th: boundary threshold parameter + :return: the F value for the given tracker and gt ID + """ + + # Only loaded when run to reduce minimum requirements + from pycocotools import mask as mask_utils + from skimage.morphology import disk + import cv2 + + f = np.zeros(len(gt_data)) + + for t, (gt_masks, tracker_masks) in enumerate(zip(gt_data, tracker_data)): + curr_tracker_mask = mask_utils.decode(tracker_masks[tracker_data_id]) + curr_gt_mask = mask_utils.decode(gt_masks[gt_id]) + + bound_pix = bound_th if bound_th >= 1 - np.finfo('float').eps else \ + np.ceil(bound_th * np.linalg.norm(curr_tracker_mask.shape)) + + # Get the pixel boundaries of both masks + fg_boundary = JAndF._seg2bmap(curr_tracker_mask) + gt_boundary = JAndF._seg2bmap(curr_gt_mask) + + # fg_dil = binary_dilation(fg_boundary, disk(bound_pix)) + fg_dil = cv2.dilate(fg_boundary.astype(np.uint8), disk(bound_pix).astype(np.uint8)) + # gt_dil = binary_dilation(gt_boundary, disk(bound_pix)) + gt_dil = cv2.dilate(gt_boundary.astype(np.uint8), disk(bound_pix).astype(np.uint8)) + + # Get the intersection + gt_match = gt_boundary * fg_dil + fg_match = fg_boundary * gt_dil + + # Area of the intersection + n_fg = np.sum(fg_boundary) + n_gt = np.sum(gt_boundary) + + # % Compute precision and recall + if n_fg == 0 and n_gt > 0: + precision = 1 + recall = 0 + elif n_fg > 0 and n_gt == 0: + precision = 0 + recall = 1 + elif n_fg == 0 and n_gt == 0: + precision = 1 + recall = 1 + else: + precision = np.sum(fg_match) / float(n_fg) + recall = np.sum(gt_match) / float(n_gt) + + # Compute F measure + if precision + recall == 0: + f_val = 0 + else: + f_val = 2 * precision * recall / (precision + recall) + + f[t] = f_val + + return f + + @staticmethod + def _compute_j(gt_data, tracker_data, num_gt_ids, num_tracker_ids, num_timesteps): + """ + Computation of J value for all ground truth IDs and all tracker IDs in the given sequence. Adapted from + https://github.com/davisvideochallenge/davis2017-evaluation + :param gt_data: the ground truth masks + :param tracker_data: the tracker masks + :param num_gt_ids: the number of ground truth IDs + :param num_tracker_ids: the number of tracker IDs + :param num_timesteps: the number of timesteps + :return: the J values + """ + + # Only loaded when run to reduce minimum requirements + from pycocotools import mask as mask_utils + + j = np.zeros((num_tracker_ids, num_gt_ids, num_timesteps)) + + for t, (time_gt, time_data) in enumerate(zip(gt_data, tracker_data)): + # run length encoded masks with pycocotools + area_gt = mask_utils.area(time_gt) + area_tr = mask_utils.area(time_data) + + area_tr = np.repeat(area_tr[:, np.newaxis], len(area_gt), axis=1) + area_gt = np.repeat(area_gt[np.newaxis, :], len(area_tr), axis=0) + + # mask iou computation with pycocotools + ious = mask_utils.iou(time_data, time_gt, [0]*len(time_gt)) + # set iou to 1 if both masks are close to 0 (no ground truth and no predicted mask in timestep) + ious[np.isclose(area_tr, 0) & np.isclose(area_gt, 0)] = 1 + assert (ious >= 0 - np.finfo('float').eps).all() + assert (ious <= 1 + np.finfo('float').eps).all() + + j[..., t] = ious + + return j diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/track_map.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/track_map.py new file mode 100644 index 0000000000000000000000000000000000000000..c3881e07baa19762fd0a24fa04a6e43182b32ae4 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/track_map.py @@ -0,0 +1,460 @@ +import numpy as np +from ._base_metric import _BaseMetric +from .. import _timing +from functools import partial +from .. import utils +from ..utils import TrackEvalException + + +class TrackMAP(_BaseMetric): + """Class which implements the TrackMAP metrics""" + + @staticmethod + def get_default_metric_config(): + """Default class config values""" + default_config = { + 'USE_AREA_RANGES': True, # whether to evaluate for certain area ranges + 'AREA_RANGES': [[0 ** 2, 32 ** 2], # additional area range sets for which TrackMAP is evaluated + [32 ** 2, 96 ** 2], # (all area range always included), default values for TAO + [96 ** 2, 1e5 ** 2]], # evaluation + 'AREA_RANGE_LABELS': ["area_s", "area_m", "area_l"], # the labels for the area ranges + 'USE_TIME_RANGES': True, # whether to evaluate for certain time ranges (length of tracks) + 'TIME_RANGES': [[0, 3], [3, 10], [10, 1e5]], # additional time range sets for which TrackMAP is evaluated + # (all time range always included) , default values for TAO evaluation + 'TIME_RANGE_LABELS': ["time_s", "time_m", "time_l"], # the labels for the time ranges + 'IOU_THRESHOLDS': np.arange(0.5, 0.96, 0.05), # the IoU thresholds + 'RECALL_THRESHOLDS': np.linspace(0.0, 1.00, int(np.round((1.00 - 0.0) / 0.01) + 1), endpoint=True), + # recall thresholds at which precision is evaluated + 'MAX_DETECTIONS': 0, # limit the maximum number of considered tracks per sequence (0 for unlimited) + 'PRINT_CONFIG': True + } + return default_config + + def __init__(self, config=None): + super().__init__() + self.config = utils.init_config(config, self.get_default_metric_config(), self.get_name()) + + self.num_ig_masks = 1 + self.lbls = ['all'] + self.use_area_rngs = self.config['USE_AREA_RANGES'] + if self.use_area_rngs: + self.area_rngs = self.config['AREA_RANGES'] + self.area_rng_lbls = self.config['AREA_RANGE_LABELS'] + self.num_ig_masks += len(self.area_rng_lbls) + self.lbls += self.area_rng_lbls + + self.use_time_rngs = self.config['USE_TIME_RANGES'] + if self.use_time_rngs: + self.time_rngs = self.config['TIME_RANGES'] + self.time_rng_lbls = self.config['TIME_RANGE_LABELS'] + self.num_ig_masks += len(self.time_rng_lbls) + self.lbls += self.time_rng_lbls + + self.array_labels = self.config['IOU_THRESHOLDS'] + self.rec_thrs = self.config['RECALL_THRESHOLDS'] + + self.maxDet = self.config['MAX_DETECTIONS'] + self.float_array_fields = ['AP_' + lbl for lbl in self.lbls] + ['AR_' + lbl for lbl in self.lbls] + self.fields = self.float_array_fields + self.summary_fields = self.float_array_fields + + @_timing.time + def eval_sequence(self, data): + """Calculates GT and Tracker matches for one sequence for TrackMAP metrics. Adapted from + https://github.com/TAO-Dataset/""" + + # Initialise results to zero for each sequence as the fields are only defined over the set of all sequences + res = {} + for field in self.fields: + res[field] = [0 for _ in self.array_labels] + + gt_ids, dt_ids = data['gt_track_ids'], data['dt_track_ids'] + + if len(gt_ids) == 0 and len(dt_ids) == 0: + for idx in range(self.num_ig_masks): + res[idx] = None + return res + + # get track data + gt_tr_areas = data.get('gt_track_areas', None) if self.use_area_rngs else None + gt_tr_lengths = data.get('gt_track_lengths', None) if self.use_time_rngs else None + gt_tr_iscrowd = data.get('gt_track_iscrowd', None) + dt_tr_areas = data.get('dt_track_areas', None) if self.use_area_rngs else None + dt_tr_lengths = data.get('dt_track_lengths', None) if self.use_time_rngs else None + is_nel = data.get('not_exhaustively_labeled', False) + + # compute ignore masks for different track sets to eval + gt_ig_masks = self._compute_track_ig_masks(len(gt_ids), track_lengths=gt_tr_lengths, track_areas=gt_tr_areas, + iscrowd=gt_tr_iscrowd) + dt_ig_masks = self._compute_track_ig_masks(len(dt_ids), track_lengths=dt_tr_lengths, track_areas=dt_tr_areas, + is_not_exhaustively_labeled=is_nel, is_gt=False) + + boxformat = data.get('boxformat', 'xywh') + ious = self._compute_track_ious(data['dt_tracks'], data['gt_tracks'], iou_function=data['iou_type'], + boxformat=boxformat) + + for mask_idx in range(self.num_ig_masks): + gt_ig_mask = gt_ig_masks[mask_idx] + + # Sort gt ignore last + gt_idx = np.argsort([g for g in gt_ig_mask], kind="mergesort") + gt_ids = [gt_ids[i] for i in gt_idx] + + ious_sorted = ious[:, gt_idx] if len(ious) > 0 else ious + + num_thrs = len(self.array_labels) + num_gt = len(gt_ids) + num_dt = len(dt_ids) + + # Array to store the "id" of the matched dt/gt + gt_m = np.zeros((num_thrs, num_gt)) - 1 + dt_m = np.zeros((num_thrs, num_dt)) - 1 + + gt_ig = np.array([gt_ig_mask[idx] for idx in gt_idx]) + dt_ig = np.zeros((num_thrs, num_dt)) + + for iou_thr_idx, iou_thr in enumerate(self.array_labels): + if len(ious_sorted) == 0: + break + + for dt_idx, _dt in enumerate(dt_ids): + iou = min([iou_thr, 1 - 1e-10]) + # information about best match so far (m=-1 -> unmatched) + # store the gt_idx which matched for _dt + m = -1 + for gt_idx, _ in enumerate(gt_ids): + # if this gt already matched continue + if gt_m[iou_thr_idx, gt_idx] > 0: + continue + # if _dt matched to reg gt, and on ignore gt, stop + if m > -1 and gt_ig[m] == 0 and gt_ig[gt_idx] == 1: + break + # continue to next gt unless better match made + if ious_sorted[dt_idx, gt_idx] < iou - np.finfo('float').eps: + continue + # if match successful and best so far, store appropriately + iou = ious_sorted[dt_idx, gt_idx] + m = gt_idx + + # No match found for _dt, go to next _dt + if m == -1: + continue + + # if gt to ignore for some reason update dt_ig. + # Should not be used in evaluation. + dt_ig[iou_thr_idx, dt_idx] = gt_ig[m] + # _dt match found, update gt_m, and dt_m with "id" + dt_m[iou_thr_idx, dt_idx] = gt_ids[m] + gt_m[iou_thr_idx, m] = _dt + + dt_ig_mask = dt_ig_masks[mask_idx] + + dt_ig_mask = np.array(dt_ig_mask).reshape((1, num_dt)) # 1 X num_dt + dt_ig_mask = np.repeat(dt_ig_mask, num_thrs, 0) # num_thrs X num_dt + + # Based on dt_ig_mask ignore any unmatched detection by updating dt_ig + dt_ig = np.logical_or(dt_ig, np.logical_and(dt_m == -1, dt_ig_mask)) + # store results for given video and category + res[mask_idx] = { + "dt_ids": dt_ids, + "gt_ids": gt_ids, + "dt_matches": dt_m, + "gt_matches": gt_m, + "dt_scores": data['dt_track_scores'], + "gt_ignore": gt_ig, + "dt_ignore": dt_ig, + } + + return res + + def combine_sequences(self, all_res): + """Combines metrics across all sequences. Computes precision and recall values based on track matches. + Adapted from https://github.com/TAO-Dataset/ + """ + num_thrs = len(self.array_labels) + num_recalls = len(self.rec_thrs) + + # -1 for absent categories + precision = -np.ones( + (num_thrs, num_recalls, self.num_ig_masks) + ) + recall = -np.ones((num_thrs, self.num_ig_masks)) + + for ig_idx in range(self.num_ig_masks): + ig_idx_results = [res[ig_idx] for res in all_res.values() if res[ig_idx] is not None] + + # Remove elements which are None + if len(ig_idx_results) == 0: + continue + + # Append all scores: shape (N,) + # limit considered tracks for each sequence if maxDet > 0 + if self.maxDet == 0: + dt_scores = np.concatenate([res["dt_scores"] for res in ig_idx_results], axis=0) + + dt_idx = np.argsort(-dt_scores, kind="mergesort") + + dt_m = np.concatenate([e["dt_matches"] for e in ig_idx_results], + axis=1)[:, dt_idx] + dt_ig = np.concatenate([e["dt_ignore"] for e in ig_idx_results], + axis=1)[:, dt_idx] + elif self.maxDet > 0: + dt_scores = np.concatenate([res["dt_scores"][0:self.maxDet] for res in ig_idx_results], axis=0) + + dt_idx = np.argsort(-dt_scores, kind="mergesort") + + dt_m = np.concatenate([e["dt_matches"][:, 0:self.maxDet] for e in ig_idx_results], + axis=1)[:, dt_idx] + dt_ig = np.concatenate([e["dt_ignore"][:, 0:self.maxDet] for e in ig_idx_results], + axis=1)[:, dt_idx] + else: + raise Exception("Number of maximum detections must be >= 0, but is set to %i" % self.maxDet) + + gt_ig = np.concatenate([res["gt_ignore"] for res in ig_idx_results]) + # num gt anns to consider + num_gt = np.count_nonzero(gt_ig == 0) + + if num_gt == 0: + continue + + tps = np.logical_and(dt_m != -1, np.logical_not(dt_ig)) + fps = np.logical_and(dt_m == -1, np.logical_not(dt_ig)) + + tp_sum = np.cumsum(tps, axis=1).astype(dtype=np.float) + fp_sum = np.cumsum(fps, axis=1).astype(dtype=np.float) + + for iou_thr_idx, (tp, fp) in enumerate(zip(tp_sum, fp_sum)): + tp = np.array(tp) + fp = np.array(fp) + num_tp = len(tp) + rc = tp / num_gt + if num_tp: + recall[iou_thr_idx, ig_idx] = rc[-1] + else: + recall[iou_thr_idx, ig_idx] = 0 + + # np.spacing(1) ~= eps + pr = tp / (fp + tp + np.spacing(1)) + pr = pr.tolist() + + # Ensure precision values are monotonically decreasing + for i in range(num_tp - 1, 0, -1): + if pr[i] > pr[i - 1]: + pr[i - 1] = pr[i] + + # find indices at the predefined recall values + rec_thrs_insert_idx = np.searchsorted(rc, self.rec_thrs, side="left") + + pr_at_recall = [0.0] * num_recalls + + try: + for _idx, pr_idx in enumerate(rec_thrs_insert_idx): + pr_at_recall[_idx] = pr[pr_idx] + except IndexError: + pass + + precision[iou_thr_idx, :, ig_idx] = (np.array(pr_at_recall)) + + res = {'precision': precision, 'recall': recall} + + # compute the precision and recall averages for the respective alpha thresholds and ignore masks + for lbl in self.lbls: + res['AP_' + lbl] = np.zeros((len(self.array_labels)), dtype=np.float) + res['AR_' + lbl] = np.zeros((len(self.array_labels)), dtype=np.float) + + for a_id, alpha in enumerate(self.array_labels): + for lbl_idx, lbl in enumerate(self.lbls): + p = precision[a_id, :, lbl_idx] + if len(p[p > -1]) == 0: + mean_p = -1 + else: + mean_p = np.mean(p[p > -1]) + res['AP_' + lbl][a_id] = mean_p + res['AR_' + lbl][a_id] = recall[a_id, lbl_idx] + + return res + + def combine_classes_class_averaged(self, all_res): + """Combines metrics across all classes by averaging over the class values""" + res = {} + for field in self.fields: + res[field] = np.zeros((len(self.array_labels)), dtype=np.float) + field_stacked = np.array([res[field] for res in all_res.values()]) + + for a_id, alpha in enumerate(self.array_labels): + values = field_stacked[:, a_id] + if len(values[values > -1]) == 0: + mean = -1 + else: + mean = np.mean(values[values > -1]) + res[field][a_id] = mean + return res + + def combine_classes_det_averaged(self, all_res): + """Combines metrics across all classes by averaging over the detection values""" + + res = {} + for field in self.fields: + res[field] = np.zeros((len(self.array_labels)), dtype=np.float) + field_stacked = np.array([res[field] for res in all_res.values()]) + + for a_id, alpha in enumerate(self.array_labels): + values = field_stacked[:, a_id] + if len(values[values > -1]) == 0: + mean = -1 + else: + mean = np.mean(values[values > -1]) + res[field][a_id] = mean + return res + + def _compute_track_ig_masks(self, num_ids, track_lengths=None, track_areas=None, iscrowd=None, + is_not_exhaustively_labeled=False, is_gt=True): + """ + Computes ignore masks for different track sets to evaluate + :param num_ids: the number of track IDs + :param track_lengths: the lengths of the tracks (number of timesteps) + :param track_areas: the average area of a track + :param iscrowd: whether a track is marked as crowd + :param is_not_exhaustively_labeled: whether the track category is not exhaustively labeled + :param is_gt: whether it is gt + :return: the track ignore masks + """ + # for TAO tracks for classes which are not exhaustively labeled are not evaluated + if not is_gt and is_not_exhaustively_labeled: + track_ig_masks = [[1 for _ in range(num_ids)] for i in range(self.num_ig_masks)] + else: + # consider all tracks + track_ig_masks = [[0 for _ in range(num_ids)]] + + # consider tracks with certain area + if self.use_area_rngs: + for rng in self.area_rngs: + track_ig_masks.append([0 if rng[0] - np.finfo('float').eps <= area <= rng[1] + np.finfo('float').eps + else 1 for area in track_areas]) + + # consider tracks with certain duration + if self.use_time_rngs: + for rng in self.time_rngs: + track_ig_masks.append([0 if rng[0] - np.finfo('float').eps <= length + <= rng[1] + np.finfo('float').eps else 1 for length in track_lengths]) + + # for YouTubeVIS evaluation tracks with crowd tag are not evaluated + if is_gt and iscrowd: + track_ig_masks = [np.logical_or(mask, iscrowd) for mask in track_ig_masks] + + return track_ig_masks + + @staticmethod + def _compute_bb_track_iou(dt_track, gt_track, boxformat='xywh'): + """ + Calculates the track IoU for one detected track and one ground truth track for bounding boxes + :param dt_track: the detected track (format: dictionary with frame index as keys and + numpy arrays as values) + :param gt_track: the ground truth track (format: dictionary with frame index as keys and + numpy array as values) + :param boxformat: the format of the boxes + :return: the track IoU + """ + intersect = 0 + union = 0 + image_ids = set(gt_track.keys()) | set(dt_track.keys()) + for image in image_ids: + g = gt_track.get(image, None) + d = dt_track.get(image, None) + if boxformat == 'xywh': + if d is not None and g is not None: + dx, dy, dw, dh = d + gx, gy, gw, gh = g + w = max(min(dx + dw, gx + gw) - max(dx, gx), 0) + h = max(min(dy + dh, gy + gh) - max(dy, gy), 0) + i = w * h + u = dw * dh + gw * gh - i + intersect += i + union += u + elif d is None and g is not None: + union += g[2] * g[3] + elif d is not None and g is None: + union += d[2] * d[3] + elif boxformat == 'x0y0x1y1': + if d is not None and g is not None: + dx0, dy0, dx1, dy1 = d + gx0, gy0, gx1, gy1 = g + w = max(min(dx1, gx1) - max(dx0, gx0), 0) + h = max(min(dy1, gy1) - max(dy0, gy0), 0) + i = w * h + u = (dx1 - dx0) * (dy1 - dy0) + (gx1 - gx0) * (gy1 - gy0) - i + intersect += i + union += u + elif d is None and g is not None: + union += (g[2] - g[0]) * (g[3] - g[1]) + elif d is not None and g is None: + union += (d[2] - d[0]) * (d[3] - d[1]) + else: + raise TrackEvalException('BoxFormat not implemented') + if intersect > union: + raise TrackEvalException("Intersection value > union value. Are the box values corrupted?") + return intersect / union if union > 0 else 0 + + @staticmethod + def _compute_mask_track_iou(dt_track, gt_track): + """ + Calculates the track IoU for one detected track and one ground truth track for segmentation masks + :param dt_track: the detected track (format: dictionary with frame index as keys and + pycocotools rle encoded masks as values) + :param gt_track: the ground truth track (format: dictionary with frame index as keys and + pycocotools rle encoded masks as values) + :return: the track IoU + """ + # only loaded when needed to reduce minimum requirements + from pycocotools import mask as mask_utils + + intersect = .0 + union = .0 + image_ids = set(gt_track.keys()) | set(dt_track.keys()) + for image in image_ids: + g = gt_track.get(image, None) + d = dt_track.get(image, None) + if d and g: + intersect += mask_utils.area(mask_utils.merge([d, g], True)) + union += mask_utils.area(mask_utils.merge([d, g], False)) + elif not d and g: + union += mask_utils.area(g) + elif d and not g: + union += mask_utils.area(d) + if union < 0.0 - np.finfo('float').eps: + raise TrackEvalException("Union value < 0. Are the segmentaions corrupted?") + if intersect > union: + raise TrackEvalException("Intersection value > union value. Are the segmentations corrupted?") + iou = intersect / union if union > 0.0 + np.finfo('float').eps else 0.0 + return iou + + @staticmethod + def _compute_track_ious(dt, gt, iou_function='bbox', boxformat='xywh'): + """ + Calculate track IoUs for a set of ground truth tracks and a set of detected tracks + """ + + if len(gt) == 0 and len(dt) == 0: + return [] + + if iou_function == 'bbox': + track_iou_function = partial(TrackMAP._compute_bb_track_iou, boxformat=boxformat) + elif iou_function == 'mask': + track_iou_function = partial(TrackMAP._compute_mask_track_iou) + else: + raise Exception('IoU function not implemented') + + ious = np.zeros([len(dt), len(gt)]) + for i, j in np.ndindex(ious.shape): + ious[i, j] = track_iou_function(dt[i], gt[j]) + return ious + + @staticmethod + def _row_print(*argv): + """Prints results in an evenly spaced rows, with more space in first row""" + if len(argv) == 1: + argv = argv[0] + to_print = '%-40s' % argv[0] + for v in argv[1:]: + to_print += '%-12s' % str(v) + print(to_print) diff --git a/OpenPVSG/models/unitrack/eval/trackeval/metrics/vace.py b/OpenPVSG/models/unitrack/eval/trackeval/metrics/vace.py new file mode 100644 index 0000000000000000000000000000000000000000..f4f7d49d3ec709bfae3a8234159243e26f3e6d66 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/metrics/vace.py @@ -0,0 +1,126 @@ +import numpy as np +from scipy.optimize import linear_sum_assignment +from ._base_metric import _BaseMetric +from .. import _timing + + +class VACE(_BaseMetric): + """Class which implements the VACE metrics. + + The metrics are described in: + Manohar et al. (2006) "Performance Evaluation of Object Detection and Tracking in Video" + https://link.springer.com/chapter/10.1007/11612704_16 + + This implementation uses the "relaxed" variant of the metrics, + where an overlap threshold is applied in each frame. + """ + + def __init__(self): + super().__init__() + self.integer_fields = ['VACE_IDs', 'VACE_GT_IDs', 'num_non_empty_timesteps'] + self.float_fields = ['STDA', 'ATA', 'FDA', 'SFDA'] + self.fields = self.integer_fields + self.float_fields + self.summary_fields = ['SFDA', 'ATA'] + + # Fields that are accumulated over multiple videos. + self._additive_fields = self.integer_fields + ['STDA', 'FDA'] + + self.threshold = 0.5 + + @_timing.time + def eval_sequence(self, data): + """Calculates VACE metrics for one sequence. + + Depends on the fields: + data['num_gt_ids'] + data['num_tracker_ids'] + data['gt_ids'] + data['tracker_ids'] + data['similarity_scores'] + """ + res = {} + + # Obtain Average Tracking Accuracy (ATA) using track correspondence. + # Obtain counts necessary to compute temporal IOU. + # Assume that integer counts can be represented exactly as floats. + potential_matches_count = np.zeros((data['num_gt_ids'], data['num_tracker_ids'])) + gt_id_count = np.zeros(data['num_gt_ids']) + tracker_id_count = np.zeros(data['num_tracker_ids']) + both_present_count = np.zeros((data['num_gt_ids'], data['num_tracker_ids'])) + for t, (gt_ids_t, tracker_ids_t) in enumerate(zip(data['gt_ids'], data['tracker_ids'])): + # Count the number of frames in which two tracks satisfy the overlap criterion. + matches_mask = np.greater_equal(data['similarity_scores'][t], self.threshold) + match_idx_gt, match_idx_tracker = np.nonzero(matches_mask) + potential_matches_count[gt_ids_t[match_idx_gt], tracker_ids_t[match_idx_tracker]] += 1 + # Count the number of frames in which the tracks are present. + gt_id_count[gt_ids_t] += 1 + tracker_id_count[tracker_ids_t] += 1 + both_present_count[gt_ids_t[:, np.newaxis], tracker_ids_t[np.newaxis, :]] += 1 + # Number of frames in which either track is present (union of the two sets of frames). + union_count = (gt_id_count[:, np.newaxis] + + tracker_id_count[np.newaxis, :] + - both_present_count) + # The denominator should always be non-zero if all tracks are non-empty. + with np.errstate(divide='raise', invalid='raise'): + temporal_iou = potential_matches_count / union_count + # Find assignment that maximizes temporal IOU. + match_rows, match_cols = linear_sum_assignment(-temporal_iou) + res['STDA'] = temporal_iou[match_rows, match_cols].sum() + res['VACE_IDs'] = data['num_tracker_ids'] + res['VACE_GT_IDs'] = data['num_gt_ids'] + + # Obtain Frame Detection Accuracy (FDA) using per-frame correspondence. + non_empty_count = 0 + fda = 0 + for t, (gt_ids_t, tracker_ids_t) in enumerate(zip(data['gt_ids'], data['tracker_ids'])): + n_g = len(gt_ids_t) + n_d = len(tracker_ids_t) + if not (n_g or n_d): + continue + # n_g > 0 or n_d > 0 + non_empty_count += 1 + if not (n_g and n_d): + continue + # n_g > 0 and n_d > 0 + spatial_overlap = data['similarity_scores'][t] + match_rows, match_cols = linear_sum_assignment(-spatial_overlap) + overlap_ratio = spatial_overlap[match_rows, match_cols].sum() + fda += overlap_ratio / (0.5 * (n_g + n_d)) + res['FDA'] = fda + res['num_non_empty_timesteps'] = non_empty_count + + res.update(self._compute_final_fields(res)) + return res + + def combine_classes_class_averaged(self, all_res): + """Combines metrics across all classes by averaging over the class values""" + res = {} + for field in self.fields: + res[field] = np.mean([v[field] for v in all_res.values() + if v['VACE_GT_IDs'] > 0 or v['VACE_IDs'] > 0], axis=0) + return res + + def combine_classes_det_averaged(self, all_res): + """Combines metrics across all classes by averaging over the detection values""" + res = {} + for field in self._additive_fields: + res[field] = _BaseMetric._combine_sum(all_res, field) + res = self._compute_final_fields(res) + return res + + def combine_sequences(self, all_res): + """Combines metrics across all sequences""" + res = {} + for header in self._additive_fields: + res[header] = _BaseMetric._combine_sum(all_res, header) + res.update(self._compute_final_fields(res)) + return res + + @staticmethod + def _compute_final_fields(additive): + final = {} + with np.errstate(invalid='ignore'): # Permit nan results. + final['ATA'] = (additive['STDA'] / + (0.5 * (additive['VACE_IDs'] + additive['VACE_GT_IDs']))) + final['SFDA'] = additive['FDA'] / additive['num_non_empty_timesteps'] + return final diff --git a/OpenPVSG/models/unitrack/eval/trackeval/plotting.py b/OpenPVSG/models/unitrack/eval/trackeval/plotting.py new file mode 100644 index 0000000000000000000000000000000000000000..e76fd08c2733011a043de5cde3f16cfa4055268c --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/plotting.py @@ -0,0 +1,230 @@ + +import os +import numpy as np +from .utils import TrackEvalException + + +def plot_compare_trackers(tracker_folder, tracker_list, cls, output_folder, plots_list=None): + """Create plots which compare metrics across different trackers.""" + # Define what to plot + if plots_list is None: + plots_list = get_default_plots_list() + + # Load data + data = load_multiple_tracker_summaries(tracker_folder, tracker_list, cls) + out_loc = os.path.join(output_folder, cls) + + # Plot + for args in plots_list: + create_comparison_plot(data, out_loc, *args) + + +def get_default_plots_list(): + # y_label, x_label, sort_label, bg_label, bg_function + plots_list = [ + ['AssA', 'DetA', 'HOTA', 'HOTA', 'geometric_mean'], + ['AssPr', 'AssRe', 'HOTA', 'AssA', 'jaccard'], + ['DetPr', 'DetRe', 'HOTA', 'DetA', 'jaccard'], + ['HOTA(0)', 'LocA(0)', 'HOTA', 'HOTALocA(0)', 'multiplication'], + ['HOTA', 'LocA', 'HOTA', None, None], + + ['HOTA', 'MOTA', 'HOTA', None, None], + ['HOTA', 'IDF1', 'HOTA', None, None], + ['IDF1', 'MOTA', 'HOTA', None, None], + ] + return plots_list + + +def load_multiple_tracker_summaries(tracker_folder, tracker_list, cls): + """Loads summary data for multiple trackers.""" + data = {} + for tracker in tracker_list: + with open(os.path.join(tracker_folder, tracker, cls + '_summary.txt')) as f: + keys = next(f).split(' ') + done = False + while not done: + values = next(f).split(' ') + if len(values) == len(keys): + done = True + data[tracker] = dict(zip(keys, map(float, values))) + return data + + +def create_comparison_plot(data, out_loc, y_label, x_label, sort_label, bg_label=None, bg_function=None, settings=None): + """ Creates a scatter plot comparing multiple trackers between two metric fields, with one on the x-axis and the + other on the y axis. Adds pareto optical lines and (optionally) a background contour. + + Inputs: + data: dict of dicts such that data[tracker_name][metric_field_name] = float + y_label: the metric_field_name to be plotted on the y-axis + x_label: the metric_field_name to be plotted on the x-axis + sort_label: the metric_field_name by which trackers are ordered and ranked + bg_label: the metric_field_name by which (optional) background contours are plotted + bg_function: the (optional) function bg_function(x,y) which converts the x_label / y_label values into bg_label. + settings: dict of plot settings with keys: + 'gap_val': gap between axis ticks and bg curves. + 'num_to_plot': maximum number of trackers to plot + """ + + # Only loaded when run to reduce minimum requirements + from matplotlib import pyplot as plt + + # Get plot settings + if settings is None: + gap_val = 2 + num_to_plot = 20 + else: + gap_val = settings['gap_val'] + num_to_plot = settings['num_to_plot'] + + if (bg_label is None) != (bg_function is None): + raise TrackEvalException('bg_function and bg_label must either be both given or neither given.') + + # Extract data + tracker_names = np.array(list(data.keys())) + sort_index = np.array([data[t][sort_label] for t in tracker_names]).argsort()[::-1] + x_values = np.array([data[t][x_label] for t in tracker_names])[sort_index][:num_to_plot] + y_values = np.array([data[t][y_label] for t in tracker_names])[sort_index][:num_to_plot] + + # Print info on what is being plotted + tracker_names = tracker_names[sort_index][:num_to_plot] + print('\nPlotting %s vs %s, for the following (ordered) trackers:' % (y_label, x_label)) + for i, name in enumerate(tracker_names): + print('%i: %s' % (i+1, name)) + + # Find best fitting boundaries for data + boundaries = _get_boundaries(x_values, y_values, round_val=gap_val/2) + + fig = plt.figure() + + # Plot background contour + if bg_function is not None: + _plot_bg_contour(bg_function, boundaries, gap_val) + + # Plot pareto optimal lines + _plot_pareto_optimal_lines(x_values, y_values) + + # Plot data points with number labels + labels = np.arange(len(y_values)) + 1 + plt.plot(x_values, y_values, 'b.', markersize=15) + for xx, yy, l in zip(x_values, y_values, labels): + plt.text(xx, yy, str(l), color="red", fontsize=15) + + # Add extra explanatory text to plots + plt.text(0, -0.11, 'label order:\nHOTA', horizontalalignment='left', verticalalignment='center', + transform=fig.axes[0].transAxes, color="red", fontsize=12) + if bg_label is not None: + plt.text(1, -0.11, 'curve values:\n' + bg_label, horizontalalignment='right', verticalalignment='center', + transform=fig.axes[0].transAxes, color="grey", fontsize=12) + + plt.xlabel(x_label, fontsize=15) + plt.ylabel(y_label, fontsize=15) + title = y_label + ' vs ' + x_label + if bg_label is not None: + title += ' (' + bg_label + ')' + plt.title(title, fontsize=17) + plt.xticks(np.arange(0, 100, gap_val)) + plt.yticks(np.arange(0, 100, gap_val)) + min_x, max_x, min_y, max_y = boundaries + plt.xlim(min_x, max_x) + plt.ylim(min_y, max_y) + plt.gca().set_aspect('equal', adjustable='box') + plt.tight_layout() + + os.makedirs(out_loc, exist_ok=True) + filename = os.path.join(out_loc, title.replace(' ', '_')) + plt.savefig(filename + '.pdf', bbox_inches='tight', pad_inches=0.05) + plt.savefig(filename + '.png', bbox_inches='tight', pad_inches=0.05) + + +def _get_boundaries(x_values, y_values, round_val): + x1 = np.min(np.floor((x_values - 0.5) / round_val) * round_val) + x2 = np.max(np.ceil((x_values + 0.5) / round_val) * round_val) + y1 = np.min(np.floor((y_values - 0.5) / round_val) * round_val) + y2 = np.max(np.ceil((y_values + 0.5) / round_val) * round_val) + x_range = x2 - x1 + y_range = y2 - y1 + max_range = max(x_range, y_range) + x_center = (x1 + x2) / 2 + y_center = (y1 + y2) / 2 + min_x = max(x_center - max_range / 2, 0) + max_x = min(x_center + max_range / 2, 100) + min_y = max(y_center - max_range / 2, 0) + max_y = min(y_center + max_range / 2, 100) + return min_x, max_x, min_y, max_y + + +def geometric_mean(x, y): + return np.sqrt(x * y) + + +def jaccard(x, y): + x = x / 100 + y = y / 100 + return 100 * (x * y) / (x + y - x * y) + + +def multiplication(x, y): + return x * y / 100 + + +bg_function_dict = { + "geometric_mean": geometric_mean, + "jaccard": jaccard, + "multiplication": multiplication, + } + + +def _plot_bg_contour(bg_function, plot_boundaries, gap_val): + """ Plot background contour. """ + + # Only loaded when run to reduce minimum requirements + from matplotlib import pyplot as plt + + # Plot background contour + min_x, max_x, min_y, max_y = plot_boundaries + x = np.arange(min_x, max_x, 0.1) + y = np.arange(min_y, max_y, 0.1) + x_grid, y_grid = np.meshgrid(x, y) + if bg_function in bg_function_dict.keys(): + z_grid = bg_function_dict[bg_function](x_grid, y_grid) + else: + raise TrackEvalException("background plotting function '%s' is not defined." % bg_function) + levels = np.arange(0, 100, gap_val) + con = plt.contour(x_grid, y_grid, z_grid, levels, colors='grey') + + def bg_format(val): + s = '{:1f}'.format(val) + return '{:.0f}'.format(val) if s[-1] == '0' else s + + con.levels = [bg_format(val) for val in con.levels] + plt.clabel(con, con.levels, inline=True, fmt='%r', fontsize=8) + + +def _plot_pareto_optimal_lines(x_values, y_values): + """ Plot pareto optimal lines """ + + # Only loaded when run to reduce minimum requirements + from matplotlib import pyplot as plt + + # Plot pareto optimal lines + cxs = x_values + cys = y_values + best_y = np.argmax(cys) + x_pareto = [0, cxs[best_y]] + y_pareto = [cys[best_y], cys[best_y]] + t = 2 + remaining = cxs > x_pareto[t - 1] + cys = cys[remaining] + cxs = cxs[remaining] + while len(cxs) > 0 and len(cys) > 0: + best_y = np.argmax(cys) + x_pareto += [x_pareto[t - 1], cxs[best_y]] + y_pareto += [cys[best_y], cys[best_y]] + t += 2 + remaining = cxs > x_pareto[t - 1] + cys = cys[remaining] + cxs = cxs[remaining] + x_pareto.append(x_pareto[t - 1]) + y_pareto.append(0) + plt.plot(np.array(x_pareto), np.array(y_pareto), '--r') diff --git a/OpenPVSG/models/unitrack/eval/trackeval/utils.py b/OpenPVSG/models/unitrack/eval/trackeval/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ef522ff82c6b76bf6e85548fc7b380de78c59c60 --- /dev/null +++ b/OpenPVSG/models/unitrack/eval/trackeval/utils.py @@ -0,0 +1,112 @@ + +import os +import csv +from collections import OrderedDict + + +def init_config(config, default_config, name=None): + """Initialise non-given config values with defaults""" + if config is None: + config = default_config + else: + for k in default_config.keys(): + if k not in config.keys(): + config[k] = default_config[k] + if name and config['PRINT_CONFIG']: + print('\n%s Config:' % name) + for c in config.keys(): + print('%-20s : %-30s' % (c, config[c])) + return config + +def get_code_path(): + """Get base path where code is""" + return os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) + + +def validate_metrics_list(metrics_list): + """Get names of metric class and ensures they are unique, further checks that the fields within each metric class + do not have overlapping names. + """ + metric_names = [metric.get_name() for metric in metrics_list] + # check metric names are unique + if len(metric_names) != len(set(metric_names)): + raise TrackEvalException('Code being run with multiple metrics of the same name') + fields = [] + for m in metrics_list: + fields += m.fields + # check metric fields are unique + if len(fields) != len(set(fields)): + raise TrackEvalException('Code being run with multiple metrics with fields of the same name') + return metric_names + + +def write_summary_results(summaries, cls, output_folder): + """Write summary results to file""" + + fields = sum([list(s.keys()) for s in summaries], []) + values = sum([list(s.values()) for s in summaries], []) + + # In order to remain consistent upon new fields being adding, for each of the following fields if they are present + # they will be output in the summary first in the order below. Any further fields will be output in the order each + # metric family is called, and within each family either in the order they were added to the dict (python >= 3.6) or + # randomly (python < 3.6). + default_order = ['HOTA', 'DetA', 'AssA', 'DetRe', 'DetPr', 'AssRe', 'AssPr', 'LocA', 'RHOTA', 'HOTA(0)', 'LocA(0)', + 'HOTALocA(0)', 'MOTA', 'MOTP', 'MODA', 'CLR_Re', 'CLR_Pr', 'MTR', 'PTR', 'MLR', 'CLR_TP', 'CLR_FN', + 'CLR_FP', 'IDSW', 'MT', 'PT', 'ML', 'Frag', 'sMOTA', 'IDF1', 'IDR', 'IDP', 'IDTP', 'IDFN', 'IDFP', + 'Dets', 'GT_Dets', 'IDs', 'GT_IDs'] + default_ordered_dict = OrderedDict(zip(default_order, [None for _ in default_order])) + for f, v in zip(fields, values): + default_ordered_dict[f] = v + for df in default_order: + if default_ordered_dict[df] is None: + del default_ordered_dict[df] + fields = list(default_ordered_dict.keys()) + values = list(default_ordered_dict.values()) + + out_file = os.path.join(output_folder, cls + '_summary.txt') + os.makedirs(os.path.dirname(out_file), exist_ok=True) + with open(out_file, 'w', newline='') as f: + writer = csv.writer(f, delimiter=' ') + writer.writerow(fields) + writer.writerow(values) + + +def write_detailed_results(details, cls, output_folder): + """Write detailed results to file""" + sequences = details[0].keys() + fields = ['seq'] + sum([list(s['COMBINED_SEQ'].keys()) for s in details], []) + out_file = os.path.join(output_folder, cls + '_detailed.csv') + os.makedirs(os.path.dirname(out_file), exist_ok=True) + with open(out_file, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(fields) + for seq in sorted(sequences): + if seq == 'COMBINED_SEQ': + continue + writer.writerow([seq] + sum([list(s[seq].values()) for s in details], [])) + writer.writerow(['COMBINED'] + sum([list(s['COMBINED_SEQ'].values()) for s in details], [])) + + +def load_detail(file): + """Loads detailed data for a tracker.""" + data = {} + with open(file) as f: + for i, row_text in enumerate(f): + row = row_text.replace('\r', '').replace('\n', '').split(',') + if i == 0: + keys = row[1:] + continue + current_values = row[1:] + seq = row[0] + if seq == 'COMBINED': + seq = 'COMBINED_SEQ' + if (len(current_values) == len(keys)) and seq is not '': + data[seq] = {} + for key, value in zip(keys, current_values): + data[seq][key] = float(value) + return data + + +class TrackEvalException(Exception): + """Custom exception for catching expected errors.""" + ... diff --git a/OpenPVSG/models/unitrack/model/__init__.py b/OpenPVSG/models/unitrack/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e5e99e055bb873af718143a680030a180d60dead --- /dev/null +++ b/OpenPVSG/models/unitrack/model/__init__.py @@ -0,0 +1,13 @@ +################################################################### +# File Name: __init__.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Thu Dec 24 14:24:44 2020 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + +from .model import * +from .resnet import * diff --git a/OpenPVSG/models/unitrack/model/functional.py b/OpenPVSG/models/unitrack/model/functional.py new file mode 100644 index 0000000000000000000000000000000000000000..c9faac096abc6b6751cb281df136df8606fbf044 --- /dev/null +++ b/OpenPVSG/models/unitrack/model/functional.py @@ -0,0 +1,181 @@ +################################################################### +# File Name: functional.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Mon Jun 21 21:04:09 2021 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + + +import torch +import torch.nn as nn +import torch.nn.functional as F + +def hard_prop(pred): + pred_max = pred.max(axis=0)[0] + pred[pred < pred_max] = 0 + pred[pred >= pred_max] = 1 + pred /= pred.sum(0)[None] + return pred + +def context_index_bank(n_context, long_mem, N): + ''' + Construct bank of source frames indices, for each target frame + ''' + ll = [] # "long term" context (i.e. first frame) + for t in long_mem: + assert 0 <= t < N, 'context frame out of bounds' + idx = torch.zeros(N, 1).long() + if t > 0: + idx += t + (n_context+1) + idx[:n_context+t+1] = 0 + ll.append(idx) + # "short" context + ss = [(torch.arange(n_context)[None].repeat(N, 1) + \ + torch.arange(N)[:, None])[:, :]] + return ll + ss + + +def mem_efficient_batched_affinity( + query, keys, mask, temperature, topk, long_mem, device): + ''' + Mini-batched computation of affinity, for memory efficiency + ''' + bsize, pbsize = 10, 100 #keys.shape[2] // 2 + Ws, Is = [], [] + + for b in range(0, keys.shape[2], bsize): + _k, _q = keys[:, :, b:b+bsize].to(device), query[:, :, b:b+bsize].to(device) + w_s, i_s = [], [] + + for pb in range(0, _k.shape[-1], pbsize): + A = torch.einsum('ijklm,ijkn->iklmn', _k, _q[..., pb:pb+pbsize]) + A[0, :, len(long_mem):] += mask[..., pb:pb+pbsize].to(device) + + _, N, T, h1w1, hw = A.shape + A = A.view(N, T*h1w1, hw) + A /= temperature + + weights, ids = torch.topk(A, topk, dim=-2) + weights = F.softmax(weights, dim=-2) + + w_s.append(weights.cpu()) + i_s.append(ids.cpu()) + + weights = torch.cat(w_s, dim=-1) + ids = torch.cat(i_s, dim=-1) + Ws += [w for w in weights] + Is += [ii for ii in ids] + + return Ws, Is + +def batched_affinity(query, keys, mask, temperature, topk, long_mem, device): + ''' + Mini-batched computation of affinity, for memory efficiency + (less aggressively mini-batched) + ''' + bsize = 2 + Ws, Is = [], [] + for b in range(0, keys.shape[2], bsize): + _k, _q = keys[:, :, b:b+bsize].to(device), query[:, :, b:b+bsize].to(device) + w_s, i_s = [], [] + + A = torch.einsum('ijklmn,ijkop->iklmnop', _k, _q) / temperature + + # Mask + A[0, :, len(long_mem):] += mask.to(device) + + _, N, T, h1w1, hw = A.shape + A = A.view(N, T*h1w1, hw) + A /= temperature + + weights, ids = torch.topk(A, topk, dim=-2) + weights = F.softmax(weights, dim=-2) + + Ws += [w for w in weights] + Is += [ii for ii in ids] + + return Ws, Is + +def process_pose(pred, lbl_set, topk=3): + # generate the coordinates: + pred = pred[..., 1:] + flatlbls = pred.flatten(0,1) + topk = min(flatlbls.shape[0], topk) + + vals, ids = torch.topk(flatlbls, k=topk, dim=0) + vals /= vals.sum(0)[None] + xx, yy = ids % pred.shape[1], ids // pred.shape[1] + + current_coord = torch.stack([(xx * vals).sum(0), (yy * vals).sum(0)], dim=0) + current_coord[:, flatlbls.sum(0) == 0] = -1 + + pred_val_sharp = np.zeros((*pred.shape[:2], 3)) + + for t in range(len(lbl_set) - 1): + x = int(current_coord[0, t]) + y = int(current_coord[1, t]) + + if x >=0 and y >= 0: + pred_val_sharp[y, x, :] = lbl_set[t + 1] + + return current_coord.cpu(), pred_val_sharp + +class MaskedAttention(nn.Module): + ''' + A module that implements masked attention based on spatial locality + TODO implement in a more efficient way (torch sparse or correlation filter) + ''' + def __init__(self, radius, flat=True): + super(MaskedAttention, self).__init__() + self.radius = radius + self.flat = flat + self.masks = {} + self.index = {} + + def mask(self, H, W): + if not ('%s-%s' %(H,W) in self.masks): + self.make(H, W) + return self.masks['%s-%s' %(H,W)] + + def index(self, H, W): + if not ('%s-%s' %(H,W) in self.index): + self.make_index(H, W) + return self.index['%s-%s' %(H,W)] + + def make(self, H, W): + if self.flat: + H = int(H**0.5) + W = int(W**0.5) + + gx, gy = torch.meshgrid(torch.arange(0, H), torch.arange(0, W)) + D = ( (gx[None, None, :, :] - gx[:, :, None, None])**2 + (gy[None, None, :, :] - gy[:, :, None, None])**2 ).float() ** 0.5 + D = (D < self.radius)[None].float() + + if self.flat: + D = self.flatten(D) + self.masks['%s-%s' %(H,W)] = D + + return D + + def flatten(self, D): + return torch.flatten(torch.flatten(D, 1, 2), -2, -1) + + def make_index(self, H, W, pad=False): + mask = self.mask(H, W).view(1, -1).byte() + idx = torch.arange(0, mask.numel())[mask[0]][None] + + self.index['%s-%s' %(H,W)] = idx + + return idx + + def forward(self, x): + H, W = x.shape[-2:] + sid = '%s-%s' % (H,W) + if sid not in self.masks: + self.masks[sid] = self.make(H, W).to(x.device) + mask = self.masks[sid] + return x * mask[0] diff --git a/OpenPVSG/models/unitrack/model/hrnet.py b/OpenPVSG/models/unitrack/model/hrnet.py new file mode 100644 index 0000000000000000000000000000000000000000..020790852deb31ae2bdf07fadfdeadf8250f3ec2 --- /dev/null +++ b/OpenPVSG/models/unitrack/model/hrnet.py @@ -0,0 +1,610 @@ +# ------------------------------------------------------------------------------ +# Copyright (c) Microsoft +# Licensed under the MIT License. +# Written by Bin Xiao (Bin.Xiao@microsoft.com) +# Modified by Ke Sun (sunk@mail.ustc.edu.cn) +# Modified by Zhongdao Wang(wcd17@mails.tsinghua.edu.cn) +# ------------------------------------------------------------------------------ + +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function + +import os +import pdb +import logging +import functools + +import numpy as np + +import torch +import torch.nn as nn +import torch._utils +import torch.nn.functional as F + +BN_MOMENTUM = 0.1 +logger = logging.getLogger(__name__) + + +def conv3x3(in_planes, out_planes, stride=1): + """3x3 convolution with padding""" + return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, + padding=1, bias=False) + + +class BasicBlock(nn.Module): + expansion = 1 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(BasicBlock, self).__init__() + self.conv1 = conv3x3(inplanes, planes, stride) + self.bn1 = nn.BatchNorm2d(planes, momentum=BN_MOMENTUM) + self.relu = nn.ReLU(inplace=True) + self.conv2 = conv3x3(planes, planes) + self.bn2 = nn.BatchNorm2d(planes, momentum=BN_MOMENTUM) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class Bottleneck(nn.Module): + expansion = 4 + + def __init__(self, inplanes, planes, stride=1, downsample=None): + super(Bottleneck, self).__init__() + self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False) + self.bn1 = nn.BatchNorm2d(planes, momentum=BN_MOMENTUM) + self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, + padding=1, bias=False) + self.bn2 = nn.BatchNorm2d(planes, momentum=BN_MOMENTUM) + self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, + bias=False) + self.bn3 = nn.BatchNorm2d(planes * self.expansion, + momentum=BN_MOMENTUM) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + self.stride = stride + + def forward(self, x): + residual = x + + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + + out = self.conv3(out) + out = self.bn3(out) + + if self.downsample is not None: + residual = self.downsample(x) + + out += residual + out = self.relu(out) + + return out + + +class HighResolutionModule(nn.Module): + def __init__(self, num_branches, blocks, num_blocks, num_inchannels, + num_channels, fuse_method, multi_scale_output=True): + super(HighResolutionModule, self).__init__() + self._check_branches( + num_branches, blocks, num_blocks, num_inchannels, num_channels) + + self.num_inchannels = num_inchannels + self.fuse_method = fuse_method + self.num_branches = num_branches + + self.multi_scale_output = multi_scale_output + + self.branches = self._make_branches( + num_branches, blocks, num_blocks, num_channels) + self.fuse_layers = self._make_fuse_layers() + self.relu = nn.ReLU(False) + + def _check_branches(self, num_branches, blocks, num_blocks, + num_inchannels, num_channels): + if num_branches != len(num_blocks): + error_msg = 'NUM_BRANCHES({}) <> NUM_BLOCKS({})'.format( + num_branches, len(num_blocks)) + logger.error(error_msg) + raise ValueError(error_msg) + + if num_branches != len(num_channels): + error_msg = 'NUM_BRANCHES({}) <> NUM_CHANNELS({})'.format( + num_branches, len(num_channels)) + logger.error(error_msg) + raise ValueError(error_msg) + + if num_branches != len(num_inchannels): + error_msg = 'NUM_BRANCHES({}) <> NUM_INCHANNELS({})'.format( + num_branches, len(num_inchannels)) + logger.error(error_msg) + raise ValueError(error_msg) + + def _make_one_branch(self, branch_index, block, num_blocks, num_channels, + stride=1): + downsample = None + if stride != 1 or \ + self.num_inchannels[branch_index] != num_channels[branch_index] * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(self.num_inchannels[branch_index], + num_channels[branch_index] * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm2d(num_channels[branch_index] * block.expansion, + momentum=BN_MOMENTUM), + ) + + layers = [] + layers.append(block(self.num_inchannels[branch_index], + num_channels[branch_index], stride, downsample)) + self.num_inchannels[branch_index] = \ + num_channels[branch_index] * block.expansion + for i in range(1, num_blocks[branch_index]): + layers.append(block(self.num_inchannels[branch_index], + num_channels[branch_index])) + + return nn.Sequential(*layers) + + def _make_branches(self, num_branches, block, num_blocks, num_channels): + branches = [] + + for i in range(num_branches): + branches.append( + self._make_one_branch(i, block, num_blocks, num_channels)) + + return nn.ModuleList(branches) + + def _make_fuse_layers(self): + if self.num_branches == 1: + return None + + num_branches = self.num_branches + num_inchannels = self.num_inchannels + fuse_layers = [] + for i in range(num_branches if self.multi_scale_output else 1): + fuse_layer = [] + for j in range(num_branches): + if j > i: + fuse_layer.append(nn.Sequential( + nn.Conv2d(num_inchannels[j], + num_inchannels[i], + 1, + 1, + 0, + bias=False), + nn.BatchNorm2d(num_inchannels[i], + momentum=BN_MOMENTUM), + nn.Upsample(scale_factor=2**(j-i), mode='nearest'))) + elif j == i: + fuse_layer.append(None) + else: + conv3x3s = [] + for k in range(i-j): + if k == i - j - 1: + num_outchannels_conv3x3 = num_inchannels[i] + conv3x3s.append(nn.Sequential( + nn.Conv2d(num_inchannels[j], + num_outchannels_conv3x3, + 3, 2, 1, bias=False), + nn.BatchNorm2d(num_outchannels_conv3x3, + momentum=BN_MOMENTUM))) + else: + num_outchannels_conv3x3 = num_inchannels[j] + conv3x3s.append(nn.Sequential( + nn.Conv2d(num_inchannels[j], + num_outchannels_conv3x3, + 3, 2, 1, bias=False), + nn.BatchNorm2d(num_outchannels_conv3x3, + momentum=BN_MOMENTUM), + nn.ReLU(False))) + fuse_layer.append(nn.Sequential(*conv3x3s)) + fuse_layers.append(nn.ModuleList(fuse_layer)) + + return nn.ModuleList(fuse_layers) + + def get_num_inchannels(self): + return self.num_inchannels + + def forward(self, x): + if self.num_branches == 1: + return [self.branches[0](x[0])] + + for i in range(self.num_branches): + x[i] = self.branches[i](x[i]) + + x_fuse = [] + for i in range(len(self.fuse_layers)): + y = x[0] if i == 0 else self.fuse_layers[i][0](x[0]) + for j in range(1, self.num_branches): + if i == j: + y = y + x[j] + else: + fused = self.fuse_layers[i][j](x[j]) + fh, fw = fused.shape[-2:] + yh, yw = y.shape[-2:] + if fh > yh: + fused = fused[:,:,(fh-yh)//2:-(fh-yh)//2,:] + if fw > yw: + fused = fused[:,:,:,(fw-yw)//2:-(fw-yw)//2] + y = y + fused + x_fuse.append(self.relu(y)) + + return x_fuse + + +blocks_dict = { + 'BASIC': BasicBlock, + 'BOTTLENECK': Bottleneck +} + + +class HighResolutionNet(nn.Module): + + def __init__(self, cfg, **kwargs): + super(HighResolutionNet, self).__init__() + self.cfg = cfg + + self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1, + bias=False) + self.bn1 = nn.BatchNorm2d(64, momentum=BN_MOMENTUM) + self.conv2 = nn.Conv2d(64, 64, kernel_size=3, stride=2, padding=1, + bias=False) + self.bn2 = nn.BatchNorm2d(64, momentum=BN_MOMENTUM) + self.relu = nn.ReLU(inplace=True) + + self.stage1_cfg = cfg['MODEL']['EXTRA']['STAGE1'] + num_channels = self.stage1_cfg['NUM_CHANNELS'][0] + block = blocks_dict[self.stage1_cfg['BLOCK']] + num_blocks = self.stage1_cfg['NUM_BLOCKS'][0] + self.layer1 = self._make_layer(block, 64, num_channels, num_blocks) + stage1_out_channel = block.expansion*num_channels + + self.stage2_cfg = cfg['MODEL']['EXTRA']['STAGE2'] + num_channels = self.stage2_cfg['NUM_CHANNELS'] + block = blocks_dict[self.stage2_cfg['BLOCK']] + num_channels = [ + num_channels[i] * block.expansion for i in range(len(num_channels))] + self.transition1 = self._make_transition_layer( + [stage1_out_channel], num_channels) + self.stage2, pre_stage_channels = self._make_stage( + self.stage2_cfg, num_channels) + + self.stage3_cfg = cfg['MODEL']['EXTRA']['STAGE3'] + num_channels = self.stage3_cfg['NUM_CHANNELS'] + block = blocks_dict[self.stage3_cfg['BLOCK']] + num_channels = [ + num_channels[i] * block.expansion for i in range(len(num_channels))] + self.transition2 = self._make_transition_layer( + pre_stage_channels, num_channels) + self.stage3, pre_stage_channels = self._make_stage( + self.stage3_cfg, num_channels) + + self.stage4_cfg = cfg['MODEL']['EXTRA']['STAGE4'] + num_channels = self.stage4_cfg['NUM_CHANNELS'] + block = blocks_dict[self.stage4_cfg['BLOCK']] + num_channels = [ + num_channels[i] * block.expansion for i in range(len(num_channels))] + self.transition3 = self._make_transition_layer( + pre_stage_channels, num_channels) + self.stage4, pre_stage_channels = self._make_stage( + self.stage4_cfg, num_channels, multi_scale_output=True) + + # Classification Head + self.incre_modules, self.downsamp_modules, \ + self.final_layer = self._make_head(pre_stage_channels) + + self.classifier = nn.Linear(2048, 1000) + + def _make_head(self, pre_stage_channels): + head_block = Bottleneck + head_channels = [32, 64, 128, 256] + + # Increasing the #channels on each resolution + # from C, 2C, 4C, 8C to 128, 256, 512, 1024 + incre_modules = [] + for i, channels in enumerate(pre_stage_channels): + incre_module = self._make_layer(head_block, + channels, + head_channels[i], + 1, + stride=1) + incre_modules.append(incre_module) + incre_modules = nn.ModuleList(incre_modules) + + # downsampling modules + downsamp_modules = [] + for i in range(len(pre_stage_channels)-1): + in_channels = head_channels[i] * head_block.expansion + out_channels = head_channels[i+1] * head_block.expansion + + downsamp_module = nn.Sequential( + nn.Conv2d(in_channels=in_channels, + out_channels=out_channels, + kernel_size=3, + stride=2, + padding=1), + nn.BatchNorm2d(out_channels, momentum=BN_MOMENTUM), + nn.ReLU(inplace=True) + ) + + downsamp_modules.append(downsamp_module) + downsamp_modules = nn.ModuleList(downsamp_modules) + + final_layer = nn.Sequential( + nn.Conv2d( + in_channels=head_channels[3] * head_block.expansion, + out_channels=2048, + kernel_size=1, + stride=1, + padding=0 + ), + nn.BatchNorm2d(2048, momentum=BN_MOMENTUM), + nn.ReLU(inplace=True) + ) + + return incre_modules, downsamp_modules, final_layer + + def _make_transition_layer( + self, num_channels_pre_layer, num_channels_cur_layer): + num_branches_cur = len(num_channels_cur_layer) + num_branches_pre = len(num_channels_pre_layer) + + transition_layers = [] + for i in range(num_branches_cur): + if i < num_branches_pre: + if num_channels_cur_layer[i] != num_channels_pre_layer[i]: + transition_layers.append(nn.Sequential( + nn.Conv2d(num_channels_pre_layer[i], + num_channels_cur_layer[i], + 3, + 1, + 1, + bias=False), + nn.BatchNorm2d( + num_channels_cur_layer[i], momentum=BN_MOMENTUM), + nn.ReLU(inplace=True))) + else: + transition_layers.append(None) + else: + conv3x3s = [] + for j in range(i+1-num_branches_pre): + inchannels = num_channels_pre_layer[-1] + outchannels = num_channels_cur_layer[i] \ + if j == i-num_branches_pre else inchannels + conv3x3s.append(nn.Sequential( + nn.Conv2d( + inchannels, outchannels, 3, 2, 1, bias=False), + nn.BatchNorm2d(outchannels, momentum=BN_MOMENTUM), + nn.ReLU(inplace=True))) + transition_layers.append(nn.Sequential(*conv3x3s)) + + return nn.ModuleList(transition_layers) + + def _make_layer(self, block, inplanes, planes, blocks, stride=1): + downsample = None + if stride != 1 or inplanes != planes * block.expansion: + downsample = nn.Sequential( + nn.Conv2d(inplanes, planes * block.expansion, + kernel_size=1, stride=stride, bias=False), + nn.BatchNorm2d(planes * block.expansion, momentum=BN_MOMENTUM), + ) + + layers = [] + layers.append(block(inplanes, planes, stride, downsample)) + inplanes = planes * block.expansion + for i in range(1, blocks): + layers.append(block(inplanes, planes)) + + return nn.Sequential(*layers) + + def _make_stage(self, layer_config, num_inchannels, + multi_scale_output=True): + num_modules = layer_config['NUM_MODULES'] + num_branches = layer_config['NUM_BRANCHES'] + num_blocks = layer_config['NUM_BLOCKS'] + num_channels = layer_config['NUM_CHANNELS'] + block = blocks_dict[layer_config['BLOCK']] + fuse_method = layer_config['FUSE_METHOD'] + + modules = [] + for i in range(num_modules): + # multi_scale_output is only used last module + if not multi_scale_output and i == num_modules - 1: + reset_multi_scale_output = False + else: + reset_multi_scale_output = True + + modules.append( + HighResolutionModule(num_branches, + block, + num_blocks, + num_inchannels, + num_channels, + fuse_method, + reset_multi_scale_output) + ) + num_inchannels = modules[-1].get_num_inchannels() + + return nn.Sequential(*modules), num_inchannels + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = self.conv2(x) + x = self.bn2(x) + x = self.relu(x) + x = self.layer1(x) + + x_list = [] + for i in range(self.stage2_cfg['NUM_BRANCHES']): + if self.transition1[i] is not None: + x_list.append(self.transition1[i](x)) + else: + x_list.append(x) + y_list = self.stage2(x_list) + + x_list = [] + for i in range(self.stage3_cfg['NUM_BRANCHES']): + if self.transition2[i] is not None: + x_list.append(self.transition2[i](y_list[-1])) + else: + x_list.append(y_list[i]) + y_list = self.stage3(x_list) + + x_list = [] + for i in range(self.stage4_cfg['NUM_BRANCHES']): + if self.transition3[i] is not None: + x_list.append(self.transition3[i](y_list[-1])) + else: + x_list.append(y_list[i]) + y_list = self.stage4(x_list) + + # Classification Head + y_list_out = {} + y_list_out[0] = self.incre_modules[0](y_list[0]) + for i in range(len(self.downsamp_modules)): + y_list_out[i+1] = self.incre_modules[i+1](y_list[i+1]) + \ + self.downsamp_modules[i](y_list_out[i]) + + #y = self.final_layer(y) + + ret = y_list_out[self.cfg['MODEL']['RETURN_STAGE']] + + ret_size = y_list_out[1].shape[-2:] + ret = F.interpolate(ret, ret_size, mode='bilinear') + return ret + + def init_weights(self, pretrained='',): + print('=> init weights from normal distribution') + for m in self.modules(): + if isinstance(m, nn.Conv2d): + nn.init.kaiming_normal_( + m.weight, mode='fan_out', nonlinearity='relu') + elif isinstance(m, nn.BatchNorm2d): + nn.init.constant_(m.weight, 1) + nn.init.constant_(m.bias, 0) + if os.path.isfile(pretrained): + pretrained_dict = torch.load(pretrained) + print('=> loading pretrained model {}'.format(pretrained)) + model_dict = self.state_dict() + pretrained_dict = {k: v for k, v in pretrained_dict.items() + if k in model_dict.keys()} + for k, _ in pretrained_dict.items(): + print( + '=> loading {} pretrained model {}'.format(k, pretrained)) + model_dict.update(pretrained_dict) + self.load_state_dict(model_dict) + + +config = { +'hrnet_w18': { + 'MODEL':{ + 'EXTRA':{ + 'STAGE1':{ + 'NUM_MODULES':1, + 'NUM_BRANCHES':1, + 'BLOCK': 'BOTTLENECK', + 'NUM_BLOCKS':[4,], + 'NUM_CHANNELS':[64,], + 'FUSE_METHOD': 'SUM', + }, + 'STAGE2':{ + 'NUM_MODULES':1, + 'NUM_BRANCHES':2, + 'BLOCK': 'BASIC', + 'NUM_BLOCKS':[4,4,], + 'NUM_CHANNELS':[18, 36], + 'FUSE_METHOD': 'SUM', + }, + 'STAGE3':{ + 'NUM_MODULES':4, + 'NUM_BRANCHES':3, + 'BLOCK': 'BASIC', + 'NUM_BLOCKS':[4,4,4], + 'NUM_CHANNELS':[18, 36, 72], + 'FUSE_METHOD': 'SUM', + }, + 'STAGE4':{ + 'NUM_MODULES':3, + 'NUM_BRANCHES':4, + 'BLOCK': 'BASIC', + 'NUM_BLOCKS':[4,4,4,4], + 'NUM_CHANNELS':[18, 36, 72, 144], + 'FUSE_METHOD': 'SUM', + }, + } + } + }, +'hrnet_w32': { + 'MODEL':{ + 'EXTRA':{ + 'STAGE1':{ + 'NUM_MODULES':1, + 'NUM_BRANCHES':1, + 'BLOCK': 'BOTTLENECK', + 'NUM_BLOCKS':[4,], + 'NUM_CHANNELS':[64,], + 'FUSE_METHOD': 'SUM', + }, + 'STAGE2':{ + 'NUM_MODULES':1, + 'NUM_BRANCHES':2, + 'BLOCK': 'BASIC', + 'NUM_BLOCKS':[4,4,], + 'NUM_CHANNELS':[32, 64], + 'FUSE_METHOD': 'SUM', + }, + 'STAGE3':{ + 'NUM_MODULES':4, + 'NUM_BRANCHES':3, + 'BLOCK': 'BASIC', + 'NUM_BLOCKS':[4,4,4], + 'NUM_CHANNELS':[32, 64, 128], + 'FUSE_METHOD': 'SUM', + }, + 'STAGE4':{ + 'NUM_MODULES':3, + 'NUM_BRANCHES':4, + 'BLOCK': 'BASIC', + 'NUM_BLOCKS':[4,4,4,4], + 'NUM_CHANNELS':[32, 64, 128, 256], + 'FUSE_METHOD': 'SUM', + }, + } + } + } +} + +def get_cls_net(c, **kwargs): + cfg = config[c] + cfg['MODEL']['RETURN_STAGE'] = kwargs['return_stage'] + model = HighResolutionNet(cfg, **kwargs) + model.init_weights(pretrained=kwargs['pretrained']) + return model + +if __name__ == '__main__': + net = get_cls_net('hrnet_w18', return_stage=2, pretrained='../weights/hrnetv2_w18_imagenet.pth') + pdb.set_trace() diff --git a/OpenPVSG/models/unitrack/model/model.py b/OpenPVSG/models/unitrack/model/model.py new file mode 100644 index 0000000000000000000000000000000000000000..f97cc846c5925d029998c3a1e93a2a7771742975 --- /dev/null +++ b/OpenPVSG/models/unitrack/model/model.py @@ -0,0 +1,147 @@ +import imp +import pdb +import os.path as osp + +import torch +import torch.nn as nn + +from models.unitrack.model import resnet +from models.unitrack.model import hrnet +from models.unitrack.model import random_feat_generator + +class AppearanceModel(nn.Module): + def __init__(self, tracker_cfg): + super(AppearanceModel, self).__init__() + self.tracker_cfg = tracker_cfg + + self.model = make_encoder(tracker_cfg).to(self.tracker_cfg.common.device) + def forward(self, x): + z = self.model(x) + return z + +def partial_load(pretrained_dict, model, skip_keys=[], log=False): + model_dict = model.state_dict() + + # 1. filter out unnecessary keys + filtered_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict and not any([sk in k for sk in skip_keys])} + skipped_keys = [k for k in pretrained_dict if k not in filtered_dict] + unload_keys = [k for k in model_dict if k not in pretrained_dict] + + # 2. overwrite entries in the existing state dict + model_dict.update(filtered_dict) + + # 3. load the new state dict + model.load_state_dict(model_dict) + + if log: + print('\nSkipped keys: ', skipped_keys) + print('\nLoading keys: ', filtered_dict.keys()) + print('\nUnLoaded keys: ', unload_keys) + +def load_vince_model(path): + checkpoint = torch.load(path, map_location={'cuda:0': 'cpu'}) + checkpoint = {k.replace('feature_extractor.module.model.', ''): checkpoint[k] for k in checkpoint if 'feature_extractor' in k} + return checkpoint + + +def load_uvc_model(ckpt_path): + net = resnet.resnet18() + net.avgpool, net.fc = None, None + + ckpt = torch.load(ckpt_path, map_location='cpu') + state_dict = {k.replace('module.gray_encoder.', ''):v for k,v in ckpt['state_dict'].items() if 'gray_encoder' in k} + partial_load(state_dict, net) + + return net + + +def load_tc_model(ckpt_path): + model_state = torch.load(ckpt_path, map_location='cpu')['state_dict'] + + net = resnet.resnet50() + net_state = net.state_dict() + + for k in [k for k in model_state.keys() if 'encoderVideo' in k]: + kk = k.replace('module.encoderVideo.', '') + tmp = model_state[k] + if net_state[kk].shape != model_state[k].shape and net_state[kk].dim() == 4 and model_state[k].dim() == 5: + tmp = model_state[k].squeeze(2) + net_state[kk][:] = tmp[:] + + net.load_state_dict(net_state) + + return net + +class From3D(nn.Module): + ''' Use a 2D convnet as a 3D convnet ''' + def __init__(self, resnet): + super(From3D, self).__init__() + self.model = resnet + + def forward(self, x): + N, C, T, h, w = x.shape + xx = x.permute(0, 2, 1, 3, 4).contiguous().view(-1, C, h, w) + m = self.model(xx) + + return m.view(N, T, *m.shape[-3:]).permute(0, 2, 1, 3, 4) + + +def make_encoder(tracker_cfg): + SSL_MODELS = ['byol', 'deepcluster-v2', 'infomin', 'insdis', 'moco-v1', 'moco-v2', + 'pcl-v1', 'pcl-v2','pirl', 'sela-v2', 'swav', 'simclr-v1', 'simclr-v2', + 'pixpro', 'detco', 'barlowtwins'] + model_type = tracker_cfg.common.model_type + if model_type == 'crw': + net = resnet.resnet18() + if osp.isfile(tracker_cfg.common.resume): + ckpt = torch.load(tracker_cfg.common.resume) + state = {} + for k, v in ckpt['model'].items(): + if 'conv1.1.weight' in k or 'conv2.1.weight' in k: + state[k.replace('.1.weight', '.weight')] = v + if 'encoder.model' in k: + state[k.replace('encoder.model.', '')] = v + else: + state[k] = v + partial_load(state, net, skip_keys=['head',]) + del ckpt + elif model_type == 'random18': + net = resnet.resnet18(pretrained=False) + elif model_type == 'random50': + net = resnet.resnet50(pretrained=False) + elif model_type == 'imagenet18': + net = resnet.resnet18(pretrained=True) + elif model_type == 'imagenet50': + net = resnet.resnet50(pretrained=True) + elif model_type == 'imagenet101': + net = resnet.resnet101(pretrained=True) + elif model_type == 'imagenet_resnext50': + net = resnet.resnext50_32x4d(pretrained=True) + elif model_type == 'imagenet_resnext101': + net = resnet.resnext101_32x8d(pretrained=True) + elif model_type == 'mocov2': + net = resnet.resnet50(pretrained=False) + net_ckpt = torch.load(tracker_cfg.common.resume) + net_state = {k.replace('module.encoder_q.', ''):v for k,v in net_ckpt['state_dict'].items() \ + if 'module.encoder_q' in k} + partial_load(net_state, net) + elif model_type == 'uvc': + net = load_uvc_model(tracker_cfg.common.resume) + elif model_type == 'timecycle': + net = load_tc_model(tracker_cfg.common.resume) + elif model_type in SSL_MODELS: + net = resnet.resnet50(pretrained=False) + net_ckpt = torch.load(tracker_cfg.common.resume) + partial_load(net_ckpt, net) + elif 'hrnet' in model_type: + net = hrnet.get_cls_net(model_type, return_stage=tracker_cfg.common.return_stage, pretrained=tracker_cfg.common.resume) + elif model_type == 'random': + net = random_feat_generator.RandomFeatGenerator(tracker_cfg) + else: + raise ValueError('Invalid model_type.') + if hasattr(net, 'modify'): + net.modify(remove_layers=tracker_cfg.common.remove_layers) + + if 'Conv2d' in str(net) and not tracker_cfg.common.infer2D: + net = From3D(net) + return net diff --git a/OpenPVSG/models/unitrack/model/random_feat_generator.py b/OpenPVSG/models/unitrack/model/random_feat_generator.py new file mode 100644 index 0000000000000000000000000000000000000000..d22a470262cb6e458bc2bf54843031c22c7727d7 --- /dev/null +++ b/OpenPVSG/models/unitrack/model/random_feat_generator.py @@ -0,0 +1,37 @@ +################################################################### +# File Name: random_feat_generator.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Mon May 10 16:13:46 2021 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + +import torch +import torch.nn as nn + +class RandomFeatGenerator(nn.Module): + def __init__(self, tracker_cfg): + super(RandomFeatGenerator, self).__init__() + self.df = tracker_cfg.common.down_factor + self.dim = tracker_cfg.common.dim + self.dummy = nn.Linear(2,3) + def forward(self, x): + if len(x.shape) == 4: + N,C,H,W = x.shape + elif len(x.shape) == 5: + N,C,T,H,W = x.shape + else: + raise ValueError + c, h, w = self.dim, round(H/self.df), round(W/self.df) + + if len(x.shape) == 4: + feat = torch.rand(N,c,h,w).cuda() + elif len(x.shape) == 5: + feat = torch.rand(N,c,T,h,w).cuda() + return feat + + def __str__(self): + return '' diff --git a/OpenPVSG/models/unitrack/model/resnet.py b/OpenPVSG/models/unitrack/model/resnet.py new file mode 100644 index 0000000000000000000000000000000000000000..8fa1aa74bdf7a18c2d852e833efeca670055834d --- /dev/null +++ b/OpenPVSG/models/unitrack/model/resnet.py @@ -0,0 +1,160 @@ +import torch +import torch.nn as nn +import torch.nn.functional as F +try: + from torch.hub import load_state_dict_from_url +except ImportError: + from torch.utils.model_zoo import load_url as load_state_dict_from_url + +import torchvision.models.resnet as torch_resnet +from torchvision.models.resnet import BasicBlock, Bottleneck +from mmdet.models.builder import BACKBONES + +model_urls = {'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth', + 'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth', + 'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth', + 'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth', + 'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth', + 'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth', + 'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth', + 'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth', + 'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth', +} + + +BACKBONES.register_module() +class ResNet(torch_resnet.ResNet): + def __init__(self, *args, **kwargs): + super(ResNet, self).__init__(*args, **kwargs) + + def modify(self, remove_layers=[], padding=''): + # Set stride of layer3 and layer 4 to 1 (from 2) + filter_layers = lambda x: [l for l in x if getattr(self, l) is not None] + for layer in filter_layers(['layer3', 'layer4']): + for m in getattr(self, layer).modules(): + if isinstance(m, torch.nn.Conv2d): + m.stride = tuple(1 for _ in m.stride) + # Set padding (zeros or reflect, doesn't change much; + # zeros requires lower temperature) + if padding != '' and padding != 'no': + for m in self.modules(): + if isinstance(m, torch.nn.Conv2d) and sum(m.padding) > 0: + m.padding_mode = padding + elif padding == 'no': + for m in self.modules(): + if isinstance(m, torch.nn.Conv2d) and sum(m.padding) > 0: + m.padding = (0,0) + + # Remove extraneous layers + remove_layers += ['fc', 'avgpool'] + for layer in filter_layers(remove_layers): + setattr(self, layer, None) + + def forward(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + x = x if self.maxpool is None else self.maxpool(x) + + x = self.layer1(x) + x = F.avg_pool2d(x,(2,2)) if self.layer2 is None else self.layer2(x) + x = x if self.layer3 is None else self.layer3(x) + x = x if self.layer4 is None else self.layer4(x) + + return x + + +def _resnet(arch, block, layers, pretrained, progress, **kwargs): + model = ResNet(block, layers, **kwargs) + if pretrained: + state_dict = load_state_dict_from_url(model_urls[arch], + progress=progress) + model.load_state_dict(state_dict) + return model + +def resnet18(pretrained=False, progress=True, **kwargs): + return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress, + **kwargs) + +def resnet50(pretrained=False, progress=True, **kwargs) -> ResNet: + return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress, + **kwargs) + +def resnet101(pretrained=False, progress=True, **kwargs): + return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress, + **kwargs) + +def resnet152(pretrained=False, progress=True, **kwargs): + r"""ResNet-152 model from + `"Deep Residual Learning for Image Recognition" `_ + + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + progress (bool): If True, displays a progress bar of the download to stderr + """ + return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress, + **kwargs) + + +def resnext50_32x4d(pretrained=False, progress=True, **kwargs): + r"""ResNeXt-50 32x4d model from + `"Aggregated Residual Transformation for Deep Neural Networks" `_ + + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + progress (bool): If True, displays a progress bar of the download to stderr + """ + kwargs['groups'] = 32 + kwargs['width_per_group'] = 4 + return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3], + pretrained, progress, **kwargs) + + +def resnext101_32x8d(pretrained=False, progress=True, **kwargs): + r"""ResNeXt-101 32x8d model from + `"Aggregated Residual Transformation for Deep Neural Networks" `_ + + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + progress (bool): If True, displays a progress bar of the download to stderr + """ + kwargs['groups'] = 32 + kwargs['width_per_group'] = 8 + return _resnet('resnext101_32x8d', Bottleneck, [3, 4, 23, 3], + pretrained, progress, **kwargs) + + +def wide_resnet50_2(pretrained=False, progress=True, **kwargs): + r"""Wide ResNet-50-2 model from + `"Wide Residual Networks" `_ + + The model is the same as ResNet except for the bottleneck number of channels + which is twice larger in every block. The number of channels in outer 1x1 + convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048 + channels, and in Wide ResNet-50-2 has 2048-1024-2048. + + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + progress (bool): If True, displays a progress bar of the download to stderr + """ + kwargs['width_per_group'] = 64 * 2 + return _resnet('wide_resnet50_2', Bottleneck, [3, 4, 6, 3], + pretrained, progress, **kwargs) + + +def wide_resnet101_2(pretrained=False, progress=True, **kwargs): + r"""Wide ResNet-101-2 model from + `"Wide Residual Networks" `_ + + The model is the same as ResNet except for the bottleneck number of channels + which is twice larger in every block. The number of channels in outer 1x1 + convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048 + channels, and in Wide ResNet-50-2 has 2048-1024-2048. + + Args: + pretrained (bool): If True, returns a model pre-trained on ImageNet + progress (bool): If True, displays a progress bar of the download to stderr + """ + kwargs['width_per_group'] = 64 * 2 + return _resnet('wide_resnet101_2', Bottleneck, [3, 4, 23, 3], + pretrained, progress, **kwargs) diff --git a/OpenPVSG/models/unitrack/utils/__init__.py b/OpenPVSG/models/unitrack/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..468c36049360e6db978f97d432e248b84d81dd40 --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/__init__.py @@ -0,0 +1,46 @@ +from collections import defaultdict, deque +import datetime +import time +import torch + +import errno +import os +import pdb +import sys + +from . import visualize +from . import box +from . import meter +from . import log +from . import io + +import numpy as np +from torch import nn +from torch.nn import functional as F + + +def to_numpy(tensor): + if torch.is_tensor(tensor): + return tensor.cpu().numpy() + elif type(tensor).__module__ != 'numpy': + raise ValueError("Cannot convert {} to numpy array" + .format(type(tensor))) + return tensor + +def to_torch(ndarray): + if type(ndarray).__module__ == 'numpy': + return torch.from_numpy(ndarray) + elif not torch.is_tensor(ndarray): + raise ValueError("Cannot convert {} to torch tensor" + .format(type(ndarray))) + return ndarray + +def im_to_numpy(img): + img = to_numpy(img) + img = np.transpose(img, (1, 2, 0)) # H*W*C + return img + +def im_to_torch(img): + img = np.transpose(img, (2, 0, 1)) # C*H*W + img = to_torch(img).float() + return img diff --git a/OpenPVSG/models/unitrack/utils/box.py b/OpenPVSG/models/unitrack/utils/box.py new file mode 100644 index 0000000000000000000000000000000000000000..9efb136fa3fcf74854d0b60c9cc9c9214a125323 --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/box.py @@ -0,0 +1,169 @@ +################################################################### +# File Name: box.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Wed Dec 23 16:27:15 2020 +################################################################### + +import torch +import torchvision +import numpy as np + + +def xyxy2xywh(x): + # Convert bounding box format from [x1, y1, x2, y2] to [x, y, w, h] + y = x.clone() if x.dtype is torch.float32 else x.copy() + y[:, 0] = (x[:, 0] + x[:, 2]) / 2 + y[:, 1] = (x[:, 1] + x[:, 3]) / 2 + y[:, 2] = x[:, 2] - x[:, 0] + y[:, 3] = x[:, 3] - x[:, 1] + return y + + +def xywh2xyxy(x): + # Convert bounding box format from [x, y, w, h] to [x1, y1, x2, y2] + y = x.clone() if x.dtype is torch.float32 else x.copy() + y[:, 0] = (x[:, 0] - x[:, 2] / 2) + y[:, 1] = (x[:, 1] - x[:, 3] / 2) + y[:, 2] = (x[:, 0] + x[:, 2] / 2) + y[:, 3] = (x[:, 1] + x[:, 3] / 2) + return y + + +def tlwh2xyxy(x): + # Convert bounding box format from [x, y, w, h] to [x1, y1, x2, y2] + y = x.clone() if x.dtype is torch.float32 else x.copy() + y[:, 2] = (x[:, 0] + x[:, 2]) + y[:, 3] = (x[:, 1] + x[:, 3]) + return y + + +def tlwh_to_xywh(tlwh): + ret = np.asarray(tlwh).copy() + ret[:2] += ret[2:] / 2 + return ret + + +def tlwh_to_xyah(tlwh): + """Convert bounding box to format `(center x, center y, aspect ratio, + height)`, where the aspect ratio is `width / height`. + """ + ret = np.asarray(tlwh).copy() + ret[:2] += ret[2:] / 2 + ret[2] /= (ret[3] + 1e-6) + return ret + + +def tlbr_to_tlwh(tlbr): + ret = np.asarray(tlbr).copy() + ret[2:] -= ret[:2] + return ret + + +def tlwh_to_tlbr(tlwh): + ret = np.asarray(tlwh).copy() + ret[2:] += ret[:2] + return ret + + +def scale_box(scale, coords): + c = coords.clone() + c[:, [0, 2]] = coords[:, [0, 2]] * scale[0] + c[:, [1, 3]] = coords[:, [1, 3]] * scale[1] + return c + + +def scale_box_letterbox_size(img_size, coords, img0_shape): + gain_w = float(img_size[0]) / img0_shape[1] # gain = old / new + gain_h = float(img_size[1]) / img0_shape[0] + gain = min(gain_w, gain_h) + pad_x = (img_size[0] - img0_shape[1] * gain) / 2 # width padding + pad_y = (img_size[1] - img0_shape[0] * gain) / 2 # height padding + coords[:, 0:4] *= gain + coords[:, [0, 2]] += pad_x + coords[:, [1, 3]] += pad_y + return coords + + +def scale_box_input_size(img_size, coords, img0_shape): + # Rescale x1, y1, x2, y2 from 416 to image size + gain_w = float(img_size[0]) / img0_shape[1] # gain = old / new + gain_h = float(img_size[1]) / img0_shape[0] + gain = min(gain_w, gain_h) + pad_x = (img_size[0] - img0_shape[1] * gain) / 2 # width padding + pad_y = (img_size[1] - img0_shape[0] * gain) / 2 # height padding + coords[:, [0, 2]] -= pad_x + coords[:, [1, 3]] -= pad_y + coords[:, 0:4] /= gain + return coords + + +def clip_boxes(boxes, im_shape): + """ + Clip boxes to image boundaries. + """ + boxes = np.asarray(boxes) + if boxes.shape[0] == 0: + return boxes + boxes = np.copy(boxes) + # x1 >= 0 + boxes[:, 0::4] = np.maximum(np.minimum(boxes[:, 0::4], im_shape[1] - 1), 0) + # y1 >= 0 + boxes[:, 1::4] = np.maximum(np.minimum(boxes[:, 1::4], im_shape[0] - 1), 0) + # x2 < im_shape[1] + boxes[:, 2::4] = np.maximum(np.minimum(boxes[:, 2::4], im_shape[1] - 1), 0) + # y2 < im_shape[0] + boxes[:, 3::4] = np.maximum(np.minimum(boxes[:, 3::4], im_shape[0] - 1), 0) + return boxes + + +def clip_box(bbox, im_shape): + h, w = im_shape[:2] + bbox = np.copy(bbox) + bbox[0] = max(min(bbox[0], w - 1), 0) + bbox[1] = max(min(bbox[1], h - 1), 0) + bbox[2] = max(min(bbox[2], w - 1), 0) + bbox[3] = max(min(bbox[3], h - 1), 0) + + return bbox + + +def int_box(box): + box = np.asarray(box, dtype=np.float) + box = np.round(box) + return np.asarray(box, dtype=np.int) + + +def remove_duplicated_box(boxes, iou_th=0.5): + if isinstance(boxes, np.ndarray): + boxes = torch.from_numpy(boxes) + jac = torchvision.ops.box_iou(boxes, boxes).float() + jac -= torch.eye(jac.shape[0]) + keep = np.ones(len(boxes)) == 1 + for i, b in enumerate(boxes): + if b[0] == -1 and b[1] == -1 and b[2] == 10 and b[3] == 10: + keep[i] = False + for r, row in enumerate(jac): + if keep[r]: + discard = torch.where(row > iou_th) + keep[discard] = False + return np.where(keep)[0] + + +def skltn2box(skltn): + dskltn = dict() + for s in skltn: + dskltn[s['id'][0]] = (int(s['x'][0]), int(s['y'][0])) + if len(dskltn) == 0: + return np.array( + [-1, -1, np.random.randint(1, 40), np.random.randint(1, 70)]) + + xmin = np.min([dskltn[k][0] for k in dskltn]) + xmax = np.max([dskltn[k][0] for k in dskltn]) + ymin = np.min([dskltn[k][1] for k in dskltn]) + ymax = np.max([dskltn[k][1] for k in dskltn]) + if xmin == xmax: + xmax += 10 + if ymin == ymax: + ymax += 10 + return np.array([xmin, ymin, xmax, ymax]) diff --git a/OpenPVSG/models/unitrack/utils/io.py b/OpenPVSG/models/unitrack/utils/io.py new file mode 100644 index 0000000000000000000000000000000000000000..45206239320a56d239fbdd767033033edf14e6d0 --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/io.py @@ -0,0 +1,143 @@ +import os +import os.path as osp +from typing import Dict +import numpy as np +import pickle +from models.unitrack.data import query_feat_tracklet + +from models.unitrack.utils import log as log + +def mkdir_if_missing(d): + if not osp.exists(d): + os.makedirs(d) + +def write_mots_results(filename, results, data_type='mot'): + if not filename: + return + path = os.path.dirname(filename) + if not os.path.exists(path): + os.makedirs(path) + + if data_type in ('mot'): + save_format = '{frame} {id} {cid} {imh} {imw} {rle}\n' + else: + raise ValueError(data_type) + + with open(filename, 'w') as f: + for frame_id, tlwhs, rles, track_ids in results: + for rle, track_id in zip(rles, track_ids): + if track_id < 0: + continue + rle_str = rle['counts'] + imh, imw = rle['size'] + cid = rle['class_id'] + line = save_format.format(frame=frame_id, id=track_id, cid=cid, imh=imh, imw=imw, rle=rle_str) + f.write(line) + log.logger.info('Save results to {}'.format(filename)) + + +def write_mot_results(filename, results, data_type='mot'): + if not filename: + return + path = os.path.dirname(filename) + if not os.path.exists(path): + os.makedirs(path) + + if data_type in ('mot', 'mcmot', 'lab'): + save_format = '{frame},{id},{x1},{y1},{w},{h},1,-1,-1,-1\n' + elif data_type == 'kitti': + save_format = '{frame} {id} pedestrian -1 -1 -10 {x1} {y1} {x2} {y2} -1 -1 -1 -1000 -1000 -1000 -10 {score}\n' + else: + raise ValueError(data_type) + + with open(filename, 'w') as f: + for frame_id, tlwhs, track_ids in results: + if data_type == 'kitti': + frame_id -= 1 + for tlwh, track_id in zip(tlwhs, track_ids): + if track_id < 0: + continue + x1, y1, w, h = tlwh + x2, y2 = x1 + w, y1 + h + line = save_format.format(frame=frame_id, id=track_id, x1=x1, y1=y1, x2=x2, y2=y2, w=w, h=h) + f.write(line) + log.logger.info('Save results to {}'.format(filename)) + + +def read_mot_results(filename, data_type='mot', is_gt=False, is_ignore=False): + if data_type in ('mot', 'lab'): + read_fun = _read_mot_results + else: + raise ValueError('Unknown data type: {}'.format(data_type)) + + return read_fun(filename, is_gt, is_ignore) + + +""" +labels={'ped', ... % 1 +'person_on_vhcl', ... % 2 +'car', ... % 3 +'bicycle', ... % 4 +'mbike', ... % 5 +'non_mot_vhcl', ... % 6 +'static_person', ... % 7 +'distractor', ... % 8 +'occluder', ... % 9 +'occluder_on_grnd', ... %10 +'occluder_full', ... % 11 +'reflection', ... % 12 +'crowd' ... % 13 +}; +""" + + +def _read_mot_results(filename, is_gt, is_ignore): + valid_labels = {1} + ignore_labels = {2, 7, 8, 12} + results_dict = dict() + if os.path.isfile(filename): + with open(filename, 'r') as f: + for line in f.readlines(): + linelist = line.split(',') + if len(linelist) < 7: + continue + fid = int(linelist[0]) + if fid < 1: + continue + results_dict.setdefault(fid, list()) + + if is_gt: + if 'MOT16-' in filename or 'MOT17-' in filename: + label = int(float(linelist[7])) + mark = int(float(linelist[6])) + if mark == 0 or label not in valid_labels: + continue + score = 1 + elif is_ignore: + if 'MOT16-' in filename or 'MOT17-' in filename: + label = int(float(linelist[7])) + vis_ratio = float(linelist[8]) + if label not in ignore_labels and vis_ratio >= 0: + continue + else: + continue + score = 1 + else: + score = float(linelist[6]) + + tlwh = tuple(map(float, linelist[2:6])) + target_id = int(linelist[1]) + + results_dict[fid].append((tlwh, target_id, score)) + + return results_dict + + +def unzip_objs(objs): + if len(objs) > 0: + tlwhs, ids, scores = zip(*objs) + else: + tlwhs, ids, scores = [], [], [] + tlwhs = np.asarray(tlwhs, dtype=float).reshape(-1, 4) + + return tlwhs, ids, scores diff --git a/OpenPVSG/models/unitrack/utils/log.py b/OpenPVSG/models/unitrack/utils/log.py new file mode 100644 index 0000000000000000000000000000000000000000..394e1e8c9e1d8aa75fa6a55091b78bba22752cf5 --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/log.py @@ -0,0 +1,18 @@ +import logging + + +def get_logger(name='root'): + formatter = logging.Formatter( + # fmt='%(asctime)s [%(levelname)s]: %(filename)s(%(funcName)s:%(lineno)s) >> %(message)s') + fmt='%(asctime)s [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S') + + handler = logging.StreamHandler() + handler.setFormatter(formatter) + + logger = logging.getLogger(name) + logger.setLevel(logging.DEBUG) + logger.addHandler(handler) + return logger + + +logger = get_logger('root') diff --git a/OpenPVSG/models/unitrack/utils/mask.py b/OpenPVSG/models/unitrack/utils/mask.py new file mode 100644 index 0000000000000000000000000000000000000000..4bfdf22cce2bb40ffdc0ce03dbcf90cc37448240 --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/mask.py @@ -0,0 +1,232 @@ +################################################################### +# File Name: mask.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Tue Feb 9 10:05:47 2021 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import + +import cv2 +import torch +import numpy as np +import pycocotools.mask as mask_utils + + +def coords2bbox(coords, extend=2): + """ + INPUTS: + - coords: coordinates of pixels in the next frame + """ + center = torch.mean(coords, dim=0) # b * 2 + center = center.view(1,2) + center_repeat = center.repeat(coords.size(0),1) + + dis_x = torch.sqrt(torch.pow(coords[:,0] - center_repeat[:,0], 2)) + dis_x = max(torch.mean(dis_x, dim=0).detach(),1) + dis_y = torch.sqrt(torch.pow(coords[:,1] - center_repeat[:,1], 2)) + dis_y = max(torch.mean(dis_y, dim=0).detach(),1) + + left = center[:,0] - dis_x*extend + right = center[:,0] + dis_x*extend + top = center[:,1] - dis_y*extend + bottom = center[:,1] + dis_y*extend + + return (top.item(), left.item(), bottom.item(), right.item()) + + +def coords2bbox_all(coords): + left = coords[:, 0].min().item() + top = coords[:, 1].min().item() + right = coords[:, 0].max().item() + bottom = coords[:, 1].max().item() + return top, left, bottom, right + + +def coords2bboxTensor(coords, extend=2): + """ + INPUTS: + - coords: coordinates of pixels in the next frame + """ + center = torch.mean(coords, dim=0) # b * 2 + center = center.view(1,2) + center_repeat = center.repeat(coords.size(0),1) + + dis_x = torch.sqrt(torch.pow(coords[:,0] - center_repeat[:,0], 2)) + dis_x = max(torch.mean(dis_x, dim=0).detach(),1) + dis_y = torch.sqrt(torch.pow(coords[:,1] - center_repeat[:,1], 2)) + dis_y = max(torch.mean(dis_y, dim=0).detach(),1) + + left = center[:,0] - dis_x*extend + right = center[:,0] + dis_x*extend + top = center[:,1] - dis_y*extend + bottom = center[:,1] + dis_y*extend + + return torch.Tensor([top.item(), left.item(), bottom.item(), right.item()]).to(coords.device) + +def mask2box(masks): + boxes = [] + for mask in masks: + m = mask[0].nonzero().float() + if m.numel() > 0: + box = coords2bbox(m, extend=2) + else: + box = (-1,-1,10,10) + boxes.append(box) + return np.asarray(boxes) + +def tensor_mask2box(masks): + boxes = [] + for mask in masks: + m = mask.nonzero().float() + if m.numel() > 0: + # box = coords2bbox(m, extend=2) + box = coords2bbox_all(m) + else: + box = (-1,-1,10,10) + boxes.append(box) + return np.asarray(boxes) + +def batch_mask2boxlist(masks): + """ + Args: + masks: Tensor b,n,h,w + + Returns: List[List[box]] + + """ + batch_bbox = [] + for i, b_masks in enumerate(masks): + boxes = [] + for mask in b_masks: + m = mask.nonzero().float() + if m.numel() > 0: + box = coords2bboxTensor(m, extend=2) + else: + box = torch.Tensor([0,0,0,0]).to(m.device) + boxes.append(box.unsqueeze(0)) + boxes_t = torch.cat(boxes, 0) + batch_bbox.append(boxes_t) + + return batch_bbox + + +def bboxlist2roi(bbox_list): + """Convert a list of bboxes to roi format. + + Args: + bbox_list (list[Tensor]): a list of bboxes corresponding to a batch + of images. + + Returns: + Tensor: shape (n, 5), [batch_ind, x1, y1, x2, y2] + """ + rois_list = [] + for img_id, bboxes in enumerate(bbox_list): + if bboxes.size(0) > 0: + img_inds = bboxes.new_full((bboxes.size(0), 1), img_id) + rois = torch.cat([img_inds, bboxes[:, :4]], dim=-1) + else: + rois = bboxes.new_zeros((0, 5)) + rois_list.append(rois) + rois = torch.cat(rois_list, 0) + return rois + +def bbox2roi(bbox_list): + """Convert a list of bboxes to roi format. + + Args: + bbox_list (list[Tensor]): a list of bboxes corresponding to a batch + of images. + + Returns: + Tensor: shape (n, 5), [batch_ind, x1, y1, x2, y2] + """ + rois_list = [] + for img_id, bboxes in enumerate(bbox_list): + if bboxes.size(0) > 0: + img_inds = bboxes.new_full((bboxes.size(0), 1), img_id) + rois = torch.cat([img_inds, bboxes[:, :4]], dim=-1) + else: + rois = bboxes.new_zeros((0, 5)) + rois_list.append(rois) + rois = torch.cat(rois_list, 0) + return rois + +def temp_interp_mask(maskseq, T): + ''' + maskseq: list of elements (RLE_mask, timestamp) + return list of RLE_mask, length of list is T + ''' + size = maskseq[0][0]['size'] + blank_mask = np.asfortranarray(np.zeros(size).astype(np.uint8)) + blank_mask = mask_utils.encode(blank_mask) + blank_mask['counts'] = blank_mask['counts'].decode('ascii') + ret = [blank_mask,] * T + for m, t in maskseq: + ret[t] = m + return ret + +def mask_seq_jac(sa, sb): + j = np.zeros((len(sa), len(sb))) + for ia, a in enumerate(sa): + for ib, b in enumerate(sb): + ious = [mask_utils.iou([at], [bt], [False,]) for (at, bt) in zip(a,b)] + tiou = np.mean(ious) + j[ia, ib] = tiou + return j + + +def skltn2mask(skltn, size): + h, w = size + mask = np.zeros((h,w)) + + dskltn = dict() + for s in skltn: + dskltn[s['id'][0]] = (int(s['x'][0]), int(s['y'][0])) + if len(dskltn)==0: + return mask + trunk_polygon = list() + for k in np.array([3,4,10,13,9])-1: + p = dskltn.get(k, None) + if not p is None: + trunk_polygon.append(p) + trunk_polygon = np.asarray(trunk_polygon, 'int32') + if len(trunk_polygon) > 2: + cv2.fillConvexPoly(mask, trunk_polygon, 1) + + xmin = np.min([dskltn[k][0] for k in dskltn]) + xmax = np.max([dskltn[k][0] for k in dskltn]) + ymin = np.min([dskltn[k][1] for k in dskltn]) + ymax = np.max([dskltn[k][1] for k in dskltn]) + line_width = np.max([int(np.max([xmax-xmin, ymax-ymin, 0])/20),8]) + + + skeleton = [[10, 11], [11, 12], [9,8], + [8,7], [10, 13], [9, 13], + [13, 15], [10,4], [4,5], + [5,6], [9,3], [3,2], [2,1]] + + + for sk in skeleton: + st = dskltn.get(sk[0]-1, None) + ed = dskltn.get(sk[1]-1, None) + if st is None or ed is None: + continue + cv2.line(mask, st, ed, color=1, thickness=line_width) + + #dmask = cv2.resize(mask, (w//8, h//8), interpolation=cv2.INTER_NEAREST) + #pdb.set_trace() + + return mask + + +def pts2array(pts): + arr = np.zeros((15,3)) + for s in pts: + arr[s['id'][0]][0] = int(s['x'][0]) + arr[s['id'][0]][1] = int(s['y'][0]) + arr[s['id'][0]][2] = s['score'][0] + return arr diff --git a/OpenPVSG/models/unitrack/utils/meter.py b/OpenPVSG/models/unitrack/utils/meter.py new file mode 100644 index 0000000000000000000000000000000000000000..6c2c3aec70e7515281013a3127fc4cdb03b2d0fa --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/meter.py @@ -0,0 +1,48 @@ +################################################################### +# File Name: meter.py +# Author: Zhongdao Wang +# mail: wcd17@mails.tsinghua.edu.cn +# Created Time: Wed Dec 23 16:35:34 2020 +################################################################### + +from __future__ import print_function +from __future__ import division +from __future__ import absolute_import +import time + + +class Timer(object): + """A simple timer.""" + def __init__(self): + self.total_time = 0. + self.calls = 0 + self.start_time = 0. + self.diff = 0. + self.average_time = 0. + + self.duration = 0. + + def tic(self): + # using time.time instead of time.clock because time time.clock + # does not normalize for multithreading + self.start_time = time.time() + + def toc(self, average=True): + self.diff = time.time() - self.start_time + self.total_time += self.diff + self.calls += 1 + self.average_time = self.total_time / self.calls + if average: + self.duration = self.average_time + else: + self.duration = self.diff + return self.duration + + def clear(self): + self.total_time = 0. + self.calls = 0 + self.start_time = 0. + self.diff = 0. + self.average_time = 0. + self.duration = 0. + diff --git a/OpenPVSG/models/unitrack/utils/palette.py b/OpenPVSG/models/unitrack/utils/palette.py new file mode 100644 index 0000000000000000000000000000000000000000..caf6579fbcae544c7aefd9d788e8daaca22ce278 --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/palette.py @@ -0,0 +1,258 @@ +palette_str = '''0 0 0 +128 0 0 +0 128 0 +128 128 0 +0 0 128 +128 0 128 +0 128 128 +128 128 128 +64 0 0 +191 0 0 +64 128 0 +191 128 0 +64 0 128 +191 0 128 +64 128 128 +191 128 128 +0 64 0 +128 64 0 +0 191 0 +128 191 0 +0 64 128 +128 64 128 +22 22 22 +23 23 23 +24 24 24 +25 25 25 +26 26 26 +27 27 27 +28 28 28 +29 29 29 +30 30 30 +31 31 31 +32 32 32 +33 33 33 +34 34 34 +35 35 35 +36 36 36 +37 37 37 +38 38 38 +39 39 39 +40 40 40 +41 41 41 +42 42 42 +43 43 43 +44 44 44 +45 45 45 +46 46 46 +47 47 47 +48 48 48 +49 49 49 +50 50 50 +51 51 51 +52 52 52 +53 53 53 +54 54 54 +55 55 55 +56 56 56 +57 57 57 +58 58 58 +59 59 59 +60 60 60 +61 61 61 +62 62 62 +63 63 63 +64 64 64 +65 65 65 +66 66 66 +67 67 67 +68 68 68 +69 69 69 +70 70 70 +71 71 71 +72 72 72 +73 73 73 +74 74 74 +75 75 75 +76 76 76 +77 77 77 +78 78 78 +79 79 79 +80 80 80 +81 81 81 +82 82 82 +83 83 83 +84 84 84 +85 85 85 +86 86 86 +87 87 87 +88 88 88 +89 89 89 +90 90 90 +91 91 91 +92 92 92 +93 93 93 +94 94 94 +95 95 95 +96 96 96 +97 97 97 +98 98 98 +99 99 99 +100 100 100 +101 101 101 +102 102 102 +103 103 103 +104 104 104 +105 105 105 +106 106 106 +107 107 107 +108 108 108 +109 109 109 +110 110 110 +111 111 111 +112 112 112 +113 113 113 +114 114 114 +115 115 115 +116 116 116 +117 117 117 +118 118 118 +119 119 119 +120 120 120 +121 121 121 +122 122 122 +123 123 123 +124 124 124 +125 125 125 +126 126 126 +127 127 127 +128 128 128 +129 129 129 +130 130 130 +131 131 131 +132 132 132 +133 133 133 +134 134 134 +135 135 135 +136 136 136 +137 137 137 +138 138 138 +139 139 139 +140 140 140 +141 141 141 +142 142 142 +143 143 143 +144 144 144 +145 145 145 +146 146 146 +147 147 147 +148 148 148 +149 149 149 +150 150 150 +151 151 151 +152 152 152 +153 153 153 +154 154 154 +155 155 155 +156 156 156 +157 157 157 +158 158 158 +159 159 159 +160 160 160 +161 161 161 +162 162 162 +163 163 163 +164 164 164 +165 165 165 +166 166 166 +167 167 167 +168 168 168 +169 169 169 +170 170 170 +171 171 171 +172 172 172 +173 173 173 +174 174 174 +175 175 175 +176 176 176 +177 177 177 +178 178 178 +179 179 179 +180 180 180 +181 181 181 +182 182 182 +183 183 183 +184 184 184 +185 185 185 +186 186 186 +187 187 187 +188 188 188 +189 189 189 +190 190 190 +191 191 191 +192 192 192 +193 193 193 +194 194 194 +195 195 195 +196 196 196 +197 197 197 +198 198 198 +199 199 199 +200 200 200 +201 201 201 +202 202 202 +203 203 203 +204 204 204 +205 205 205 +206 206 206 +207 207 207 +208 208 208 +209 209 209 +210 210 210 +211 211 211 +212 212 212 +213 213 213 +214 214 214 +215 215 215 +216 216 216 +217 217 217 +218 218 218 +219 219 219 +220 220 220 +221 221 221 +222 222 222 +223 223 223 +224 224 224 +225 225 225 +226 226 226 +227 227 227 +228 228 228 +229 229 229 +230 230 230 +231 231 231 +232 232 232 +233 233 233 +234 234 234 +235 235 235 +236 236 236 +237 237 237 +238 238 238 +239 239 239 +240 240 240 +241 241 241 +242 242 242 +243 243 243 +244 244 244 +245 245 245 +246 246 246 +247 247 247 +248 248 248 +249 249 249 +250 250 250 +251 251 251 +252 252 252 +253 253 253 +254 254 254 +255 255 255''' +import numpy as np +tensor = np.array([[int(x) for x in line.split()] for line in palette_str.split('\n')]) diff --git a/OpenPVSG/models/unitrack/utils/visualize.py b/OpenPVSG/models/unitrack/utils/visualize.py new file mode 100644 index 0000000000000000000000000000000000000000..108f31c9d4d619635629415885e904452d19d5da --- /dev/null +++ b/OpenPVSG/models/unitrack/utils/visualize.py @@ -0,0 +1,222 @@ + +import cv2 +import numpy as np +import imageio as io +from matplotlib import cm + +import time +import PIL + +import pycocotools.mask as mask_utils +from . import palette + +CLASSES = ['adult', 'baby', 'bag', 'ball', 'ballon', 'basket', 'bat', 'bed', +'bench', 'beverage', 'bike', 'bird', 'blanket', 'board', 'book', 'bottle', +'bowl', 'box', 'bread', 'brush', 'bucket', 'cabinet', 'cake', 'camera', 'can', +'candle', 'car', 'card', 'carpet', 'cart', 'cat', 'cellphone', 'chair', +'child', 'chopstick', 'cloth', 'computer', 'condiment', 'cookie', 'countertop', +'cover', 'cup', 'curtain', 'dog', 'door', 'drawer', 'dustbin', 'egg', 'fan', +'faucet', 'fence', 'flower', 'fork', 'fridge', 'fruit', 'gift', 'glass', +'glasses', 'glove', 'grain', 'guitar', 'hat', 'helmet', 'horse', 'iron', +'knife', 'light', 'lighter', 'mat', 'meat', 'microphone', 'microwave', 'mop', +'net', 'noodle', 'others', 'oven', 'pan', 'paper', 'piano', 'pillow', 'pizza', +'plant', 'plate', 'pot', 'powder', 'rack', 'racket', 'rag', 'ring', 'scissor', +'shelf', 'shoe', 'simmering', 'sink', 'slide', 'sofa', 'spatula', 'sponge', +'spoon', 'spray', 'stairs', 'stand', 'stove', 'switch', 'table', 'teapot', +'towel', 'toy', 'tray', 'tv', 'vaccum', 'vegetable', 'washer', 'window', +'ceiling', 'floor', 'grass', 'ground', 'rock', 'sand', 'sky', 'snow', +'tree', 'wall', 'water'] + + +def dump_predictions(pred, lbl_set, img, prefix): + ''' + Save: + 1. Predicted labels for evaluation + 2. Label heatmaps for visualization + ''' + lbl_set = palette.tensor.astype(np.uint8) + sz = img.shape[:-1] + + # Upsample predicted soft label maps + # pred_dist = pred.copy() + pred_dist = cv2.resize(pred, sz[::-1])[:] + + # Argmax to get the hard label for index + pred_lbl = np.argmax(pred_dist, axis=-1) + pred_lbl = np.array(lbl_set, dtype=np.int32)[pred_lbl] + mask = np.float32(pred_lbl.sum(2) > 0)[:,:,None] + alpha = 0.5 + img_with_label = mask * (np.float32(img) * alpha + \ + np.float32(pred_lbl) * (1-alpha)) + (1-mask) * np.float32(img) + + # Visualize label distribution for object 1 (debugging/analysis) + pred_soft = pred_dist[..., 1] + pred_soft = cv2.resize(pred_soft, (img.shape[1], img.shape[0]), + interpolation=cv2.INTER_NEAREST) + pred_soft = cm.jet(pred_soft)[..., :3] * 255.0 + img_with_heatmap1 = np.float32(img) * 0.5 + np.float32(pred_soft) * 0.5 + + # Save blend image for visualization + io.imwrite('%s_blend.jpg' % prefix, np.uint8(img_with_label)) + + if prefix[-4] != '.': # Super HACK-y + imname2 = prefix + '_mask.png' + else: + imname2 = prefix.replace('jpg','png') + + # Save predicted labels for evaluation + io.imwrite(imname2, np.uint8(pred_lbl)) + + return img_with_label, pred_lbl, img_with_heatmap1 + +def make_gif(video, outname='/tmp/test.gif', sz=256): + if hasattr(video, 'shape'): + video = video.cpu() + if video.shape[0] == 3: + video = video.transpose(0, 1) + + video = video.numpy().transpose(0, 2, 3, 1) + video = (video*255).astype(np.uint8) + + video = [cv2.resize(vv, (sz, sz)) for vv in video] + + if outname is None: + return np.stack(video) + + io.mimsave(outname, video, duration = 0.2) + +def get_color(idx): + idx = idx * 17 + color = ((37 * idx) % 255, (17 * idx) % 255, (29 * idx) % 255) + return color + +def plot_tracking(image, obs, obj_ids, scores=None, frame_id=0, fps=0.): + im = np.ascontiguousarray(np.copy(image)) + im_h, im_w = im.shape[:2] + + text_scale = max(1, image.shape[1] / 1600.) + text_thickness = 1 if text_scale > 1.1 else 1 + line_thickness = max(1, int(image.shape[1] / 150.)) + alpha = 0.4 + + for i, ob in enumerate(obs): + obj_id = int(obj_ids[i]) + id_text = '{}_{}'.format(CLASSES[ob['class_id']], str(obj_id)) + _line_thickness = 1 if obj_id <= 0 else line_thickness + color = get_color(obj_id) + if len(ob) == 4: + x1, y1, w, h = ob + intbox = tuple(map(int, (x1, y1, x1 + w, y1 + h))) + cv2.rectangle(im, intbox[0:2], intbox[2:4], color=color, thickness=line_thickness) + cv2.putText(im, id_text, (intbox[0], intbox[1] + 30), cv2.FONT_HERSHEY_PLAIN, text_scale, (0, 0, 255), + thickness=text_thickness) + elif isinstance(ob, dict): + mask = mask_utils.decode(ob) + mask = cv2.resize(mask, (im_w, im_h), interpolation=cv2.INTER_LINEAR) + mask = (mask > 0.5).astype(np.uint8)[:,:,None] + mask_color = mask * color + im = (1 - mask) * im + mask * (alpha*im + (1-alpha)*mask_color) + # put the id tag at the mask centroid + M = cv2.moments(mask) + if M['m00'] != 0: + cx = int(M['m10'] / M['m00']) + cy = int(M['m01'] / M['m00']) + else: + cx, cy = mask.shape[1]//2, mask.shape[0]//2 + (text_width, text_height), _ = cv2.getTextSize(id_text, cv2.FONT_HERSHEY_PLAIN, text_scale, text_thickness) + tag = np.zeros((text_height + 10, text_width + 10, 3), dtype=np.uint8) + cv2.putText(tag, id_text, (5, text_height + 5), cv2.FONT_HERSHEY_PLAIN, text_scale, (255,255,255), thickness=text_thickness) + # put the tag on image + start_x = cx - tag.shape[1] // 2 + start_y = cy - tag.shape[0] // 2 + tag_height, tag_width = tag.shape[:2] + start_x = max(start_x, 0) + start_y = max(start_y, 0) + end_x = start_x + tag_width + end_y = start_y + tag_height + if end_x > im.shape[1]: + end_x = im.shape[1] + tag_width = im.shape[1] - start_x + if end_y > im.shape[0]: + end_y = im.shape[0] + tag_height = im.shape[0] - start_y + im[start_y:end_y, start_x:end_x] = tag[:tag_height, :tag_width] + + else: + raise ValueError('Observation format not supported.') + return im + + +def vis_pose(oriImg, points): + + pa = np.zeros(15) + pa[2] = 0 + pa[12] = 8 + pa[8] = 4 + pa[4] = 0 + pa[11] = 7 + pa[7] = 3 + pa[3] = 0 + pa[0] = 1 + pa[14] = 10 + pa[10] = 6 + pa[6] = 1 + pa[13] = 9 + pa[9] = 5 + pa[5] = 1 + + colors = [[255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0], + [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255], + [170,0,255],[255,0,255]] + canvas = oriImg + stickwidth = 4 + x = points[0, :] + y = points[1, :] + + for n in range(len(x)): + pair_id = int(pa[n]) + + x1 = int(x[pair_id]) + y1 = int(y[pair_id]) + x2 = int(x[n]) + y2 = int(y[n]) + + if x1 >= 0 and y1 >= 0 and x2 >= 0 and y2 >= 0: + cv2.line(canvas, (x1, y1), (x2, y2), colors[n], 8) + + return canvas + + +def draw_skeleton(aa, kp, color, show_skeleton_labels=False, dataset= "PoseTrack"): + if dataset == "COCO": + skeleton = [[16, 14], [14, 12], [17, 15], [15, 13], [12, 13], + [6, 12], [7, 13], [6, 7], [6, 8], [7, 9], [8, 10], + [9, 11], [2, 3], [1, 2], [1, 3], [2, 4], [3, 5], [4, 6], [5, 7]] + kp_names = ['nose', 'l_eye', 'r_eye', 'l_ear', 'r_ear', 'l_shoulder', + 'r_shoulder', 'l_elbow', 'r_elbow', 'l_wrist', 'r_wrist', + 'l_hip', 'r_hip', 'l_knee', 'r_knee', 'l_ankle', 'r_ankle'] + elif dataset == "PoseTrack": + skeleton = [[10, 11], [11, 12], [9,8], [8,7], + [10, 13], [9, 13], [13, 15], [10,4], + [4,5], [5,6], [9,3], [3,2], [2,1]] + kp_names = ['right_ankle', 'right_knee', 'right_pelvis', + 'left_pelvis', 'left_knee', 'left_ankle', + 'right_wrist', 'right_elbow', 'right_shoulder', + 'left_shoulder', 'left_elbow', 'left_wrist', + 'upper_neck', 'nose', 'head'] + for i, j in skeleton: + if kp[i-1][0] >= 0 and kp[i-1][1] >= 0 and kp[j-1][0] >= 0 and kp[j-1][1] >= 0 and \ + (len(kp[i-1]) <= 2 or (len(kp[i-1]) > 2 and kp[i-1][2] > 0.1 and kp[j-1][2] > 0.1)): + st = (int(kp[i-1][0]), int(kp[i-1][1])) + ed = (int(kp[j-1][0]), int(kp[j-1][1])) + cv2.line(aa, st, ed, color, max(1, int(aa.shape[1]/150.))) + for j in range(len(kp)): + if kp[j][0] >= 0 and kp[j][1] >= 0: + pt = (int(kp[j][0]), int(kp[j][1])) + if len(kp[j]) <= 2 or (len(kp[j]) > 2 and kp[j][2] > 1.1): + cv2.circle(aa, pt, 2, tuple((0,0,255)), 2) + elif len(kp[j]) <= 2 or (len(kp[j]) > 2 and kp[j][2] > 0.1): + cv2.circle(aa, pt, 2, tuple((255,0,0)), 2) + + if show_skeleton_labels and (len(kp[j]) <= 2 or (len(kp[j]) > 2 and kp[j][2] > 0.1)): + cv2.putText(aa, kp_names[j], tuple(kp[j][:2]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0)) diff --git a/OpenPVSG/notebooks/Understanding PVSG Dataset.ipynb b/OpenPVSG/notebooks/Understanding PVSG Dataset.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..c40facba5d7dc178ba69d95e1e03dbcc8c27dc8a --- /dev/null +++ b/OpenPVSG/notebooks/Understanding PVSG Dataset.ipynb @@ -0,0 +1,2120 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "9afe8195", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import json\n", + "import glob" + ] + }, + { + "cell_type": "markdown", + "id": "8c518e70", + "metadata": {}, + "source": [ + "### Understanding Basics" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1cda7b73", + "metadata": {}, + "outputs": [], + "source": [ + "data_root = '/weka-train/jamesp/data/PVSG_dataset'\n", + "with open(os.path.join(data_root, 'pvsg.json'), 'r') as f:\n", + " anno = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "75e0b560", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Keys inside pvsg.json: ['objects', 'relations', 'split', 'data']\n", + "Number of Object Classes: 115\n", + "Number of Stuff Classes: 11\n", + "Number of Relation Classes: 57\n" + ] + } + ], + "source": [ + "print('Keys inside pvsg.json:', list(anno.keys()))\n", + "print('Number of Object Classes:', len(anno['objects']['thing']))\n", + "print('Number of Stuff Classes:', len(anno['objects']['stuff']))\n", + "print('Number of Relation Classes:', len(anno['relations']))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4d71c908", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'video_id': '0001_4164158586',\n", + " 'meta': {'height': 360,\n", + " 'width': 480,\n", + " 'fps': 5,\n", + " 'duration': 36.0,\n", + " 'num_frames': 180},\n", + " 'objects': [{'object_id': 1,\n", + " 'category': 'wall',\n", + " 'is_thing': False,\n", + " 'status': []},\n", + " {'object_id': 2, 'category': 'countertop', 'is_thing': True, 'status': []},\n", + " {'object_id': 3, 'category': 'microwave', 'is_thing': True, 'status': []},\n", + " {'object_id': 4, 'category': 'cabinet', 'is_thing': True, 'status': []},\n", + " {'object_id': 5, 'category': 'door', 'is_thing': True, 'status': []},\n", + " {'object_id': 6, 'category': 'fridge', 'is_thing': True, 'status': []},\n", + " {'object_id': 7, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 8, 'category': 'child', 'is_thing': True, 'status': []},\n", + " {'object_id': 9, 'category': 'table', 'is_thing': True, 'status': []},\n", + " {'object_id': 10, 'category': 'chair', 'is_thing': True, 'status': []},\n", + " {'object_id': 11, 'category': 'candle', 'is_thing': True, 'status': []},\n", + " {'object_id': 12, 'category': 'cake', 'is_thing': True, 'status': []},\n", + " {'object_id': 13, 'category': 'countertop', 'is_thing': True, 'status': []},\n", + " {'object_id': 14, 'category': 'cabinet', 'is_thing': True, 'status': []},\n", + " {'object_id': 15, 'category': 'door', 'is_thing': True, 'status': []},\n", + " {'object_id': 16, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 17, 'category': 'child', 'is_thing': True, 'status': []},\n", + " {'object_id': 18, 'category': 'baby', 'is_thing': True, 'status': []},\n", + " {'object_id': 19, 'category': 'table', 'is_thing': True, 'status': []},\n", + " {'object_id': 20, 'category': 'cake', 'is_thing': True, 'status': []},\n", + " {'object_id': 21, 'category': 'cabinet', 'is_thing': True, 'status': []},\n", + " {'object_id': 22, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 23, 'category': 'child', 'is_thing': True, 'status': []},\n", + " {'object_id': 24, 'category': 'cabinet', 'is_thing': True, 'status': []},\n", + " {'object_id': 25, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 26, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 27, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 28, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 29, 'category': 'adult', 'is_thing': True, 'status': []},\n", + " {'object_id': 30, 'category': 'adult', 'is_thing': True, 'status': []}],\n", + " 'relations': [[27, 23, 'holding', [[102, 110]]],\n", + " [29, 18, 'holding', [[87, 101]]],\n", + " [7, 8, 'holding', [[0, 86], [119, 125], [145, 179]]],\n", + " [22, 17, 'holding', [[0, 6], [125, 148]]],\n", + " [7, 12, 'looking at', [[0, 2], [55, 62]]],\n", + " [7, 8, 'looking at', [[17, 54], [63, 84], [166, 171]]],\n", + " [8, 12, 'looking at', [[4, 10], [36, 43]]],\n", + " [7, 11, 'blowing', [[157, 166]]],\n", + " [8, 11, 'blowing', [[157, 166]]],\n", + " [8, 12, 'pointing to', [[171, 179]]],\n", + " [11, 12, 'on', [[0, 179]]],\n", + " [12, 9, 'on', [[0, 179]]],\n", + " [20, 9, 'on', [[0, 179]]],\n", + " [16, 11, 'picking', [[171, 179]]],\n", + " [23, 9, 'sitting on', [[103, 110]]]],\n", + " 'captions': [{'time': '0000-0008',\n", + " 'description': 'A man (22) carries a child (17) and walks to the left from behind a woman (7) holding another child (8).'},\n", + " {'time': '0009-0047',\n", + " 'description': 'The woman (7) rocks and holds the child (8), singing a birthday song together with another woman (25) to celebrate the birthday of the girl (8).'},\n", + " {'time': '0048-0079',\n", + " 'description': 'The woman (7) smiles and holds the child (8) in front of the cake (12).'},\n", + " {'time': '0080-0122',\n", + " 'description': \"The camera shifts to the right, showing a woman (25), a man (28), a woman (29) holding a baby (baby-1), two men (30) (26), and a woman (27) holding a boy (23), all singing a birthday song to celebrate the girl's (8) birthday.\"},\n", + " {'time': '0123-0155',\n", + " 'description': \"The woman (7) on the left side, holding the child (17), and the man (22) and woman (16) are singing a birthday song to celebrate the girl (8)'s birthday.\"},\n", + " {'time': '0156-0179',\n", + " 'description': 'The girl (8) and the woman (7) blow out the candles (11) on the cake (12) together and laugh happily.'},\n", + " {'time': '0171-0179',\n", + " 'description': 'The woman (16) picks up the candles (11).'}],\n", + " 'qa_pairs': [{'time': '0018',\n", + " 'question': 'Why are the woman (7) and the girl (8) smiling?',\n", + " 'answer': \"Because it's the girl (8)'s birthday, and they (7) (8) are very happy.\"},\n", + " {'time': '0058',\n", + " 'question': 'Why is the man (28) singing?',\n", + " 'answer': \"Because he is celebrating the girl (8)'s birthday and singing a birthday song for her.\"},\n", + " {'time': '0128',\n", + " 'question': 'Why is the woman (16) dancing and gesturing with her hands?',\n", + " 'answer': \"Because she is adding to the festive atmosphere and making the girl (8)'s birthday celebration lively.\"},\n", + " {'time': '0158',\n", + " 'question': 'Why is the woman (7) bending down?',\n", + " 'answer': 'Because she (7) is going to blow out the candles together with the little girl (8).'}],\n", + " 'summary': 'A scene where a group of adults and children celebrate the birthday of a little girl'}" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# See video id in anno['split'].\n", + "# In this notebook we use 0001_4164158586 from vidor as example.\n", + "data = {data_dict['video_id']: data_dict for data_dict in anno['data']}\n", + "vid = '0001_4164158586'\n", + "data[vid]\n", + "# Each video has info of video_id, meta, objects, relations, captions, qa_pairs, and summary." + ] + }, + { + "cell_type": "markdown", + "id": "a3b1af8a", + "metadata": {}, + "source": [ + "### Understanding Objects" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "809045ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mask in p mode, value indicates object id:\n", + "[[5 5 5 ... 6 6 6]\n", + " [5 5 5 ... 6 6 6]\n", + " [5 5 5 ... 6 6 6]\n", + " ...\n", + " [5 5 5 ... 9 9 9]\n", + " [5 5 5 ... 9 9 9]\n", + " [5 5 5 ... 9 9 9]]\n" + ] + } + ], + "source": [ + "# Each video has info of video_id, meta, objects, relations, captions, qa_pairs, and summary.\n", + "# We first understand objects.\n", + "# get frame_id from the video\n", + "frame_id = 0\n", + "# img_name = os.path.join(data_root, 'vidor', 'frames', vid, f'{str(frame_id).zfill(4)}.png')\n", + "mask_name = os.path.join(data_root, 'vidor', 'masks', vid, f'{str(frame_id).zfill(4)}.png')\n", + "\n", + "from PIL import Image, ImageDraw\n", + "# image = Image.open(img_name)\n", + "mask = Image.open(mask_name)\n", + "\n", + "# Since mask is in mode P, we convert it into numpy for very intuitive mask representation.\n", + "import numpy as np\n", + "mask = np.array(mask)\n", + "print(\"Mask in p mode, value indicates object id:\")\n", + "print(mask)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8a63bb7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'object_id': 6, 'category': 'fridge', 'is_thing': True, 'status': []}" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's focus on object_id = 6\n", + "data[vid]['objects'][5]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "226a251e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# We can get the mask for this object via the following code\n", + "# For example, to see the mask for object_id = 6, simply use (mask == 6)\n", + "import matplotlib.pyplot as plt\n", + "# plt.imshow(image)\n", + "plt.imshow(mask == 6, alpha=0.5)\n", + "plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "74b6ac7f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'0000': {1: [187, 0, 479, 290],\n", + " 5: [0, 0, 186, 359],\n", + " 6: [234, 0, 479, 330],\n", + " 7: [137, 43, 337, 337],\n", + " 8: [250, 47, 352, 319],\n", + " 9: [176, 318, 479, 359],\n", + " 11: [308, 283, 324, 309],\n", + " 12: [258, 305, 368, 359],\n", + " 17: [46, 20, 151, 257],\n", + " 22: [75, 13, 197, 359],\n", + " 25: [449, 120, 479, 333]},\n", + " '0007': {1: [166, 0, 479, 316],\n", + " 5: [0, 0, 178, 359],\n", + " 6: [216, 0, 455, 316],\n", + " 7: [159, 35, 340, 307],\n", + " 8: [252, 46, 361, 297],\n", + " 9: [144, 307, 479, 359],\n", + " 11: [283, 271, 297, 296],\n", + " 12: [228, 293, 341, 359],\n", + " 20: [235, 358, 290, 359],\n", + " 22: [0, 96, 24, 359],\n", + " 25: [423, 101, 479, 319]},\n", + " '0006': {1: [168, 0, 479, 320],\n", + " 5: [0, 0, 179, 359],\n", + " 6: [218, 0, 456, 321],\n", + " 7: [159, 38, 341, 311],\n", + " 8: [251, 49, 365, 302],\n", + " 9: [146, 311, 479, 359],\n", + " 11: [282, 277, 301, 300],\n", + " 12: [227, 299, 341, 359],\n", + " 22: [0, 2, 53, 359],\n", + " 25: [426, 106, 479, 324]},\n", + " '0010': {1: [147, 0, 476, 314],\n", + " 5: [0, 0, 155, 359],\n", + " 6: [197, 0, 435, 311],\n", + " 7: [112, 28, 300, 308],\n", + " 8: [213, 35, 321, 300],\n", + " 9: [121, 301, 479, 359],\n", + " 11: [264, 269, 276, 291],\n", + " 12: [211, 288, 322, 352],\n", + " 20: [199, 346, 293, 359],\n", + " 25: [401, 24, 479, 314]},\n", + " '0014': {1: [131, 0, 453, 301],\n", + " 5: [0, 0, 143, 359],\n", + " 6: [183, 0, 421, 293],\n", + " 7: [103, 11, 295, 292],\n", + " 8: [205, 13, 306, 286],\n", + " 9: [103, 286, 479, 359],\n", + " 11: [243, 252, 275, 274],\n", + " 12: [206, 272, 318, 335],\n", + " 20: [176, 329, 304, 359],\n", + " 25: [387, 5, 479, 295]},\n", + " '0015': {1: [126, 0, 461, 305],\n", + " 5: [0, 0, 140, 359],\n", + " 6: [179, 0, 417, 295],\n", + " 7: [106, 14, 299, 293],\n", + " 8: [211, 15, 305, 285],\n", + " 9: [102, 291, 479, 359],\n", + " 11: [246, 255, 274, 278],\n", + " 12: [200, 275, 314, 340],\n", + " 20: [179, 334, 293, 359],\n", + " 25: [384, 7, 479, 298]},\n", + " '0011': {1: [143, 0, 473, 328],\n", + " 5: [0, 0, 147, 359],\n", + " 6: [199, 0, 437, 312],\n", + " 7: [106, 27, 296, 315],\n", + " 8: [204, 35, 317, 303],\n", + " 9: [126, 303, 479, 359],\n", + " 11: [267, 271, 282, 291],\n", + " 12: [215, 291, 327, 356],\n", + " 20: [214, 346, 295, 359],\n", + " 25: [404, 25, 479, 316]},\n", + " '0012': {1: [139, 0, 470, 325],\n", + " 5: [0, 0, 145, 359],\n", + " 6: [197, 0, 434, 308],\n", + " 7: [103, 26, 291, 313],\n", + " 8: [200, 35, 313, 299],\n", + " 9: [122, 300, 479, 359],\n", + " 11: [266, 268, 280, 286],\n", + " 12: [213, 287, 327, 352],\n", + " 20: [202, 343, 301, 359],\n", + " 25: [399, 22, 479, 311]},\n", + " '0013': {1: [138, 0, 456, 99],\n", + " 5: [0, 0, 140, 359],\n", + " 6: [189, 0, 428, 299],\n", + " 7: [101, 18, 292, 312],\n", + " 8: [200, 24, 309, 291],\n", + " 9: [112, 292, 479, 359],\n", + " 11: [263, 255, 279, 280],\n", + " 12: [208, 278, 322, 343],\n", + " 20: [188, 335, 302, 359],\n", + " 25: [393, 12, 479, 302]},\n", + " '0004': {1: [185, 0, 479, 319],\n", + " 5: [0, 0, 197, 359],\n", + " 6: [235, 0, 479, 323],\n", + " 7: [175, 39, 360, 310],\n", + " 8: [268, 46, 383, 302],\n", + " 9: [163, 311, 479, 359],\n", + " 11: [299, 275, 316, 299],\n", + " 12: [246, 299, 361, 359],\n", + " 17: [0, 80, 27, 224],\n", + " 20: [266, 359, 276, 359],\n", + " 22: [0, 6, 134, 359],\n", + " 25: [447, 112, 479, 325]},\n", + " '0009': {1: [148, 0, 478, 306],\n", + " 5: [0, 0, 157, 359],\n", + " 6: [198, 0, 436, 305],\n", + " 7: [126, 25, 311, 297],\n", + " 8: [225, 30, 330, 288],\n", + " 9: [117, 297, 479, 359],\n", + " 11: [258, 266, 279, 285],\n", + " 12: [208, 283, 322, 348],\n", + " 20: [193, 340, 291, 359],\n", + " 25: [401, 17, 479, 309]},\n", + " '0002': {1: [187, 0, 479, 324],\n", + " 5: [0, 0, 202, 359],\n", + " 6: [236, 0, 479, 326],\n", + " 7: [170, 42, 361, 318],\n", + " 8: [274, 43, 370, 305],\n", + " 9: [172, 315, 479, 359],\n", + " 11: [304, 282, 321, 303],\n", + " 12: [256, 302, 366, 359],\n", + " 17: [0, 16, 83, 250],\n", + " 22: [0, 9, 178, 359],\n", + " 25: [450, 116, 479, 326]},\n", + " '0003': {1: [189, 0, 479, 320],\n", + " 5: [0, 0, 201, 359],\n", + " 6: [238, 0, 479, 323],\n", + " 7: [176, 40, 361, 311],\n", + " 8: [276, 41, 380, 302],\n", + " 9: [169, 311, 479, 359],\n", + " 11: [306, 278, 321, 300],\n", + " 12: [253, 299, 366, 359],\n", + " 17: [0, 14, 57, 261],\n", + " 20: [264, 358, 291, 359],\n", + " 22: [0, 6, 159, 359],\n", + " 25: [450, 115, 479, 325]},\n", + " '0016': {1: [122, 0, 454, 313],\n", + " 5: [0, 0, 138, 359],\n", + " 6: [176, 0, 413, 304],\n", + " 7: [106, 26, 302, 301],\n", + " 8: [216, 24, 303, 289],\n", + " 9: [103, 300, 479, 359],\n", + " 11: [247, 261, 265, 286],\n", + " 12: [195, 284, 311, 348],\n", + " 20: [183, 342, 284, 359],\n", + " 25: [381, 16, 479, 307]},\n", + " '0008': {1: [159, 0, 479, 308],\n", + " 5: [0, 0, 170, 359],\n", + " 6: [210, 0, 449, 309],\n", + " 7: [144, 30, 329, 299],\n", + " 8: [243, 37, 348, 290],\n", + " 9: [130, 300, 479, 359],\n", + " 11: [273, 265, 298, 288],\n", + " 12: [221, 287, 334, 354],\n", + " 20: [206, 343, 302, 359],\n", + " 22: [0, 358, 22, 359],\n", + " 25: [414, 35, 479, 312]},\n", + " '0001': {1: [187, 0, 479, 121],\n", + " 5: [0, 0, 202, 359],\n", + " 6: [238, 0, 479, 328],\n", + " 7: [156, 44, 353, 325],\n", + " 8: [270, 43, 364, 309],\n", + " 9: [175, 317, 479, 359],\n", + " 11: [304, 281, 326, 305],\n", + " 12: [256, 304, 367, 359],\n", + " 17: [11, 15, 118, 245],\n", + " 22: [35, 11, 190, 359],\n", + " 25: [451, 119, 479, 330]},\n", + " '0005': {1: [178, 0, 479, 320],\n", + " 5: [0, 0, 188, 359],\n", + " 6: [227, 0, 468, 323],\n", + " 7: [167, 39, 350, 312],\n", + " 8: [259, 49, 375, 303],\n", + " 9: [154, 312, 479, 359],\n", + " 11: [289, 277, 316, 301],\n", + " 12: [237, 300, 350, 359],\n", + " 22: [0, 0, 96, 359],\n", + " 25: [437, 109, 479, 325]},\n", + " '0018': {1: [118, 0, 437, 311],\n", + " 5: [0, 0, 134, 359],\n", + " 6: [171, 0, 408, 303],\n", + " 7: [97, 28, 296, 300],\n", + " 8: [212, 24, 294, 288],\n", + " 9: [96, 300, 479, 359],\n", + " 11: [244, 257, 256, 285],\n", + " 12: [189, 284, 304, 348],\n", + " 20: [175, 341, 275, 359],\n", + " 25: [377, 16, 479, 305]},\n", + " '0019': {1: [120, 0, 437, 311],\n", + " 5: [0, 0, 135, 359],\n", + " 6: [172, 0, 409, 304],\n", + " 7: [92, 27, 290, 302],\n", + " 8: [205, 23, 289, 291],\n", + " 9: [96, 301, 479, 359],\n", + " 11: [238, 255, 258, 286],\n", + " 12: [189, 284, 303, 348],\n", + " 20: [175, 341, 275, 359],\n", + " 25: [377, 16, 479, 305]},\n", + " '0030': {1: [129, 0, 454, 307],\n", + " 5: [0, 0, 143, 359],\n", + " 6: [181, 0, 420, 306],\n", + " 7: [108, 27, 300, 300],\n", + " 8: [217, 23, 305, 288],\n", + " 9: [92, 300, 479, 359],\n", + " 11: [243, 265, 255, 285],\n", + " 12: [188, 284, 304, 350],\n", + " 20: [170, 341, 273, 359],\n", + " 25: [395, 16, 479, 309]},\n", + " '0024': {1: [129, 0, 452, 106],\n", + " 5: [0, 0, 144, 359],\n", + " 6: [180, 0, 418, 304],\n", + " 7: [88, 24, 286, 307],\n", + " 8: [199, 23, 292, 296],\n", + " 9: [97, 299, 479, 359],\n", + " 11: [233, 255, 260, 285],\n", + " 12: [191, 284, 307, 349],\n", + " 20: [174, 341, 274, 359],\n", + " 25: [391, 14, 479, 307]},\n", + " '0031': {1: [130, 0, 455, 306],\n", + " 5: [0, 0, 144, 359],\n", + " 6: [181, 0, 421, 305],\n", + " 7: [107, 27, 300, 300],\n", + " 8: [217, 23, 306, 287],\n", + " 9: [92, 299, 479, 359],\n", + " 11: [244, 264, 254, 284],\n", + " 12: [189, 284, 304, 349],\n", + " 20: [170, 341, 273, 359],\n", + " 25: [396, 16, 479, 308]},\n", + " '0020': {1: [122, 0, 441, 310],\n", + " 5: [0, 0, 137, 359],\n", + " 6: [174, 0, 412, 303],\n", + " 7: [84, 25, 285, 303],\n", + " 8: [197, 22, 285, 293],\n", + " 9: [97, 299, 479, 359],\n", + " 11: [232, 253, 259, 285],\n", + " 12: [190, 284, 305, 349],\n", + " 20: [175, 341, 275, 359],\n", + " 25: [380, 15, 479, 305]},\n", + " '0021': {1: [125, 0, 444, 314],\n", + " 5: [0, 0, 134, 359],\n", + " 6: [177, 0, 414, 305],\n", + " 7: [81, 25, 281, 313],\n", + " 8: [191, 24, 284, 300],\n", + " 9: [100, 300, 479, 359],\n", + " 11: [227, 252, 258, 287],\n", + " 12: [192, 286, 306, 350],\n", + " 20: [177, 343, 277, 359],\n", + " 25: [385, 17, 479, 308]},\n", + " '0025': {1: [128, 0, 453, 309],\n", + " 5: [0, 0, 145, 359],\n", + " 6: [179, 0, 418, 307],\n", + " 7: [95, 28, 292, 304],\n", + " 8: [208, 24, 297, 291],\n", + " 9: [97, 303, 479, 359],\n", + " 11: [239, 255, 267, 288],\n", + " 12: [191, 287, 305, 351],\n", + " 20: [173, 343, 273, 359],\n", + " 25: [392, 15, 479, 309]},\n", + " '0017': {1: [120, 0, 440, 311],\n", + " 5: [0, 0, 135, 359],\n", + " 6: [172, 0, 409, 304],\n", + " 7: [102, 27, 298, 300],\n", + " 8: [215, 24, 299, 289],\n", + " 9: [98, 300, 479, 359],\n", + " 11: [244, 260, 257, 285],\n", + " 12: [190, 284, 305, 348],\n", + " 20: [177, 342, 277, 359],\n", + " 25: [378, 17, 479, 306]},\n", + " '0032': {1: [131, 0, 456, 305],\n", + " 5: [0, 0, 144, 359],\n", + " 6: [183, 0, 422, 305],\n", + " 7: [107, 25, 299, 298],\n", + " 8: [214, 22, 306, 287],\n", + " 9: [92, 299, 479, 359],\n", + " 11: [244, 263, 254, 284],\n", + " 12: [189, 283, 305, 348],\n", + " 20: [170, 340, 272, 359],\n", + " 25: [396, 16, 479, 308]},\n", + " '0028': {1: [127, 0, 454, 312],\n", + " 5: [0, 0, 142, 359],\n", + " 6: [179, 0, 418, 311],\n", + " 7: [104, 32, 301, 304],\n", + " 8: [218, 28, 304, 292],\n", + " 9: [96, 305, 479, 359],\n", + " 11: [242, 268, 258, 291],\n", + " 12: [189, 290, 304, 356],\n", + " 20: [190, 346, 267, 359],\n", + " 25: [393, 19, 479, 313]},\n", + " '0037': {1: [135, 0, 456, 306],\n", + " 5: [0, 0, 144, 359],\n", + " 6: [186, 0, 426, 308],\n", + " 7: [107, 22, 301, 300],\n", + " 8: [218, 25, 319, 288],\n", + " 9: [92, 300, 479, 359],\n", + " 11: [245, 265, 255, 284],\n", + " 12: [190, 284, 306, 351],\n", + " 20: [170, 341, 273, 359],\n", + " 25: [396, 18, 479, 312]},\n", + " '0022': {1: [128, 0, 448, 316],\n", + " 5: [0, 0, 130, 359],\n", + " 6: [179, 0, 417, 304],\n", + " 7: [81, 24, 280, 311],\n", + " 8: [188, 24, 286, 298],\n", + " 9: [99, 299, 479, 359],\n", + " 11: [224, 252, 258, 286],\n", + " 12: [192, 284, 307, 349],\n", + " 20: [177, 342, 276, 359],\n", + " 25: [388, 15, 479, 307]},\n", + " '0033': {1: [131, 0, 456, 305],\n", + " 5: [0, 0, 143, 359],\n", + " 6: [183, 0, 422, 306],\n", + " 7: [103, 25, 298, 299],\n", + " 8: [214, 23, 307, 288],\n", + " 9: [92, 299, 479, 359],\n", + " 11: [244, 264, 254, 284],\n", + " 12: [189, 283, 305, 349],\n", + " 20: [170, 340, 272, 359],\n", + " 25: [396, 16, 479, 309]},\n", + " '0038': {1: [134, 0, 456, 307],\n", + " 5: [0, 0, 143, 359],\n", + " 6: [186, 0, 425, 310],\n", + " 7: [110, 25, 301, 300],\n", + " 8: [217, 27, 321, 289],\n", + " 9: [91, 301, 479, 359],\n", + " 11: [244, 266, 255, 287],\n", + " 12: [189, 286, 305, 352],\n", + " 20: [169, 342, 271, 359],\n", + " 25: [395, 20, 479, 314]},\n", + " '0040': {1: [141, 0, 463, 307],\n", + " 5: [0, 0, 150, 359],\n", + " 6: [192, 0, 432, 310],\n", + " 7: [116, 25, 306, 300],\n", + " 8: [224, 34, 328, 287],\n", + " 9: [97, 300, 479, 359],\n", + " 11: [249, 264, 261, 284],\n", + " 12: [195, 285, 311, 350],\n", + " 20: [176, 341, 278, 359],\n", + " 25: [402, 22, 479, 313]},\n", + " '0039': {1: [135, 0, 458, 309],\n", + " 5: [0, 0, 145, 359],\n", + " 6: [186, 0, 426, 312],\n", + " 7: [111, 28, 302, 302],\n", + " 8: [218, 33, 319, 291],\n", + " 9: [94, 303, 479, 359],\n", + " 11: [245, 268, 255, 288],\n", + " 12: [191, 288, 305, 354],\n", + " 20: [170, 343, 272, 359],\n", + " 25: [396, 22, 479, 316]},\n", + " '0041': {1: [144, 0, 469, 305],\n", + " 5: [0, 0, 154, 359],\n", + " 6: [196, 0, 437, 309],\n", + " 7: [120, 25, 312, 299],\n", + " 8: [231, 36, 333, 286],\n", + " 9: [102, 299, 479, 359],\n", + " 11: [254, 264, 270, 284],\n", + " 12: [200, 283, 317, 349],\n", + " 20: [181, 340, 283, 359],\n", + " 25: [407, 21, 479, 313]},\n", + " '0029': {1: [128, 0, 453, 308],\n", + " 5: [0, 0, 142, 359],\n", + " 6: [179, 0, 418, 308],\n", + " 7: [105, 29, 300, 301],\n", + " 8: [217, 24, 304, 289],\n", + " 9: [92, 301, 479, 359],\n", + " 11: [242, 264, 257, 286],\n", + " 12: [187, 286, 303, 352],\n", + " 20: [168, 342, 269, 359],\n", + " 25: [394, 17, 479, 310]},\n", + " '0026': {1: [128, 0, 454, 310],\n", + " 5: [0, 0, 143, 359],\n", + " 6: [179, 0, 418, 308],\n", + " 7: [100, 30, 297, 302],\n", + " 8: [215, 24, 299, 291],\n", + " 9: [96, 303, 479, 359],\n", + " 11: [243, 259, 269, 289],\n", + " 12: [190, 287, 305, 352],\n", + " 20: [172, 344, 272, 359],\n", + " 25: [393, 16, 479, 310]},\n", + " '0036': {1: [135, 0, 458, 304],\n", + " 5: [0, 0, 145, 359],\n", + " 6: [187, 0, 428, 307],\n", + " 7: [106, 23, 302, 298],\n", + " 8: [218, 21, 316, 285],\n", + " 9: [91, 298, 479, 359],\n", + " 11: [243, 263, 256, 283],\n", + " 12: [191, 283, 306, 348],\n", + " 20: [167, 339, 273, 359],\n", + " 25: [398, 18, 479, 310]},\n", + " '0044': {1: [158, 0, 479, 277],\n", + " 5: [0, 0, 171, 359],\n", + " 6: [209, 0, 456, 304],\n", + " 7: [125, 6, 322, 291],\n", + " 8: [231, 14, 346, 279],\n", + " 9: [92, 290, 479, 359],\n", + " 11: [258, 255, 273, 279],\n", + " 12: [203, 277, 324, 347],\n", + " 20: [169, 336, 285, 359],\n", + " 25: [424, 86, 479, 309]},\n", + " '0047': {1: [193, 0, 244, 11],\n", + " 5: [0, 0, 194, 359],\n", + " 6: [245, 0, 479, 345],\n", + " 7: [148, 9, 357, 315],\n", + " 8: [258, 20, 386, 304],\n", + " 9: [112, 314, 479, 359],\n", + " 11: [274, 281, 292, 307],\n", + " 12: [209, 304, 347, 359],\n", + " 25: [478, 176, 479, 184]},\n", + " '0046': {1: [177, 0, 479, 279],\n", + " 5: [0, 0, 183, 359],\n", + " 6: [229, 0, 479, 331],\n", + " 7: [138, 6, 342, 310],\n", + " 8: [245, 15, 366, 298],\n", + " 9: [111, 309, 479, 359],\n", + " 11: [270, 274, 284, 300],\n", + " 12: [208, 296, 340, 359],\n", + " 25: [453, 112, 479, 332]},\n", + " '0034': {1: [133, 0, 451, 307],\n", + " 5: [0, 0, 145, 359],\n", + " 6: [184, 0, 424, 308],\n", + " 7: [102, 26, 300, 302],\n", + " 8: [216, 23, 308, 287],\n", + " 9: [93, 301, 479, 359],\n", + " 11: [243, 265, 253, 284],\n", + " 12: [190, 284, 306, 350],\n", + " 20: [170, 339, 274, 359],\n", + " 25: [395, 17, 479, 310]},\n", + " '0052': {1: [255, 0, 350, 340],\n", + " 5: [0, 0, 204, 359],\n", + " 6: [271, 0, 479, 359],\n", + " 7: [144, 0, 385, 337],\n", + " 8: [265, 0, 401, 327],\n", + " 9: [41, 319, 443, 359],\n", + " 11: [223, 271, 238, 305],\n", + " 12: [142, 303, 316, 359]},\n", + " '0049': {1: [268, 0, 285, 80],\n", + " 5: [0, 0, 212, 343],\n", + " 6: [275, 0, 479, 359],\n", + " 7: [165, 0, 386, 323],\n", + " 8: [275, 0, 412, 303],\n", + " 9: [52, 298, 476, 359],\n", + " 11: [258, 269, 274, 293],\n", + " 12: [186, 291, 338, 359]},\n", + " '0055': {1: [215, 0, 245, 77],\n", + " 5: [0, 0, 166, 348],\n", + " 6: [246, 0, 479, 359],\n", + " 7: [106, 0, 363, 336],\n", + " 8: [235, 0, 380, 321],\n", + " 9: [0, 315, 475, 359],\n", + " 11: [185, 253, 198, 290],\n", + " 12: [87, 287, 291, 359]},\n", + " '0056': {1: [198, 0, 309, 359],\n", + " 5: [0, 0, 160, 359],\n", + " 6: [245, 0, 479, 359],\n", + " 7: [102, 0, 362, 359],\n", + " 8: [233, 0, 379, 359],\n", + " 9: [7, 334, 301, 359],\n", + " 11: [182, 271, 198, 312],\n", + " 12: [88, 308, 292, 359]},\n", + " '0051': {1: [254, 0, 337, 337],\n", + " 5: [0, 0, 193, 355],\n", + " 6: [268, 0, 479, 359],\n", + " 7: [143, 0, 373, 327],\n", + " 8: [259, 0, 396, 325],\n", + " 9: [22, 309, 452, 359],\n", + " 11: [222, 270, 243, 301],\n", + " 12: [142, 298, 310, 359]},\n", + " '0043': {1: [160, 0, 479, 293],\n", + " 5: [0, 0, 170, 357],\n", + " 6: [209, 0, 456, 301],\n", + " 7: [130, 9, 329, 290],\n", + " 8: [237, 19, 353, 276],\n", + " 9: [99, 289, 479, 359],\n", + " 11: [267, 254, 275, 277],\n", + " 12: [213, 275, 326, 338],\n", + " 20: [170, 328, 301, 359],\n", + " 25: [424, 86, 479, 305]},\n", + " '0050': {1: [263, 0, 337, 330],\n", + " 5: [0, 0, 201, 347],\n", + " 6: [274, 0, 479, 359],\n", + " 7: [151, 0, 378, 323],\n", + " 8: [264, 0, 404, 314],\n", + " 9: [32, 304, 473, 359],\n", + " 11: [237, 269, 254, 294],\n", + " 12: [160, 294, 320, 359]},\n", + " '0045': {1: [170, 0, 479, 272],\n", + " 5: [0, 0, 181, 359],\n", + " 6: [221, 0, 477, 327],\n", + " 7: [133, 15, 335, 308],\n", + " 8: [241, 23, 357, 297],\n", + " 9: [111, 308, 479, 359],\n", + " 11: [270, 273, 286, 296],\n", + " 12: [209, 294, 338, 359],\n", + " 20: [217, 358, 241, 359],\n", + " 25: [441, 106, 479, 330]},\n", + " '0058': {1: [225, 0, 267, 106],\n", + " 5: [0, 0, 175, 359],\n", + " 6: [215, 0, 479, 359],\n", + " 7: [120, 0, 376, 356],\n", + " 8: [248, 0, 399, 329],\n", + " 9: [18, 329, 347, 359],\n", + " 11: [204, 270, 216, 308],\n", + " 12: [105, 304, 313, 359]},\n", + " '0057': {1: [214, 0, 263, 104],\n", + " 5: [0, 0, 176, 359],\n", + " 6: [261, 0, 479, 359],\n", + " 7: [118, 0, 378, 359],\n", + " 8: [247, 0, 396, 340],\n", + " 9: [39, 338, 124, 359],\n", + " 11: [200, 276, 214, 315],\n", + " 12: [112, 311, 307, 359]},\n", + " '0053': {1: [254, 0, 321, 333],\n", + " 5: [0, 0, 205, 359],\n", + " 6: [273, 0, 479, 359],\n", + " 7: [142, 0, 393, 337],\n", + " 8: [268, 0, 407, 320],\n", + " 9: [35, 318, 477, 359],\n", + " 11: [222, 258, 239, 299],\n", + " 12: [135, 296, 320, 359]},\n", + " '0060': {1: [228, 0, 268, 94],\n", + " 5: [0, 0, 176, 359],\n", + " 6: [268, 0, 479, 359],\n", + " 7: [123, 0, 374, 353],\n", + " 8: [247, 0, 399, 319],\n", + " 9: [19, 327, 366, 359],\n", + " 11: [202, 267, 221, 306],\n", + " 12: [110, 302, 305, 359]},\n", + " '0059': {1: [231, 0, 274, 95],\n", + " 5: [0, 0, 183, 359],\n", + " 6: [273, 0, 479, 359],\n", + " 7: [127, 0, 382, 351],\n", + " 8: [253, 0, 406, 320],\n", + " 9: [21, 325, 386, 359],\n", + " 11: [207, 267, 226, 304],\n", + " 12: [117, 301, 317, 359]},\n", + " '0062': {1: [223, 0, 272, 106],\n", + " 5: [0, 0, 178, 359],\n", + " 6: [270, 0, 479, 359],\n", + " 7: [125, 0, 377, 359],\n", + " 8: [247, 0, 403, 331],\n", + " 9: [38, 336, 129, 359],\n", + " 11: [204, 277, 226, 316],\n", + " 12: [116, 313, 305, 359]},\n", + " '0035': {1: [135, 0, 457, 305],\n", + " 5: [0, 0, 146, 359],\n", + " 6: [187, 0, 427, 308],\n", + " 7: [105, 26, 302, 299],\n", + " 8: [218, 23, 310, 287],\n", + " 9: [92, 300, 479, 359],\n", + " 11: [244, 264, 256, 284],\n", + " 12: [192, 284, 307, 349],\n", + " 20: [171, 340, 274, 359],\n", + " 25: [397, 19, 479, 311]},\n", + " '0042': {1: [150, 0, 476, 300],\n", + " 5: [0, 0, 160, 359],\n", + " 6: [202, 0, 444, 306],\n", + " 7: [122, 22, 318, 295],\n", + " 8: [235, 33, 342, 282],\n", + " 9: [102, 295, 479, 359],\n", + " 11: [258, 261, 270, 282],\n", + " 12: [205, 281, 321, 347],\n", + " 20: [176, 337, 287, 359],\n", + " 25: [413, 27, 479, 310]},\n", + " '0023': {1: [129, 0, 451, 315],\n", + " 5: [0, 0, 131, 359],\n", + " 6: [180, 0, 418, 304],\n", + " 7: [84, 22, 281, 312],\n", + " 8: [191, 22, 288, 298],\n", + " 9: [98, 299, 479, 359],\n", + " 11: [226, 251, 259, 286],\n", + " 12: [192, 284, 307, 349],\n", + " 20: [176, 341, 276, 359],\n", + " 25: [390, 14, 479, 307]},\n", + " '0054': {1: [235, 0, 256, 75],\n", + " 5: [0, 0, 176, 348],\n", + " 6: [209, 0, 479, 359],\n", + " 7: [119, 0, 370, 333],\n", + " 8: [241, 0, 390, 318],\n", + " 9: [0, 311, 475, 359],\n", + " 11: [194, 250, 210, 290],\n", + " 12: [102, 287, 299, 359]},\n", + " '0067': {1: [228, 0, 274, 108],\n", + " 5: [0, 0, 228, 359],\n", + " 6: [273, 0, 479, 359],\n", + " 7: [135, 7, 381, 359],\n", + " 8: [253, 0, 393, 335],\n", + " 9: [49, 338, 137, 359],\n", + " 11: [208, 282, 226, 319],\n", + " 12: [124, 316, 308, 359]},\n", + " '0066': {1: [231, 0, 278, 108],\n", + " 5: [0, 0, 231, 359],\n", + " 6: [276, 0, 479, 359],\n", + " 7: [136, 6, 382, 359],\n", + " 8: [254, 0, 396, 336],\n", + " 9: [42, 336, 138, 359],\n", + " 11: [206, 280, 226, 318],\n", + " 12: [121, 315, 309, 359]},\n", + " '0069': {1: [226, 0, 274, 101],\n", + " 5: [0, 0, 191, 359],\n", + " 6: [274, 0, 479, 359],\n", + " 7: [136, 0, 385, 359],\n", + " 8: [258, 0, 409, 331],\n", + " 9: [50, 334, 335, 359],\n", + " 11: [212, 274, 230, 314],\n", + " 12: [126, 310, 319, 359],\n", + " 25: [447, 138, 479, 175]},\n", + " '0070': {1: [233, 0, 275, 99],\n", + " 5: [0, 0, 187, 359],\n", + " 6: [275, 0, 479, 359],\n", + " 7: [139, 0, 386, 359],\n", + " 8: [256, 0, 407, 328],\n", + " 9: [48, 332, 347, 359],\n", + " 11: [214, 273, 230, 312],\n", + " 12: [126, 308, 315, 359],\n", + " 25: [459, 112, 479, 148]},\n", + " '0075': {1: [225, 0, 273, 105],\n", + " 5: [0, 0, 224, 359],\n", + " 6: [273, 0, 479, 359],\n", + " 7: [141, 3, 393, 359],\n", + " 8: [265, 0, 417, 341],\n", + " 9: [69, 341, 145, 359],\n", + " 11: [217, 283, 229, 319],\n", + " 12: [136, 317, 313, 359]},\n", + " '0074': {1: [236, 0, 339, 359],\n", + " 5: [0, 0, 196, 359],\n", + " 6: [274, 0, 479, 359],\n", + " 7: [142, 0, 392, 359],\n", + " 8: [263, 0, 417, 334],\n", + " 9: [56, 336, 336, 359],\n", + " 11: [215, 274, 230, 314],\n", + " 12: [129, 310, 318, 359]},\n", + " '0065': {1: [230, 0, 278, 107],\n", + " 5: [0, 0, 230, 359],\n", + " 6: [274, 0, 479, 359],\n", + " 7: [133, 5, 378, 359],\n", + " 8: [250, 0, 392, 336],\n", + " 9: [26, 334, 134, 359],\n", + " 11: [205, 277, 228, 316],\n", + " 12: [115, 313, 304, 359]},\n", + " '0078': {1: [202, 0, 250, 110],\n", + " 5: [0, 0, 202, 359],\n", + " 6: [248, 0, 479, 359],\n", + " 7: [115, 12, 363, 359],\n", + " 8: [236, 5, 375, 359],\n", + " 9: [72, 347, 130, 359],\n", + " 11: [192, 292, 210, 331],\n", + " 12: [127, 328, 286, 359]},\n", + " '0073': {1: [243, 0, 274, 98],\n", + " 5: [0, 0, 189, 359],\n", + " 6: [274, 0, 479, 359],\n", + " 7: [141, 0, 387, 356],\n", + " 8: [260, 0, 414, 330],\n", + " 9: [42, 331, 357, 359],\n", + " 11: [214, 271, 229, 310],\n", + " 12: [123, 307, 313, 359]},\n", + " '0027': {1: [128, 0, 454, 310],\n", + " 5: [0, 0, 143, 359],\n", + " 6: [179, 0, 418, 308],\n", + " 7: [104, 30, 301, 302],\n", + " 8: [219, 25, 302, 290],\n", + " 9: [96, 302, 479, 359],\n", + " 11: [243, 264, 258, 290],\n", + " 12: [189, 287, 304, 351],\n", + " 20: [177, 344, 270, 359],\n", + " 25: [394, 16, 479, 310]},\n", + " '0061': {1: [224, 0, 269, 100],\n", + " 5: [0, 0, 173, 359],\n", + " 6: [266, 0, 479, 359],\n", + " 7: [122, 0, 373, 359],\n", + " 8: [243, 0, 395, 326],\n", + " 9: [25, 333, 312, 359],\n", + " 11: [201, 273, 218, 311],\n", + " 12: [107, 308, 308, 359]},\n", + " '0071': {1: [244, 0, 275, 97],\n", + " 5: [0, 0, 186, 359],\n", + " 6: [275, 0, 479, 359],\n", + " 7: [140, 0, 385, 356],\n", + " 8: [257, 0, 414, 327],\n", + " 9: [42, 331, 360, 359],\n", + " 11: [215, 272, 230, 309],\n", + " 12: [125, 307, 314, 359]},\n", + " '0064': {1: [226, 0, 277, 107],\n", + " 5: [0, 0, 227, 359],\n", + " 6: [273, 0, 479, 359],\n", + " 7: [130, 5, 379, 359],\n", + " 8: [250, 0, 395, 334],\n", + " 9: [28, 334, 134, 359],\n", + " 11: [204, 277, 227, 317],\n", + " 12: [116, 313, 305, 359]},\n", + " '0077': {1: [221, 0, 269, 111],\n", + " 5: [0, 0, 221, 359],\n", + " 6: [268, 0, 479, 359],\n", + " 7: [135, 11, 387, 359],\n", + " 8: [258, 3, 401, 349],\n", + " 9: [90, 348, 146, 359],\n", + " 11: [212, 290, 226, 328],\n", + " 12: [143, 326, 307, 359]},\n", + " '0079': {1: [188, 0, 236, 110],\n", + " 5: [0, 0, 188, 359],\n", + " 6: [235, 0, 479, 359],\n", + " 7: [104, 13, 346, 359],\n", + " 8: [225, 4, 359, 350],\n", + " 9: [69, 347, 129, 359],\n", + " 11: [185, 298, 200, 332],\n", + " 12: [126, 328, 274, 359]},\n", + " '0081': {1: [126, 0, 479, 143],\n", + " 5: [0, 0, 127, 359],\n", + " 6: [172, 0, 445, 359],\n", + " 7: [43, 43, 274, 359],\n", + " 8: [158, 44, 289, 359],\n", + " 11: [130, 339, 151, 359],\n", + " 25: [407, 132, 479, 359]},\n", + " '0080': {1: [161, 0, 205, 117],\n", + " 5: [0, 0, 160, 359],\n", + " 6: [202, 0, 479, 359],\n", + " 7: [76, 21, 308, 359],\n", + " 8: [188, 15, 325, 359],\n", + " 9: [78, 354, 113, 359],\n", + " 11: [155, 312, 174, 348],\n", + " 12: [111, 342, 238, 359],\n", + " 25: [449, 130, 479, 359]},\n", + " '0083': {1: [17, 0, 479, 314],\n", + " 5: [0, 0, 18, 55],\n", + " 6: [61, 0, 333, 359],\n", + " 7: [0, 55, 178, 359],\n", + " 8: [64, 58, 187, 359],\n", + " 25: [294, 53, 475, 359]},\n", + " '0072': {1: [244, 0, 275, 96],\n", + " 5: [0, 0, 186, 359],\n", + " 6: [275, 0, 479, 359],\n", + " 7: [140, 0, 387, 356],\n", + " 8: [258, 0, 413, 326],\n", + " 9: [40, 330, 361, 359],\n", + " 11: [214, 270, 229, 309],\n", + " 12: [123, 307, 313, 359]},\n", + " '0088': {1: [44, 0, 394, 183],\n", + " 2: [340, 194, 397, 245],\n", + " 4: [266, 0, 479, 148],\n", + " 6: [0, 31, 53, 359],\n", + " 9: [381, 334, 479, 359],\n", + " 14: [330, 240, 414, 359],\n", + " 18: [402, 147, 475, 266],\n", + " 25: [18, 86, 180, 359],\n", + " 28: [244, 88, 372, 359],\n", + " 29: [384, 90, 479, 349]},\n", + " '0063': {1: [221, 0, 273, 106],\n", + " 5: [0, 0, 217, 359],\n", + " 6: [218, 0, 479, 359],\n", + " 7: [127, 2, 377, 359],\n", + " 8: [249, 0, 390, 332],\n", + " 9: [34, 336, 130, 359],\n", + " 11: [203, 277, 225, 317],\n", + " 12: [116, 314, 305, 359]},\n", + " '0082': {1: [71, 0, 479, 143],\n", + " 5: [0, 0, 72, 359],\n", + " 6: [116, 0, 387, 359],\n", + " 7: [0, 43, 224, 359],\n", + " 8: [110, 47, 236, 359],\n", + " 11: [83, 351, 100, 359],\n", + " 25: [346, 44, 479, 359]},\n", + " '0086': {1: [153, 0, 404, 354],\n", + " 2: [367, 194, 391, 224],\n", + " 4: [377, 0, 479, 142],\n", + " 6: [0, 16, 164, 359],\n", + " 7: [0, 285, 10, 343],\n", + " 8: [0, 114, 17, 271],\n", + " 14: [369, 223, 479, 359],\n", + " 25: [81, 76, 324, 359],\n", + " 28: [376, 75, 479, 359]},\n", + " '0090': {1: [156, 0, 479, 347],\n", + " 2: [243, 171, 437, 239],\n", + " 4: [177, 0, 449, 142],\n", + " 7: [0, 239, 88, 300],\n", + " 9: [250, 295, 479, 359],\n", + " 14: [195, 212, 450, 359],\n", + " 18: [316, 141, 385, 254],\n", + " 25: [0, 81, 91, 359],\n", + " 28: [157, 84, 279, 359],\n", + " 29: [304, 88, 402, 335],\n", + " 30: [400, 67, 479, 295]},\n", + " '0091': {1: [130, 0, 479, 289],\n", + " 2: [200, 168, 396, 236],\n", + " 4: [144, 0, 402, 145],\n", + " 7: [0, 243, 57, 290],\n", + " 9: [199, 288, 479, 359],\n", + " 14: [156, 205, 406, 359],\n", + " 18: [288, 137, 355, 248],\n", + " 25: [0, 155, 61, 359],\n", + " 28: [112, 81, 242, 359],\n", + " 29: [272, 86, 373, 324],\n", + " 30: [369, 67, 479, 288]},\n", + " '0085': {1: [210, 0, 470, 355],\n", + " 2: [430, 195, 451, 227],\n", + " 4: [442, 0, 479, 138],\n", + " 6: [0, 12, 220, 359],\n", + " 7: [0, 276, 67, 359],\n", + " 8: [0, 75, 80, 359],\n", + " 14: [422, 223, 443, 359],\n", + " 25: [140, 73, 369, 359],\n", + " 28: [438, 137, 479, 359]},\n", + " '0048': {1: [224, 0, 273, 12],\n", + " 5: [0, 0, 223, 359],\n", + " 6: [274, 0, 479, 359],\n", + " 7: [161, 4, 382, 321],\n", + " 8: [279, 14, 409, 310],\n", + " 9: [101, 312, 474, 359],\n", + " 11: [277, 282, 292, 307],\n", + " 12: [208, 303, 353, 359]},\n", + " '0092': {1: [86, 0, 479, 346],\n", + " 2: [167, 162, 358, 235],\n", + " 4: [108, 0, 370, 135],\n", + " 7: [0, 244, 21, 269],\n", + " 9: [162, 279, 479, 359],\n", + " 14: [119, 204, 377, 359],\n", + " 18: [263, 134, 329, 244],\n", + " 25: [0, 172, 27, 359],\n", + " 26: [451, 129, 479, 274],\n", + " 28: [76, 76, 205, 359],\n", + " 29: [252, 83, 349, 319],\n", + " 30: [330, 62, 446, 281]},\n", + " '0089': {1: [0, 0, 309, 168],\n", + " 2: [291, 188, 353, 242],\n", + " 4: [225, 0, 479, 144],\n", + " 6: [0, 30, 4, 169],\n", + " 9: [309, 310, 479, 359],\n", + " 14: [286, 200, 479, 359],\n", + " 18: [360, 143, 432, 258],\n", + " 25: [0, 80, 139, 359],\n", + " 28: [204, 83, 327, 359],\n", + " 29: [342, 87, 453, 340],\n", + " 30: [454, 138, 479, 176]},\n", + " '0093': {1: [58, 0, 479, 281],\n", + " 2: [130, 179, 240, 236],\n", + " 4: [71, 0, 333, 136],\n", + " 9: [134, 278, 479, 359],\n", + " 14: [126, 214, 336, 359],\n", + " 18: [233, 137, 299, 247],\n", + " 26: [413, 97, 479, 281],\n", + " 28: [33, 77, 175, 359],\n", + " 29: [227, 87, 323, 319],\n", + " 30: [304, 67, 411, 281]},\n", + " '0096': {1: [0, 0, 464, 205],\n", + " 2: [19, 183, 132, 242],\n", + " 4: [0, 0, 220, 139],\n", + " 9: [44, 268, 479, 359],\n", + " 14: [20, 220, 132, 359],\n", + " 18: [126, 137, 190, 247],\n", + " 26: [298, 56, 426, 269],\n", + " 28: [0, 142, 61, 359],\n", + " 29: [117, 85, 216, 319],\n", + " 30: [192, 67, 299, 277]},\n", + " '0097': {1: [0, 0, 479, 206],\n", + " 2: [0, 182, 179, 240],\n", + " 4: [0, 0, 183, 135],\n", + " 9: [9, 264, 479, 359],\n", + " 14: [0, 220, 86, 359],\n", + " 18: [78, 134, 146, 247],\n", + " 26: [262, 55, 387, 265],\n", + " 28: [0, 183, 17, 229],\n", + " 29: [59, 81, 177, 321],\n", + " 30: [153, 64, 262, 275]},\n", + " '0068': {1: [225, 0, 273, 103],\n", + " 5: [0, 0, 224, 359],\n", + " 6: [272, 0, 479, 359],\n", + " 7: [135, 2, 385, 359],\n", + " 8: [257, 0, 402, 334],\n", + " 9: [52, 337, 140, 359],\n", + " 11: [209, 276, 228, 317],\n", + " 12: [126, 313, 319, 359]},\n", + " '0099': {1: [76, 0, 479, 209],\n", + " 2: [51, 158, 93, 208],\n", + " 4: [0, 0, 97, 133],\n", + " 9: [0, 256, 479, 359],\n", + " 14: [51, 198, 107, 291],\n", + " 18: [0, 132, 38, 250],\n", + " 26: [181, 51, 299, 263],\n", + " 29: [0, 76, 63, 324],\n", + " 30: [55, 59, 181, 275]},\n", + " '0100': {1: [42, 0, 479, 238],\n", + " 2: [0, 159, 47, 211],\n", + " 4: [0, 0, 50, 132],\n", + " 9: [0, 255, 479, 359],\n", + " 14: [0, 198, 65, 299],\n", + " 26: [138, 48, 255, 264],\n", + " 29: [0, 131, 14, 304],\n", + " 30: [6, 55, 139, 277]},\n", + " '0087': {1: [95, 0, 475, 359],\n", + " 2: [311, 194, 461, 246],\n", + " 4: [324, 0, 479, 148],\n", + " 6: [0, 24, 108, 359],\n", + " 14: [311, 225, 470, 359],\n", + " 18: [471, 181, 479, 259],\n", + " 25: [78, 85, 233, 359],\n", + " 28: [317, 88, 432, 359],\n", + " 29: [453, 146, 479, 359]},\n", + " '0102': {1: [0, 0, 479, 251],\n", + " 9: [0, 256, 479, 359],\n", + " 10: [126, 202, 230, 258],\n", + " 15: [472, 54, 479, 122],\n", + " 19: [214, 207, 376, 251],\n", + " 23: [437, 134, 479, 280],\n", + " 26: [16, 43, 160, 270],\n", + " 27: [390, 119, 479, 271],\n", + " 30: [0, 121, 32, 277]},\n", + " '0101': {1: [0, 0, 479, 257],\n", + " 9: [0, 256, 479, 359],\n", + " 10: [176, 201, 283, 261],\n", + " 19: [255, 210, 431, 256],\n", + " 26: [21, 45, 205, 280],\n", + " 27: [444, 175, 479, 280],\n", + " 30: [0, 50, 85, 282]},\n", + " '0104': {1: [0, 0, 479, 246],\n", + " 9: [0, 258, 479, 359],\n", + " 10: [39, 202, 148, 259],\n", + " 15: [386, 10, 479, 266],\n", + " 19: [130, 207, 294, 248],\n", + " 23: [355, 132, 454, 275],\n", + " 26: [0, 37, 73, 267],\n", + " 27: [310, 115, 405, 263]},\n", + " '0084': {1: [262, 0, 479, 359],\n", + " 6: [0, 11, 276, 359],\n", + " 7: [0, 158, 119, 359],\n", + " 8: [6, 70, 132, 359],\n", + " 25: [236, 68, 408, 359]},\n", + " '0094': {1: [15, 0, 479, 269],\n", + " 2: [95, 177, 212, 238],\n", + " 4: [32, 0, 297, 136],\n", + " 9: [102, 274, 479, 359],\n", + " 14: [93, 216, 297, 359],\n", + " 18: [202, 137, 268, 247],\n", + " 26: [374, 37, 479, 275],\n", + " 28: [0, 76, 142, 359],\n", + " 29: [197, 86, 289, 316],\n", + " 30: [271, 66, 377, 278]},\n", + " '0103': {1: [0, 0, 479, 248],\n", + " 9: [0, 257, 479, 359],\n", + " 10: [76, 200, 183, 258],\n", + " 15: [421, 25, 479, 218],\n", + " 19: [163, 208, 329, 248],\n", + " 23: [384, 131, 479, 279],\n", + " 26: [0, 39, 112, 271],\n", + " 27: [344, 113, 435, 265]},\n", + " '0110': {1: [0, 0, 479, 247],\n", + " 9: [0, 255, 479, 359],\n", + " 10: [132, 201, 238, 256],\n", + " 15: [468, 31, 479, 116],\n", + " 19: [215, 207, 384, 247],\n", + " 23: [453, 145, 479, 280],\n", + " 26: [30, 42, 164, 269],\n", + " 27: [407, 113, 479, 265],\n", + " 30: [0, 121, 40, 281]},\n", + " '0108': {1: [60, 0, 479, 254],\n", + " 9: [0, 249, 479, 359],\n", + " 10: [0, 202, 98, 260],\n", + " 15: [331, 0, 465, 255],\n", + " 19: [74, 205, 246, 248],\n", + " 23: [301, 126, 397, 266],\n", + " 26: [0, 138, 13, 195],\n", + " 27: [262, 110, 344, 254]},\n", + " '0113': {1: [52, 0, 479, 266],\n", + " 2: [58, 171, 120, 222],\n", + " 4: [0, 0, 117, 142],\n", + " 9: [0, 268, 479, 359],\n", + " 10: [292, 213, 405, 277],\n", + " 14: [67, 209, 142, 317],\n", + " 18: [0, 146, 53, 263],\n", + " 19: [383, 223, 479, 270],\n", + " 26: [199, 59, 326, 274],\n", + " 29: [0, 86, 76, 353],\n", + " 30: [73, 69, 208, 286]},\n", + " '0109': {1: [127, 0, 476, 240],\n", + " 9: [0, 251, 479, 359],\n", + " 10: [54, 199, 166, 255],\n", + " 15: [392, 0, 479, 259],\n", + " 19: [143, 203, 311, 245],\n", + " 23: [367, 124, 467, 269],\n", + " 26: [0, 37, 82, 261],\n", + " 27: [324, 109, 420, 256]},\n", + " '0112': {1: [15, 0, 479, 231],\n", + " 2: [0, 168, 73, 219],\n", + " 4: [0, 0, 65, 139],\n", + " 9: [0, 261, 479, 359],\n", + " 10: [252, 208, 359, 267],\n", + " 14: [0, 207, 96, 327],\n", + " 18: [0, 185, 3, 194],\n", + " 19: [338, 217, 479, 263],\n", + " 25: [0, 194, 2, 196],\n", + " 26: [158, 54, 282, 270],\n", + " 29: [0, 138, 26, 325],\n", + " 30: [24, 60, 169, 283]},\n", + " '0114': {1: [0, 0, 479, 238],\n", + " 2: [0, 176, 197, 262],\n", + " 4: [0, 0, 187, 153],\n", + " 9: [61, 277, 479, 359],\n", + " 10: [365, 224, 479, 289],\n", + " 14: [0, 214, 207, 359],\n", + " 18: [56, 151, 138, 262],\n", + " 19: [458, 234, 479, 274],\n", + " 26: [287, 67, 403, 280],\n", + " 28: [0, 165, 25, 250],\n", + " 29: [42, 94, 152, 344],\n", + " 30: [145, 76, 304, 297]},\n", + " '0095': {1: [35, 0, 457, 262],\n", + " 2: [54, 179, 174, 240],\n", + " 4: [0, 0, 258, 138],\n", + " 9: [75, 270, 479, 359],\n", + " 14: [55, 217, 261, 359],\n", + " 18: [162, 138, 231, 247],\n", + " 26: [337, 55, 476, 273],\n", + " 28: [0, 76, 100, 359],\n", + " 29: [158, 87, 252, 318],\n", + " 30: [233, 67, 336, 278]},\n", + " '0105': {1: [87, 0, 459, 242],\n", + " 9: [0, 255, 479, 359],\n", + " 10: [3, 200, 116, 258],\n", + " 15: [353, 0, 479, 259],\n", + " 19: [98, 204, 262, 249],\n", + " 23: [322, 126, 413, 268],\n", + " 26: [0, 95, 34, 259],\n", + " 27: [279, 110, 370, 257]},\n", + " '0107': {1: [42, 0, 479, 270],\n", + " 9: [0, 254, 479, 359],\n", + " 10: [0, 203, 76, 261],\n", + " 15: [314, 0, 451, 256],\n", + " 19: [55, 206, 227, 249],\n", + " 23: [283, 126, 388, 266],\n", + " 27: [245, 112, 327, 256]},\n", + " '0116': {2: [229, 163, 415, 253],\n", + " 9: [285, 305, 479, 359],\n", + " 14: [150, 0, 433, 358],\n", + " 18: [294, 150, 386, 261],\n", + " 25: [0, 111, 87, 359],\n", + " 28: [139, 103, 257, 359],\n", + " 29: [274, 99, 398, 345],\n", + " 30: [382, 77, 479, 305]},\n", + " '0111': {1: [0, 0, 479, 256],\n", + " 2: [0, 174, 8, 210],\n", + " 9: [0, 257, 479, 359],\n", + " 10: [196, 204, 301, 261],\n", + " 14: [0, 217, 7, 228],\n", + " 19: [281, 209, 450, 253],\n", + " 26: [98, 48, 226, 267],\n", + " 30: [0, 53, 105, 294]},\n", + " '0118': {2: [318, 203, 479, 264],\n", + " 4: [324, 0, 479, 156],\n", + " 6: [0, 59, 135, 359],\n", + " 14: [312, 254, 479, 358],\n", + " 25: [89, 110, 261, 359],\n", + " 28: [320, 104, 444, 359]},\n", + " '0117': {2: [324, 195, 420, 255],\n", + " 4: [231, 4, 479, 159],\n", + " 9: [419, 339, 479, 359],\n", + " 14: [231, 240, 418, 359],\n", + " 18: [400, 156, 479, 272],\n", + " 25: [0, 108, 180, 359],\n", + " 28: [233, 107, 349, 359],\n", + " 29: [378, 99, 479, 358]},\n", + " '0106': {1: [1, 0, 479, 262],\n", + " 9: [0, 255, 479, 359],\n", + " 10: [0, 202, 93, 260],\n", + " 15: [329, 0, 472, 257],\n", + " 19: [69, 205, 241, 248],\n", + " 23: [295, 125, 392, 267],\n", + " 26: [0, 133, 7, 195],\n", + " 27: [257, 112, 343, 255]},\n", + " '0120': {1: [0, 0, 304, 179],\n", + " 6: [3, 46, 282, 359],\n", + " 7: [0, 120, 155, 359],\n", + " 8: [10, 118, 160, 359],\n", + " 25: [250, 94, 429, 359]},\n", + " '0123': {1: [207, 0, 267, 96],\n", + " 5: [0, 0, 212, 359],\n", + " 6: [249, 29, 479, 359],\n", + " 7: [169, 95, 383, 359],\n", + " 8: [279, 103, 400, 359]},\n", + " '0122': {1: [130, 0, 461, 357],\n", + " 5: [0, 0, 143, 359],\n", + " 6: [171, 38, 436, 359],\n", + " 7: [88, 100, 302, 359],\n", + " 8: [210, 109, 319, 359],\n", + " 25: [398, 86, 479, 359]},\n", + " '0124': {5: [37, 0, 298, 359],\n", + " 6: [328, 18, 479, 359],\n", + " 7: [246, 85, 467, 359],\n", + " 8: [362, 90, 479, 359],\n", + " 22: [0, 40, 85, 359]},\n", + " '0121': {1: [35, 0, 372, 175],\n", + " 5: [0, 0, 56, 359],\n", + " 6: [79, 45, 350, 359],\n", + " 7: [0, 105, 220, 359],\n", + " 8: [109, 115, 230, 359],\n", + " 9: [82, 350, 114, 359],\n", + " 25: [315, 92, 479, 359]},\n", + " '0119': {1: [180, 0, 221, 184],\n", + " 4: [403, 0, 479, 156],\n", + " 6: [0, 52, 199, 359],\n", + " 7: [0, 331, 64, 359],\n", + " 8: [0, 130, 63, 349],\n", + " 25: [166, 104, 335, 359],\n", + " 28: [387, 97, 479, 359]},\n", + " '0126': {5: [196, 0, 447, 359],\n", + " 7: [395, 79, 479, 359],\n", + " 17: [45, 35, 203, 359],\n", + " 22: [34, 47, 240, 359]},\n", + " '0127': {1: [0, 136, 112, 229],\n", + " 5: [266, 0, 479, 359],\n", + " 13: [0, 205, 133, 323],\n", + " 17: [115, 35, 276, 345],\n", + " 21: [0, 0, 121, 143],\n", + " 22: [111, 40, 308, 359],\n", + " 24: [11, 288, 130, 359]},\n", + " '0125': {5: [118, 0, 364, 359],\n", + " 6: [406, 23, 479, 193],\n", + " 7: [316, 86, 479, 359],\n", + " 8: [446, 192, 479, 359],\n", + " 17: [0, 36, 122, 353],\n", + " 22: [0, 47, 161, 359]},\n", + " '0128': {1: [0, 126, 173, 226],\n", + " 3: [0, 0, 27, 131],\n", + " 5: [329, 0, 478, 357],\n", + " 13: [29, 207, 196, 319],\n", + " 16: [0, 154, 60, 359],\n", + " 17: [177, 33, 338, 340],\n", + " 21: [24, 0, 188, 141],\n", + " 22: [174, 37, 373, 359],\n", + " 24: [80, 282, 192, 359]},\n", + " '0129': {1: [45, 127, 231, 237],\n", + " 3: [0, 0, 99, 129],\n", + " 5: [390, 1, 478, 357],\n", + " 13: [98, 205, 254, 312],\n", + " 16: [0, 50, 126, 359],\n", + " 17: [234, 36, 380, 339],\n", + " 21: [2, 0, 241, 145],\n", + " 22: [230, 40, 436, 359],\n", + " 24: [133, 283, 247, 359]},\n", + " '0131': {1: [0, 130, 337, 237],\n", + " 3: [0, 1, 200, 134],\n", + " 13: [0, 207, 354, 337],\n", + " 16: [9, 45, 442, 359],\n", + " 17: [339, 35, 479, 346],\n", + " 21: [0, 0, 351, 143],\n", + " 22: [332, 38, 479, 358],\n", + " 24: [238, 262, 348, 359]},\n", + " '0132': {1: [0, 129, 356, 232],\n", + " 3: [0, 6, 230, 134],\n", + " 13: [0, 205, 376, 336],\n", + " 16: [25, 47, 479, 359],\n", + " 17: [354, 35, 479, 302],\n", + " 21: [0, 0, 375, 138],\n", + " 22: [351, 37, 479, 359],\n", + " 24: [257, 279, 370, 359]},\n", + " '0134': {1: [0, 138, 357, 240],\n", + " 3: [0, 15, 235, 142],\n", + " 13: [0, 212, 379, 346],\n", + " 16: [55, 60, 392, 359],\n", + " 17: [379, 20, 479, 334],\n", + " 21: [0, 0, 377, 157],\n", + " 22: [347, 41, 479, 359],\n", + " 24: [0, 331, 363, 359]},\n", + " '0137': {1: [0, 135, 327, 246],\n", + " 3: [0, 13, 206, 144],\n", + " 9: [477, 357, 479, 359],\n", + " 13: [0, 214, 337, 331],\n", + " 16: [20, 59, 242, 359],\n", + " 17: [308, 42, 459, 339],\n", + " 19: [473, 354, 479, 359],\n", + " 21: [0, 0, 344, 144],\n", + " 22: [313, 43, 479, 359],\n", + " 24: [0, 282, 326, 359],\n", + " 25: [478, 352, 479, 353]},\n", + " '0136': {1: [0, 134, 346, 241],\n", + " 3: [0, 16, 222, 142],\n", + " 13: [0, 211, 334, 337],\n", + " 16: [44, 59, 361, 359],\n", + " 17: [342, 40, 477, 348],\n", + " 21: [0, 0, 364, 154],\n", + " 22: [333, 43, 479, 359],\n", + " 24: [0, 321, 352, 359]},\n", + " '0130': {1: [112, 126, 290, 225],\n", + " 3: [0, 0, 159, 127],\n", + " 5: [453, 0, 479, 359],\n", + " 13: [161, 205, 311, 305],\n", + " 16: [0, 46, 208, 359],\n", + " 17: [292, 34, 446, 341],\n", + " 21: [146, 0, 303, 141],\n", + " 22: [284, 36, 479, 359],\n", + " 24: [193, 279, 305, 359]},\n", + " '0139': {1: [74, 132, 256, 222],\n", + " 3: [0, 12, 126, 132],\n", + " 5: [411, 0, 479, 359],\n", + " 13: [115, 204, 259, 305],\n", + " 16: [0, 53, 131, 359],\n", + " 17: [234, 43, 364, 332],\n", + " 21: [0, 0, 271, 142],\n", + " 22: [238, 44, 439, 359],\n", + " 24: [119, 283, 250, 359]},\n", + " '0143': {5: [248, 0, 479, 359],\n", + " 7: [427, 78, 479, 359],\n", + " 13: [0, 202, 97, 301],\n", + " 16: [0, 174, 4, 185],\n", + " 17: [65, 40, 210, 339],\n", + " 22: [71, 38, 269, 359],\n", + " 24: [0, 0, 105, 359]},\n", + " '0140': {1: [41, 134, 226, 221],\n", + " 3: [0, 9, 95, 135],\n", + " 5: [379, 0, 479, 359],\n", + " 13: [83, 207, 229, 310],\n", + " 16: [0, 56, 108, 359],\n", + " 17: [203, 46, 333, 336],\n", + " 21: [0, 0, 238, 148],\n", + " 22: [205, 47, 399, 359],\n", + " 24: [123, 284, 218, 359]},\n", + " '0141': {1: [0, 134, 186, 229],\n", + " 3: [0, 9, 50, 136],\n", + " 5: [339, 0, 479, 359],\n", + " 13: [42, 210, 192, 317],\n", + " 16: [0, 151, 50, 359],\n", + " 17: [166, 47, 294, 339],\n", + " 21: [0, 0, 200, 148],\n", + " 22: [167, 47, 360, 359],\n", + " 24: [79, 285, 181, 359]},\n", + " '0115': {1: [97, 0, 479, 278],\n", + " 2: [103, 175, 292, 251],\n", + " 4: [0, 0, 288, 157],\n", + " 9: [150, 285, 479, 359],\n", + " 14: [104, 211, 307, 359],\n", + " 18: [165, 147, 247, 254],\n", + " 26: [389, 57, 479, 285],\n", + " 28: [10, 94, 135, 359],\n", + " 29: [160, 89, 266, 336],\n", + " 30: [253, 76, 384, 290]},\n", + " '0098': {1: [0, 0, 479, 204],\n", + " 2: [0, 162, 139, 234],\n", + " 4: [0, 0, 143, 134],\n", + " 9: [0, 262, 479, 359],\n", + " 14: [0, 202, 149, 347],\n", + " 18: [24, 133, 96, 249],\n", + " 26: [225, 55, 346, 266],\n", + " 29: [6, 77, 113, 327],\n", + " 30: [109, 63, 225, 276]},\n", + " '0142': {1: [0, 143, 142, 219],\n", + " 3: [0, 48, 4, 144],\n", + " 5: [299, 0, 479, 359],\n", + " 13: [1, 212, 150, 317],\n", + " 16: [0, 145, 66, 315],\n", + " 17: [124, 49, 256, 343],\n", + " 21: [0, 0, 157, 148],\n", + " 22: [124, 46, 318, 359],\n", + " 24: [32, 286, 141, 359]},\n", + " '0145': {1: [376, 0, 479, 101],\n", + " 5: [157, 1, 385, 359],\n", + " 6: [429, 9, 479, 157],\n", + " 7: [318, 68, 479, 359],\n", + " 8: [420, 127, 479, 359],\n", + " 17: [0, 29, 111, 325],\n", + " 22: [0, 28, 171, 359]},\n", + " '0146': {1: [370, 49, 373, 56],\n", + " 5: [112, 0, 342, 359],\n", + " 6: [383, 0, 479, 359],\n", + " 7: [278, 63, 479, 359],\n", + " 8: [374, 65, 479, 359],\n", + " 17: [0, 109, 63, 330],\n", + " 22: [0, 22, 124, 359]},\n", + " '0147': {5: [72, 0, 303, 359],\n", + " 6: [346, 0, 479, 359],\n", + " 7: [241, 62, 458, 359],\n", + " 8: [343, 64, 471, 359],\n", + " 11: [320, 350, 333, 359],\n", + " 17: [0, 303, 21, 333],\n", + " 22: [0, 23, 87, 359]},\n", + " '0151': {5: [0, 0, 213, 359],\n", + " 6: [259, 0, 479, 359],\n", + " 7: [154, 26, 370, 359],\n", + " 8: [259, 27, 382, 349],\n", + " 9: [119, 339, 212, 359],\n", + " 11: [213, 319, 260, 340],\n", + " 12: [198, 336, 305, 359],\n", + " 22: [311, 330, 334, 359]},\n", + " '0144': {1: [0, 0, 479, 142],\n", + " 5: [204, 0, 438, 359],\n", + " 7: [370, 72, 479, 359],\n", + " 13: [0, 211, 45, 295],\n", + " 17: [18, 39, 162, 345],\n", + " 21: [0, 0, 50, 136],\n", + " 22: [15, 36, 218, 359],\n", + " 24: [0, 288, 35, 359]},\n", + " '0150': {5: [0, 0, 224, 359],\n", + " 6: [270, 0, 479, 359],\n", + " 7: [163, 40, 379, 359],\n", + " 8: [266, 42, 391, 359],\n", + " 9: [183, 354, 248, 359],\n", + " 11: [245, 338, 270, 359],\n", + " 16: [0, 167, 0, 171],\n", + " 21: [428, 0, 459, 4],\n", + " 22: [0, 172, 343, 359]},\n", + " '0152': {5: [0, 0, 197, 359],\n", + " 6: [255, 0, 479, 359],\n", + " 7: [145, 0, 364, 340],\n", + " 8: [250, 4, 379, 328],\n", + " 9: [73, 319, 404, 359],\n", + " 11: [234, 295, 251, 314],\n", + " 12: [167, 312, 309, 359],\n", + " 22: [306, 311, 328, 331]},\n", + " '0155': {5: [0, 0, 176, 359],\n", + " 6: [246, 0, 479, 359],\n", + " 7: [126, 0, 361, 332],\n", + " 8: [244, 0, 389, 316],\n", + " 9: [63, 325, 432, 359],\n", + " 11: [231, 281, 246, 311],\n", + " 12: [153, 310, 318, 359]},\n", + " '0148': {5: [39, 1, 273, 357],\n", + " 6: [315, 0, 479, 359],\n", + " 7: [209, 58, 422, 359],\n", + " 8: [313, 64, 433, 359],\n", + " 11: [289, 350, 303, 359],\n", + " 22: [0, 107, 54, 359]},\n", + " '0154': {5: [0, 0, 194, 359],\n", + " 6: [255, 0, 479, 359],\n", + " 7: [144, 0, 373, 345],\n", + " 8: [258, 0, 391, 329],\n", + " 9: [88, 331, 366, 359],\n", + " 11: [242, 295, 258, 321],\n", + " 12: [173, 320, 326, 359],\n", + " 22: [315, 334, 320, 339]},\n", + " '0159': {5: [0, 0, 152, 359],\n", + " 6: [224, 0, 479, 359],\n", + " 7: [88, 0, 340, 332],\n", + " 8: [239, 14, 415, 311],\n", + " 9: [56, 333, 467, 359],\n", + " 11: [216, 276, 245, 311],\n", + " 12: [139, 310, 324, 359]},\n", + " '0162': {5: [0, 0, 143, 354],\n", + " 6: [234, 0, 479, 329],\n", + " 7: [82, 0, 332, 296],\n", + " 8: [242, 31, 421, 276],\n", + " 9: [0, 296, 479, 359],\n", + " 11: [230, 252, 242, 276],\n", + " 12: [136, 272, 328, 359]},\n", + " '0163': {5: [0, 0, 142, 354],\n", + " 6: [244, 0, 479, 329],\n", + " 7: [87, 0, 342, 295],\n", + " 8: [248, 1, 417, 251],\n", + " 9: [0, 296, 479, 359],\n", + " 11: [230, 259, 242, 279],\n", + " 12: [136, 273, 329, 359]},\n", + " '0158': {5: [0, 0, 142, 359],\n", + " 6: [219, 0, 479, 359],\n", + " 7: [88, 0, 336, 336],\n", + " 8: [228, 0, 416, 318],\n", + " 9: [60, 337, 385, 359],\n", + " 11: [214, 280, 234, 318],\n", + " 12: [142, 316, 314, 359]},\n", + " '0149': {5: [4, 0, 244, 359],\n", + " 6: [288, 0, 479, 359],\n", + " 7: [183, 46, 396, 359],\n", + " 8: [280, 47, 409, 359],\n", + " 9: [178, 354, 266, 359],\n", + " 11: [262, 339, 281, 359],\n", + " 12: [264, 359, 264, 359],\n", + " 21: [454, 0, 471, 8],\n", + " 22: [0, 141, 358, 359]},\n", + " '0157': {5: [0, 0, 144, 359],\n", + " 6: [226, 0, 479, 359],\n", + " 7: [93, 0, 336, 337],\n", + " 8: [224, 0, 400, 322],\n", + " 9: [63, 337, 146, 359],\n", + " 11: [210, 288, 228, 322],\n", + " 12: [141, 320, 308, 359]},\n", + " '0165': {1: [223, 279, 227, 282],\n", + " 5: [0, 0, 160, 359],\n", + " 6: [232, 0, 479, 340],\n", + " 7: [102, 0, 359, 311],\n", + " 8: [231, 0, 400, 288],\n", + " 9: [6, 305, 479, 359],\n", + " 11: [226, 263, 246, 286],\n", + " 12: [139, 283, 329, 359]},\n", + " '0133': {1: [0, 129, 362, 237],\n", + " 3: [3, 8, 240, 136],\n", + " 13: [0, 205, 384, 336],\n", + " 16: [55, 54, 479, 359],\n", + " 17: [360, 24, 479, 325],\n", + " 21: [0, 0, 382, 159],\n", + " 22: [357, 39, 479, 359],\n", + " 24: [0, 271, 376, 359]},\n", + " '0156': {5: [0, 0, 156, 359],\n", + " 6: [229, 0, 479, 359],\n", + " 7: [102, 0, 346, 331],\n", + " 8: [229, 0, 394, 316],\n", + " 9: [50, 328, 430, 359],\n", + " 11: [217, 277, 229, 313],\n", + " 12: [138, 311, 309, 359]},\n", + " '0153': {5: [0, 0, 191, 359],\n", + " 6: [254, 0, 479, 359],\n", + " 7: [142, 0, 363, 342],\n", + " 8: [247, 1, 381, 335],\n", + " 9: [74, 324, 362, 359],\n", + " 11: [234, 297, 249, 319],\n", + " 12: [164, 317, 310, 359],\n", + " 22: [304, 320, 325, 339]},\n", + " '0169': {5: [0, 0, 191, 359],\n", + " 6: [251, 0, 479, 359],\n", + " 7: [131, 6, 370, 359],\n", + " 8: [249, 7, 392, 345],\n", + " 9: [111, 342, 197, 359],\n", + " 11: [252, 329, 260, 336],\n", + " 12: [190, 332, 323, 359]},\n", + " '0166': {5: [0, 0, 180, 359],\n", + " 6: [235, 0, 479, 349],\n", + " 7: [110, 0, 368, 314],\n", + " 8: [245, 0, 425, 314],\n", + " 9: [47, 317, 479, 359],\n", + " 11: [237, 281, 260, 300],\n", + " 12: [151, 298, 338, 359]},\n", + " '0171': {1: [192, 0, 241, 56],\n", + " 5: [0, 0, 192, 332],\n", + " 6: [238, 0, 479, 359],\n", + " 7: [124, 11, 350, 342],\n", + " 8: [230, 26, 389, 333],\n", + " 9: [153, 355, 329, 359],\n", + " 12: [157, 333, 308, 359],\n", + " 16: [0, 286, 251, 359],\n", + " 22: [346, 191, 390, 205],\n", + " 25: [478, 188, 479, 198]},\n", + " '0172': {1: [190, 0, 240, 112],\n", + " 5: [0, 0, 191, 339],\n", + " 6: [238, 0, 479, 359],\n", + " 7: [77, 23, 356, 350],\n", + " 8: [227, 43, 383, 345],\n", + " 12: [256, 339, 297, 359],\n", + " 16: [0, 0, 259, 359],\n", + " 25: [470, 176, 479, 359]},\n", + " '0170': {1: [199, 0, 248, 107],\n", + " 5: [0, 0, 198, 359],\n", + " 6: [247, 0, 479, 359],\n", + " 7: [132, 19, 362, 344],\n", + " 8: [243, 23, 389, 359],\n", + " 9: [108, 344, 193, 359],\n", + " 11: [244, 329, 252, 349],\n", + " 12: [184, 337, 309, 359],\n", + " 16: [0, 259, 190, 359]},\n", + " '0164': {5: [0, 0, 149, 353],\n", + " 6: [247, 0, 479, 330],\n", + " 7: [95, 0, 351, 295],\n", + " 8: [220, 0, 413, 274],\n", + " 9: [0, 296, 479, 359],\n", + " 11: [227, 254, 246, 278],\n", + " 12: [137, 273, 328, 359]},\n", + " '0173': {1: [188, 0, 253, 94],\n", + " 5: [4, 0, 189, 359],\n", + " 6: [230, 0, 479, 359],\n", + " 7: [129, 47, 324, 359],\n", + " 8: [230, 69, 374, 359],\n", + " 12: [261, 359, 264, 359],\n", + " 16: [0, 0, 260, 359],\n", + " 25: [464, 173, 479, 359]},\n", + " '0168': {5: [0, 0, 186, 359],\n", + " 6: [252, 0, 479, 359],\n", + " 7: [127, 0, 375, 329],\n", + " 8: [248, 0, 392, 354],\n", + " 9: [87, 328, 373, 359],\n", + " 11: [250, 310, 264, 321],\n", + " 12: [175, 319, 342, 359]},\n", + " '0138': {1: [0, 134, 290, 218],\n", + " 3: [0, 15, 170, 142],\n", + " 5: [453, 0, 479, 359],\n", + " 13: [164, 209, 302, 304],\n", + " 16: [0, 58, 174, 359],\n", + " 17: [277, 45, 411, 336],\n", + " 21: [0, 0, 309, 147],\n", + " 22: [278, 45, 479, 359],\n", + " 24: [163, 285, 291, 359]},\n", + " '0178': {1: [193, 0, 256, 99],\n", + " 5: [0, 0, 193, 359],\n", + " 6: [237, 8, 479, 359],\n", + " 7: [143, 70, 303, 359],\n", + " 8: [238, 90, 360, 359],\n", + " 16: [0, 22, 165, 359],\n", + " 25: [465, 185, 479, 265]},\n", + " '0179': {1: [193, 0, 257, 97],\n", + " 5: [0, 0, 193, 359],\n", + " 6: [237, 6, 479, 359],\n", + " 7: [141, 70, 304, 359],\n", + " 8: [239, 89, 361, 359],\n", + " 16: [0, 37, 210, 359],\n", + " 25: [466, 185, 479, 268]},\n", + " '0177': {1: [191, 0, 255, 103],\n", + " 5: [0, 0, 247, 359],\n", + " 6: [237, 6, 479, 359],\n", + " 7: [143, 67, 303, 359],\n", + " 8: [237, 89, 359, 359],\n", + " 12: [221, 359, 238, 359],\n", + " 16: [0, 17, 142, 359],\n", + " 25: [463, 177, 479, 264]},\n", + " '0175': {1: [190, 0, 251, 100],\n", + " 5: [0, 0, 199, 359],\n", + " 6: [234, 6, 479, 359],\n", + " 7: [141, 70, 308, 335],\n", + " 8: [250, 93, 365, 359],\n", + " 16: [0, 20, 270, 359],\n", + " 25: [463, 179, 479, 267]},\n", + " '0167': {5: [0, 0, 186, 359],\n", + " 6: [247, 0, 479, 359],\n", + " 7: [124, 0, 377, 338],\n", + " 8: [261, 0, 391, 336],\n", + " 9: [83, 331, 187, 359],\n", + " 11: [254, 304, 264, 317],\n", + " 12: [170, 317, 346, 359]},\n", + " '0160': {5: [0, 0, 171, 359],\n", + " 6: [236, 0, 479, 357],\n", + " 7: [93, 0, 347, 318],\n", + " 8: [248, 27, 427, 297],\n", + " 9: [34, 318, 479, 359],\n", + " 11: [229, 270, 248, 301],\n", + " 12: [143, 296, 332, 359]},\n", + " '0174': {1: [184, 0, 247, 100],\n", + " 5: [0, 0, 184, 359],\n", + " 6: [230, 0, 479, 359],\n", + " 7: [131, 62, 311, 359],\n", + " 8: [235, 82, 362, 359],\n", + " 16: [0, 9, 247, 359],\n", + " 25: [458, 163, 479, 359]},\n", + " '0135': {1: [0, 138, 352, 240],\n", + " 3: [0, 15, 231, 140],\n", + " 13: [0, 199, 346, 337],\n", + " 16: [54, 58, 367, 359],\n", + " 17: [343, 45, 479, 344],\n", + " 21: [0, 0, 371, 157],\n", + " 22: [343, 44, 479, 359],\n", + " 24: [0, 321, 356, 359]},\n", + " '0161': {5: [0, 0, 158, 358],\n", + " 6: [236, 0, 479, 334],\n", + " 7: [86, 0, 342, 302],\n", + " 8: [243, 27, 428, 286],\n", + " 9: [0, 302, 479, 359],\n", + " 11: [234, 260, 243, 281],\n", + " 12: [138, 276, 329, 359]},\n", + " '0176': {1: [191, 0, 253, 115],\n", + " 5: [0, 0, 193, 335],\n", + " 6: [237, 1, 479, 359],\n", + " 7: [60, 64, 304, 359],\n", + " 8: [191, 86, 362, 359],\n", + " 12: [217, 352, 252, 359],\n", + " 16: [0, 15, 287, 359],\n", + " 25: [464, 174, 479, 355]},\n", + " '0076': {1: [225, 0, 272, 105],\n", + " 5: [0, 0, 224, 359],\n", + " 6: [271, 0, 479, 359],\n", + " 7: [140, 4, 392, 359],\n", + " 8: [263, 0, 410, 343],\n", + " 9: [72, 343, 145, 359],\n", + " 11: [215, 285, 228, 322],\n", + " 12: [138, 319, 312, 359]}}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pickle\n", + "with open(\"/weka-train/royg/pvsg/pvsg_bbox_data/vidor/0001_4164158586.pkl\", \"rb\") as f:\n", + " bbox_data = pickle.load(f)\n", + "bbox_data" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1c77cacc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# visualize bbox\n", + "import matplotlib.pyplot as plt\n", + "from PIL import Image, ImageDraw\n", + "image = Image.open(mask_name)\n", + "draw = ImageDraw.Draw(image)\n", + "for obj in bbox_data['0000']:\n", + " if obj == 6:\n", + " bbox = bbox_data['0000'][obj]\n", + " # bbox = obj\n", + " draw.rectangle([bbox[0], bbox[1], bbox[2], bbox[3]], outline='red', width=2)\n", + " # draw.text((bbox[0], bbox[1]), str(obj['object_id']), fill='red')\n", + "plt.imshow(image)" + ] + }, + { + "cell_type": "markdown", + "id": "25b41ce3", + "metadata": {}, + "source": [ + "### Understanding Relations" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8ff8b5cf", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[[27, 23, 'holding', [[102, 110]]],\n", + " [29, 18, 'holding', [[87, 101]]],\n", + " [7, 8, 'holding', [[0, 86], [119, 125], [145, 179]]],\n", + " [22, 17, 'holding', [[0, 6], [125, 148]]],\n", + " [7, 12, 'looking at', [[0, 2], [55, 62]]],\n", + " [7, 8, 'looking at', [[17, 54], [63, 84], [166, 171]]],\n", + " [8, 12, 'looking at', [[4, 10], [36, 43]]],\n", + " [7, 11, 'blowing', [[157, 166]]],\n", + " [8, 11, 'blowing', [[157, 166]]],\n", + " [8, 12, 'pointing to', [[171, 179]]],\n", + " [11, 12, 'on', [[0, 179]]],\n", + " [12, 9, 'on', [[0, 179]]],\n", + " [20, 9, 'on', [[0, 179]]],\n", + " [16, 11, 'picking', [[171, 179]]],\n", + " [23, 9, 'sitting on', [[103, 110]]]]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Now you understand the key \"objects\", then let's look at relations.\n", + "data[vid]['relations']" + ] + }, + { + "cell_type": "markdown", + "id": "39e674a8", + "metadata": {}, + "source": [ + "[27, 23, 'holding', [[102, 110]]] means the object_id=27 is holding object_id=23 during frame 102 to frame 110, inclusively. \n", + "\n", + "Below we plot the relation." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8df36e0b", + "metadata": {}, + "outputs": [], + "source": [ + "# visualization\n", + "def draw_selected_mask(mask, draw):\n", + " color = (255, 0, 0, 153)\n", + " nonzero_coords = np.transpose(np.nonzero(mask))\n", + " for coord in nonzero_coords:\n", + " draw.point(coord[::-1], fill=color)\n", + " \n", + "def draw_object_mask(mask, draw):\n", + " color = (0, 0, 255, 153)\n", + " nonzero_coords = np.transpose(np.nonzero(mask))\n", + " for coord in nonzero_coords:\n", + " draw.point(coord[::-1], fill=color)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d0bd1c4e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# [27, 23, 'holding', [[102, 110]]]\n", + "fig, axes = plt.subplots(3, 3, figsize=(20, 20))\n", + "for i, frame_id in enumerate(range(102, 110 + 1)):\n", + " img_name = os.path.join(data_root, 'vidor', 'frames', vid, f'{str(frame_id).zfill(4)}.png')\n", + " mask_name = os.path.join(data_root, 'vidor', 'masks', vid, f'{str(frame_id).zfill(4)}.png')\n", + " \n", + " image = Image.open(img_name)\n", + " mask = Image.open(mask_name)\n", + " mask = np.array(mask)\n", + " \n", + " pil_image = image.convert('RGBA') \n", + " mask_image = Image.new('RGBA', pil_image.size, color=(0, 0, 0, 0))\n", + " mask_draw = ImageDraw.Draw(mask_image)\n", + "\n", + " draw_selected_mask(mask == 27, mask_draw) # subject plot red\n", + " draw_object_mask(mask == 23, mask_draw) # object plot blue\n", + "\n", + " current_pil_image = pil_image.copy()\n", + " current_pil_image.alpha_composite(mask_image)\n", + " \n", + " ax = axes[i // 3, i % 3]\n", + " ax.imshow(current_pil_image)\n", + " ax.axis('off')\n", + " ax.set_title(f\"Frame {frame_id}\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e7dde1b9", + "metadata": {}, + "source": [ + "### Understanding Caption and QA Pairs\n", + "\n", + "We also provide captioning, qa pairs, and video summary. The number in brackets represents the object id." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "816bfab9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'time': '0000-0008',\n", + " 'description': 'A man (22) carries a child (17) and walks to the left from behind a woman (7) holding another child (8).'},\n", + " {'time': '0009-0047',\n", + " 'description': 'The woman (7) rocks and holds the child (8), singing a birthday song together with another woman (25) to celebrate the birthday of the girl (8).'},\n", + " {'time': '0048-0079',\n", + " 'description': 'The woman (7) smiles and holds the child (8) in front of the cake (12).'},\n", + " {'time': '0080-0122',\n", + " 'description': \"The camera shifts to the right, showing a woman (25), a man (28), a woman (29) holding a baby (baby-1), two men (30) (26), and a woman (27) holding a boy (23), all singing a birthday song to celebrate the girl's (8) birthday.\"},\n", + " {'time': '0123-0155',\n", + " 'description': \"The woman (7) on the left side, holding the child (17), and the man (22) and woman (16) are singing a birthday song to celebrate the girl (8)'s birthday.\"},\n", + " {'time': '0156-0179',\n", + " 'description': 'The girl (8) and the woman (7) blow out the candles (11) on the cake (12) together and laugh happily.'},\n", + " {'time': '0171-0179',\n", + " 'description': 'The woman (16) picks up the candles (11).'}]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[vid]['captions']" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e784c398", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'time': '0018',\n", + " 'question': 'Why are the woman (7) and the girl (8) smiling?',\n", + " 'answer': \"Because it's the girl (8)'s birthday, and they (7) (8) are very happy.\"},\n", + " {'time': '0058',\n", + " 'question': 'Why is the man (28) singing?',\n", + " 'answer': \"Because he is celebrating the girl (8)'s birthday and singing a birthday song for her.\"},\n", + " {'time': '0128',\n", + " 'question': 'Why is the woman (16) dancing and gesturing with her hands?',\n", + " 'answer': \"Because she is adding to the festive atmosphere and making the girl (8)'s birthday celebration lively.\"},\n", + " {'time': '0158',\n", + " 'question': 'Why is the woman (7) bending down?',\n", + " 'answer': 'Because she (7) is going to blow out the candles together with the little girl (8).'}]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[vid]['qa_pairs']" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f540a32a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'A scene where a group of adults and children celebrate the birthday of a little girl'" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data[vid]['summary']" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/OpenPVSG/roy_process/get_bbox.py b/OpenPVSG/roy_process/get_bbox.py new file mode 100644 index 0000000000000000000000000000000000000000..2822d78b0666bcff2094cff91794d7eef0a0c49a --- /dev/null +++ b/OpenPVSG/roy_process/get_bbox.py @@ -0,0 +1,297 @@ +""" +PVSG Multi-Process BBox Extractor +================================= + +使用多进程快速从PVSG数据集的mask文件中提取bbox坐标。 +支持视频级别和帧级别的并行处理。 + +优化策略: +1. 视频级并行:多个进程同时处理不同的视频 +2. 帧级并行:单个视频内部多个进程处理不同帧(适用于长视频) +3. 内存优化:及时释放mask数据 +4. 批量保存:减少I/O操作 +""" + +import os +import pickle +import numpy as np +from PIL import Image +from pathlib import Path +import multiprocessing as mp +from concurrent.futures import ProcessPoolExecutor, as_completed +from functools import partial +import time + +def extract_bbox_from_mask(mask, object_id): + """从mask中提取指定object_id的bbox坐标""" + object_mask = (mask == object_id) + + if not np.any(object_mask): + return None + + coords = np.where(object_mask) + y_coords, x_coords = coords[0], coords[1] + + x_min, x_max = x_coords.min(), x_coords.max() + y_min, y_max = y_coords.min(), y_coords.max() + + return [int(x_min), int(y_min), int(x_max), int(y_max)] + +def process_single_frame(mask_file_path): + """ + 处理单帧mask文件 + + Args: + mask_file_path (str): mask文件路径 + + Returns: + tuple: (frame_id, frame_data) 或 (frame_id, None) 如果出错 + """ + try: + mask_file = Path(mask_file_path) + frame_id = mask_file.stem + + # 读取mask + mask = np.array(Image.open(mask_file)) + + # 处理RGB图像 + if len(mask.shape) == 3: + mask = mask[:, :, 0] + + # 获取unique object IDs + unique_ids = np.unique(mask) + unique_ids = unique_ids[unique_ids > 0] + + # 计算每个object的bbox + frame_data = {} + for obj_id in unique_ids: + bbox = extract_bbox_from_mask(mask, obj_id) + if bbox is not None: + frame_data[int(obj_id)] = bbox + + # 释放内存 + del mask + + return (frame_id, frame_data if frame_data else None) + + except Exception as e: + print(f"Error processing {mask_file_path}: {e}") + return (Path(mask_file_path).stem, None) + +def process_video_parallel_frames(video_mask_path, output_path, max_workers=None): + """ + 并行处理单个视频的所有帧 + + Args: + video_mask_path (str): 视频mask文件夹路径 + output_path (str): 输出pkl文件路径 + max_workers (int): 最大并行进程数 + """ + video_mask_dir = Path(video_mask_path) + + # 获取所有mask文件 + mask_files = sorted(video_mask_dir.glob("*.png")) + + if not mask_files: + print(f"No mask files found in {video_mask_path}") + return + + print(f"Processing video: {video_mask_dir.name} ({len(mask_files)} frames)") + + video_data = {} + + # 使用ProcessPoolExecutor并行处理帧 + with ProcessPoolExecutor(max_workers=max_workers) as executor: + # 提交所有任务 + future_to_file = { + executor.submit(process_single_frame, str(mask_file)): mask_file + for mask_file in mask_files + } + + # 收集结果 + processed_count = 0 + for future in as_completed(future_to_file): + frame_id, frame_data = future.result() + + if frame_data is not None: + video_data[frame_id] = frame_data + + processed_count += 1 + if processed_count % 50 == 0: # 每处理50帧打印一次进度 + print(f" Processed {processed_count}/{len(mask_files)} frames") + + # 保存结果 + os.makedirs(os.path.dirname(output_path), exist_ok=True) + with open(output_path, 'wb') as f: + pickle.dump(video_data, f) + + print(f" Saved: {output_path} ({len(video_data)} valid frames)") + return len(video_data) + +def process_single_video_wrapper(args): + """ + 单个视频处理的包装函数,用于多进程调用 + + Args: + args (tuple): (video_dir_path, output_path, frame_workers) + """ + video_dir_path, output_path, frame_workers = args + + try: + start_time = time.time() + frame_count = process_video_parallel_frames(video_dir_path, output_path, frame_workers) + end_time = time.time() + + video_name = Path(video_dir_path).name + print(f"✓ Completed {video_name}: {frame_count} frames in {end_time-start_time:.1f}s") + return True + + except Exception as e: + video_name = Path(video_dir_path).name + print(f"✗ Failed {video_name}: {e}") + return False + +def batch_process_dataset_multiprocess(dataset_path, output_base_path, + video_workers=None, frame_workers=4): + """ + 多进程批量处理整个数据集 + + Args: + dataset_path (str): 数据集根路径 + output_base_path (str): 输出文件夹根路径 + video_workers (int): 同时处理的视频数量(None=CPU核心数) + frame_workers (int): 每个视频内部的帧处理进程数 + """ + if video_workers is None: + video_workers = mp.cpu_count() + + print(f"Using {video_workers} video workers, {frame_workers} frame workers per video") + + dataset_root = Path(dataset_path) + all_tasks = [] + + # 收集所有待处理的视频任务 + for dataset_name in ['vidor', 'ego4d', 'epic_kitchen']: + dataset_masks_path = dataset_root / dataset_name / 'masks' + + if not dataset_masks_path.exists(): + print(f"Warning: {dataset_masks_path} does not exist, skipping...") + continue + + video_dirs = [d for d in dataset_masks_path.iterdir() if d.is_dir()] + + for video_dir in video_dirs: + video_id = video_dir.name + output_pkl_path = Path(output_base_path) / dataset_name / f"{video_id}.pkl" + + # 跳过已存在的文件 + if output_pkl_path.exists(): + print(f"Skipping {video_id} (already exists)") + continue + + all_tasks.append((str(video_dir), str(output_pkl_path), frame_workers)) + + if not all_tasks: + print("No videos to process!") + return + + print(f"\nTotal videos to process: {len(all_tasks)}") + print("=" * 60) + + # 多进程处理视频 + start_time = time.time() + success_count = 0 + + with ProcessPoolExecutor(max_workers=video_workers) as executor: + futures = [executor.submit(process_single_video_wrapper, task) for task in all_tasks] + + for i, future in enumerate(as_completed(futures)): + success = future.result() + if success: + success_count += 1 + + # 打印总体进度 + progress = (i + 1) / len(all_tasks) * 100 + print(f"Overall progress: {i+1}/{len(all_tasks)} ({progress:.1f}%)") + + end_time = time.time() + total_time = end_time - start_time + + print("=" * 60) + print(f"Processing completed!") + print(f"Success: {success_count}/{len(all_tasks)} videos") + print(f"Total time: {total_time:.1f}s ({total_time/60:.1f} minutes)") + print(f"Average: {total_time/len(all_tasks):.1f}s per video") + +def get_dataset_stats(dataset_path): + """获取数据集统计信息""" + dataset_root = Path(dataset_path) + total_videos = 0 + total_frames = 0 + + print("Dataset Statistics:") + print("-" * 40) + + for dataset_name in ['vidor', 'ego4d', 'epic_kitchen']: + dataset_masks_path = dataset_root / dataset_name / 'masks' + + if not dataset_masks_path.exists(): + continue + + video_dirs = [d for d in dataset_masks_path.iterdir() if d.is_dir()] + dataset_frames = 0 + + for video_dir in video_dirs: + frame_count = len(list(video_dir.glob("*.png"))) + dataset_frames += frame_count + + total_videos += len(video_dirs) + total_frames += dataset_frames + + print(f"{dataset_name:12}: {len(video_dirs):4} videos, {dataset_frames:6} frames") + + print("-" * 40) + print(f"{'Total':12}: {total_videos:4} videos, {total_frames:6} frames") + print() + +def main(): + """主函数""" + # 配置路径 + dataset_path = "/weka-train/jamesp/data/PVSG_dataset" + output_path = "/weka-train/royg/pvsg/pvsg_bbox_data" # 请修改为你的输出路径 + + # 获取数据集统计信息 + get_dataset_stats(dataset_path) + + # 配置并行参数 + video_workers = mp.cpu_count() # 同时处理的视频数 + frame_workers = 16 # 每个视频内部的帧处理进程数 + + print(f"CPU cores: {mp.cpu_count()}") + print(f"Video workers: {video_workers}") + print(f"Frame workers per video: {frame_workers}") + print() + + # 开始处理 + batch_process_dataset_multiprocess( + dataset_path=dataset_path, + output_base_path=output_path, + video_workers=video_workers, + frame_workers=frame_workers + ) + +def process_single_video_only(video_path, output_path, frame_workers=8): + """只处理单个视频的便捷函数""" + print(f"Processing single video: {video_path}") + process_video_parallel_frames(video_path, output_path, frame_workers) + +if __name__ == "__main__": + # 单个视频测试 + # process_single_video_only( + # "/weka-train/jamesp/data/PVSG_dataset/vidor/masks/0001_4164158586", + # "/tmp/test_0001_4164158586.pkl", + # frame_workers=8 + # ) + + # 批量处理 + main() \ No newline at end of file diff --git a/OpenPVSG/roy_process/get_rle_mask.py b/OpenPVSG/roy_process/get_rle_mask.py new file mode 100644 index 0000000000000000000000000000000000000000..20fb247987740d4f4a2c284098abc2e784d502cf --- /dev/null +++ b/OpenPVSG/roy_process/get_rle_mask.py @@ -0,0 +1,680 @@ +""" +PVSG RLE Exporter + Multiprocessing + Visualization + Sidecars (indent-fixed) +============================================================================ + +Features +-------- +1) Export per-video **2D RLE JSON** (frames × objects, COCO RLE per cell). Objects strictly + follow the order in `pvsg.json` for the given video. +2) Multiprocessing: video-level (`--video_workers`) and optional frame-level (`--frame_workers`). +3) Visualization: + - `viz`: save a PNG for frame 0 with one object's mask & bbox. + - `viz-video`: overlay one object's mask across the entire MP4 and save an annotated video. +4) Sidecars: + - `emit-objjson`: per-video, write `/