# Ultralytics YOLO 🚀, AGPL-3.0 license
import torch
from ultralytics.engine.predictor import BasePredictor
from ultralytics.engine.results import Results
from ultralytics.utils import ops


class DetectionPredictor(BasePredictor):
    """
    A class extending the BasePredictor class for prediction based on a detection model.

    Example:
        ```python
        from ultralytics.utils import ASSETS
        from ultralytics.models.yolo.detect import DetectionPredictor

        args = dict(model='yolov8n.pt', source=ASSETS)
        predictor = DetectionPredictor(overrides=args)
        predictor.predict_cli()
        ```
    """

    def postprocess(self, preds, img, orig_imgs):
        """Post-processes predictions and returns a list of Results objects."""
        # if isinstance(preds, (list, tuple)):  # YOLOv8 model in validation model, output = (inference_out, loss_out)
        #     preds = preds[0]
        # cls_max = torch.max(preds[:, 4:8, :], dim=1, keepdim=True).values
        # idx = (cls_max > self.args.conf)
        # preds[:, -1:, :][idx] = 0

        # preds = ops.non_max_suppression(
        #     preds,
        #     self.args.conf,
        #     self.args.iou,
        #     agnostic=self.args.agnostic_nms,
        #     max_det=self.args.max_det,
        #     classes=self.args.classes,
        # )

        if isinstance(preds, (list, tuple)):  # YOLOv8 model in validation model, output = (inference_out, loss_out)
            preds = preds[0]
            preds_c = preds.clone()

        nms_cls = ops.non_max_suppression(
            preds[:, :8, :],
            self.args.conf,
            self.args.iou,
            agnostic=self.args.agnostic_nms,
            max_det=self.args.max_det,
            classes=self.args.classes,
        )

        nms_obj = ops.non_max_suppression(
            torch.cat((preds_c[:, :4, :], preds_c[:, -1:, :]), dim=1),
            self.args.conf,
            self.args.iou,
            agnostic=self.args.agnostic_nms,
            max_det=self.args.max_det,
            classes=self.args.classes,
        )

        preds = [n.clone() for n in nms_cls]
        for i in range(len(nms_cls)):
            nms_obj[i][:, 5] = len(self.model.names) - 1
            if nms_obj[i].size(0) == 0:  # Skip if there are no objects
                continue
            if nms_cls[i].size(0) == 0:
                preds[i] = nms_obj[i]
                continue
            iou = self.box_iou(nms_cls[i][:, :4], nms_obj[i][:, :4])
            idxs = []
            # 将多分类置信度低、二分类置信度高，且IOU较大的框替换
            matchs = torch.ones_like(iou)
            matchs[nms_cls[i][:, 4] > 0.3, :] = 0  # new_track_thresh
            matchs[:, nms_obj[i][:, 4] < 0.3] = 0
            matchs[iou < self.args.iou] = 0
            rows, cols = torch.where(matchs == 1)
            preds[i][rows, :] = nms_obj[i][cols, :]
            idxs.append(cols)

            # 将二分类无对应多分类结果的框附后
            max_values = torch.max(iou, dim=0)[0]
            idxs = torch.where(max_values < self.args.iou)[0]
            idxs = torch.tensor([i for i in idxs if i not in cols]).to(torch.int64)
            preds[i] = torch.cat((preds[i], nms_obj[i][idxs, :]), dim=0)

            # for m in range(len(nms_obj[i])):
            #     if (torch.max(iou[:, m]) < self.args.iou) and (m not in idxs):
            #         preds[i] = torch.cat((preds[i], nms_obj[i][m, :]), dim=0)

        if not isinstance(orig_imgs, list):  # input images are a torch.Tensor, not a list
            orig_imgs = ops.convert_torch2numpy_batch(orig_imgs)

        results = []
        for i, pred in enumerate(preds):
            orig_img = orig_imgs[i]
            pred[:, :4] = ops.scale_boxes(img.shape[2:], pred[:, :4], orig_img.shape)
            img_path = self.batch[0][i]
            results.append(Results(orig_img, path=img_path, names=self.model.names, boxes=pred))
        return results
    
    def box_iou(self, box1, box2, eps=1e-7):
        """
        Calculate intersection-over-union (IoU) of boxes. Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
        Based on https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py

        Args:
            box1 (torch.Tensor): A tensor of shape (N, 4) representing N bounding boxes.
            box2 (torch.Tensor): A tensor of shape (M, 4) representing M bounding boxes.
            eps (float, optional): A small value to avoid division by zero. Defaults to 1e-7.

        Returns:
            (torch.Tensor): An NxM tensor containing the pairwise IoU values for every element in box1 and box2.
        """

        # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)
        (a1, a2), (b1, b2) = box1.unsqueeze(1).chunk(2, 2), box2.unsqueeze(0).chunk(2, 2)
        inter = (torch.min(a2, b2) - torch.max(a1, b1)).clamp_(0).prod(2)

        # IoU = inter / (area1 + area2 - inter)
        return inter / ((a2 - a1).prod(2) + (b2 - b1).prod(2) - inter + eps)