Reference for ultralytics/models/yolo/obb/val.py

def eval_json(self, stats):
    """Evaluate YOLO output in JSON format and save predictions in DOTA format."""
    if self.args.save_json and self.is_dota and len(self.jdict):
        import json
        import re
        from collections import defaultdict

        pred_json = self.save_dir / "predictions.json"  # predictions
        pred_txt = self.save_dir / "predictions_txt"  # predictions
        pred_txt.mkdir(parents=True, exist_ok=True)
        data = json.load(open(pred_json))
        # Save split results
        LOGGER.info(f"Saving predictions with DOTA format to {pred_txt}...")
        for d in data:
            image_id = d["image_id"]
            score = d["score"]
            classname = self.names[d["category_id"] - 1].replace(" ", "-")
            p = d["poly"]

            with open(f"{pred_txt / f'Task1_{classname}'}.txt", "a", encoding="utf-8") as f:
                f.writelines(f"{image_id} {score} {p[0]} {p[1]} {p[2]} {p[3]} {p[4]} {p[5]} {p[6]} {p[7]}\n")
        # Save merged results, this could result slightly lower map than using official merging script,
        # because of the probiou calculation.
        pred_merged_txt = self.save_dir / "predictions_merged_txt"  # predictions
        pred_merged_txt.mkdir(parents=True, exist_ok=True)
        merged_results = defaultdict(list)
        LOGGER.info(f"Saving merged predictions with DOTA format to {pred_merged_txt}...")
        for d in data:
            image_id = d["image_id"].split("__")[0]
            pattern = re.compile(r"\d+___\d+")
            x, y = (int(c) for c in re.findall(pattern, d["image_id"])[0].split("___"))
            bbox, score, cls = d["rbox"], d["score"], d["category_id"] - 1
            bbox[0] += x
            bbox[1] += y
            bbox.extend([score, cls])
            merged_results[image_id].append(bbox)
        for image_id, bbox in merged_results.items():
            bbox = torch.tensor(bbox)
            max_wh = torch.max(bbox[:, :2]).item() * 2
            c = bbox[:, 6:7] * max_wh  # classes
            scores = bbox[:, 5]  # scores
            b = bbox[:, :5].clone()
            b[:, :2] += c
            # 0.3 could get results close to the ones from official merging script, even slightly better.
            i = ops.nms_rotated(b, scores, 0.3)
            bbox = bbox[i]

            b = ops.xywhr2xyxyxyxy(bbox[:, :5]).view(-1, 8)
            for x in torch.cat([b, bbox[:, 5:7]], dim=-1).tolist():
                classname = self.names[int(x[-1])].replace(" ", "-")
                p = [round(i, 3) for i in x[:-2]]  # poly
                score = round(x[-2], 3)

                with open(f"{pred_merged_txt / f'Task1_{classname}'}.txt", "a", encoding="utf-8") as f:
                    f.writelines(f"{image_id} {score} {p[0]} {p[1]} {p[2]} {p[3]} {p[4]} {p[5]} {p[6]} {p[7]}\n")

    return stats

def init_metrics(self, model):
    """Initialize evaluation metrics for YOLO."""
    super().init_metrics(model)
    val = self.data.get(self.args.split, "")  # validation path
    self.is_dota = isinstance(val, str) and "DOTA" in val  # check if dataset is DOTA format

def plot_predictions(self, batch, preds, ni):
    """
    Plot predicted bounding boxes on input images and save the result.

    Args:
        batch (dict): Batch data containing images, file paths, and other metadata.
        preds (list): List of prediction tensors for each image in the batch.
        ni (int): Batch index used for naming the output file.

    Examples:
        >>> validator = OBBValidator()
        >>> batch = {"img": images, "im_file": paths}
        >>> preds = [torch.rand(10, 7)]  # Example predictions for one image
        >>> validator.plot_predictions(batch, preds, 0)
    """
    plot_images(
        batch["img"],
        *output_to_rotated_target(preds, max_det=self.args.max_det),
        paths=batch["im_file"],
        fname=self.save_dir / f"val_batch{ni}_pred.jpg",
        names=self.names,
        on_plot=self.on_plot,
    )  # pred

def pred_to_json(self, predn, filename):
    """
    Convert YOLO predictions to COCO JSON format with rotated bounding box information.

    Args:
        predn (torch.Tensor): Prediction tensor containing bounding box coordinates, confidence scores,
            class predictions, and rotation angles with shape (N, 6+) where the last column is the angle.
        filename (str | Path): Path to the image file for which predictions are being processed.

    Notes:
        This method processes rotated bounding box predictions and converts them to both rbox format
        (x, y, w, h, angle) and polygon format (x1, y1, x2, y2, x3, y3, x4, y4) before adding them
        to the JSON dictionary.
    """
    stem = Path(filename).stem
    image_id = int(stem) if stem.isnumeric() else stem
    rbox = torch.cat([predn[:, :4], predn[:, -1:]], dim=-1)
    poly = ops.xywhr2xyxyxyxy(rbox).view(-1, 8)
    for i, (r, b) in enumerate(zip(rbox.tolist(), poly.tolist())):
        self.jdict.append(
            {
                "image_id": image_id,
                "category_id": self.class_map[int(predn[i, 5].item())],
                "score": round(predn[i, 4].item(), 5),
                "rbox": [round(x, 3) for x in r],
                "poly": [round(x, 3) for x in b],
            }
        )

def save_one_txt(self, predn, save_conf, shape, file):
    """
    Save YOLO OBB (Oriented Bounding Box) detections to a text file in normalized coordinates.

    Args:
        predn (torch.Tensor): Predicted detections with shape (N, 7) containing bounding boxes, confidence scores,
            class predictions, and angles in format (x, y, w, h, conf, cls, angle).
        save_conf (bool): Whether to save confidence scores in the text file.
        shape (tuple): Original image shape in format (height, width).
        file (Path | str): Output file path to save detections.

    Examples:
        >>> validator = OBBValidator()
        >>> predn = torch.tensor([[100, 100, 50, 30, 0.9, 0, 45]])  # One detection: x,y,w,h,conf,cls,angle
        >>> validator.save_one_txt(predn, True, (640, 480), "detection.txt")
    """
    import numpy as np

    from ultralytics.engine.results import Results

    rboxes = torch.cat([predn[:, :4], predn[:, -1:]], dim=-1)
    # xywh, r, conf, cls
    obb = torch.cat([rboxes, predn[:, 4:6]], dim=-1)
    Results(
        np.zeros((shape[0], shape[1]), dtype=np.uint8),
        path=None,
        names=self.names,
        obb=obb,
    ).save_txt(file, save_conf=save_conf)