Upload 12 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+boats.jpg filter=lfs diff=lfs merge=lfs -text
+result_yolo26_obb.jpg filter=lfs diff=lfs merge=lfs -text

ax_infer.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+# =============================================================================
+# YOLO26-OBB Inference Script (AXERARuntime)
+#
+# Copyright (c) 2025, AXERA Semiconductor Co., Ltd. All rights reserved.
+#
+# Licensed under the BSD 3-Clause License (the "License"); you may not use
+# this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://opensource.org/licenses/BSD-3-Clause
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+# =============================================================================
+#
+# Author: GUOFANGMING
+#
+
+import os
+import cv2
+import numpy as np
+from time import time
+import argparse
+import logging
+import axengine as ort
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='[%(name)s] [%(asctime)s.%(msecs)03d] [%(levelname)s] %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger("YOLO26-OBB")
+
+
+# DOTAv1 class names (15 classes)
+DOTA_CLASSES = [
+    "plane", "ship", "storage tank", "baseball diamond", "tennis court",
+    "basketball court", "ground track field", "harbor", "bridge",
+    "large vehicle", "small vehicle", "helicopter", "roundabout",
+    "soccer ball field", "swimming pool"
+]
+
+DOTA_COLORS = [
+    (255, 56, 56),   (255, 159, 56),  (255, 207, 56),  (180, 255, 56),
+    (102, 255, 56),  (56, 255, 122),  (56, 255, 207),  (56, 207, 255),
+    (56, 122, 255),  (102, 56, 255),  (180, 56, 255),  (255, 56, 207),
+    (255, 56, 122),  (200, 200, 200), (128, 128, 255),
+]
+
+
+def infer_hw_layout(shape):
+    """Infer input height, width and layout from model input shape."""
+    shape = list(shape)
+    if len(shape) == 4 and shape[-1] == 3:
+        h = int(shape[1] or 1024)
+        w = int(shape[2] or 1024)
+        return h, w, "NHWC"
+    if len(shape) == 4 and shape[1] == 3:
+        h = int(shape[2] or 1024)
+        w = int(shape[3] or 1024)
+        return h, w, "NCHW"
+    return 1024, 1024, "NCHW"
+
+
+def softmax(x, axis=-1):
+    e_x = np.exp(x - np.max(x, axis=axis, keepdims=True))
+    return e_x / np.sum(e_x, axis=axis, keepdims=True)
+
+
+def dfl_decode(box_pred, reg_max):
+    N = box_pred.shape[0]
+    box_pred = box_pred.reshape(N, 4, reg_max)
+    box_pred = softmax(box_pred, axis=-1)
+    proj = np.arange(reg_max, dtype=np.float32)
+    return np.sum(box_pred * proj, axis=-1)
+
+
+def decode_obb(box_preds, angle_preds, anchors, stride, reg_max=None):
+    """Decode oriented boxes (cx, cy, w, h, theta) in pixel space."""
+    if reg_max is not None and box_preds.shape[-1] == 4 * reg_max and reg_max > 1:
+        box_preds = dfl_decode(box_preds, reg_max)
+
+    angle = angle_preds.reshape(-1)
+    cos_a = np.cos(angle)
+    sin_a = np.sin(angle)
+
+    lt = box_preds[:, :2]
+    rb = box_preds[:, 2:]
+    xf = (rb[:, 0] - lt[:, 0]) * 0.5
+    yf = (rb[:, 1] - lt[:, 1]) * 0.5
+
+    cx = xf * cos_a - yf * sin_a + anchors[:, 0]
+    cy = xf * sin_a + yf * cos_a + anchors[:, 1]
+    w = lt[:, 0] + rb[:, 0]
+    h = lt[:, 1] + rb[:, 1]
+    return np.stack([cx * stride, cy * stride, w * stride, h * stride, angle], axis=1)
+
+
+def regularize_rbox(rboxes):
+    """Ensure w >= h, theta in [0, pi)."""
+    rboxes = rboxes.copy()
+    swap = rboxes[:, 2] < rboxes[:, 3]
+    if np.any(swap):
+        w_old = rboxes[swap, 2].copy()
+        rboxes[swap, 2] = rboxes[swap, 3]
+        rboxes[swap, 3] = w_old
+        rboxes[swap, 4] = rboxes[swap, 4] + np.pi / 2.0
+    rboxes[:, 4] = np.mod(rboxes[:, 4], np.pi)
+    return rboxes
+
+
+def scale_rboxes_lefttop(rboxes, scale, orig_shape):
+    rboxes = rboxes.copy()
+    rboxes[:, :4] /= scale
+    rboxes[:, 0] = np.clip(rboxes[:, 0], 0, orig_shape[1])
+    rboxes[:, 1] = np.clip(rboxes[:, 1], 0, orig_shape[0])
+    return rboxes
+
+
+def rbox_to_corners(rbox):
+    cx, cy, w, h, ag = rbox
+    cos_a, sin_a = np.cos(ag), np.sin(ag)
+    wx, wy = w / 2 * cos_a, w / 2 * sin_a
+    hx, hy = -h / 2 * sin_a, h / 2 * cos_a
+    return np.array([
+        [cx - wx - hx, cy - wy - hy],
+        [cx + wx - hx, cy + wy - hy],
+        [cx + wx + hx, cy + wy + hy],
+        [cx - wx + hx, cy - wy + hy],
+    ], dtype=np.float32)
+
+
+def main():
+    ap = argparse.ArgumentParser(description='YOLO26-OBB Inference (AXERARuntime)')
+    ap.add_argument('--model-path', type=str, default='yolo26n-obb_1024x1024.axmodel')
+    ap.add_argument('--test-img', type=str, default='boats.jpg')
+    ap.add_argument('--img-save-path', type=str, default='result_yolo26_obb.jpg')
+    ap.add_argument('--score-thres', type=float, default=0.25)
+    ap.add_argument('--nms-thres', type=float, default=0.45)
+    ap.add_argument('--num-classes', type=int, default=15)
+    ap.add_argument('--providers', type=str, default='AxEngineExecutionProvider')
+    opt = ap.parse_args()
+
+    if not os.path.exists(opt.model_path):
+        logger.error(f"Model not found: {opt.model_path}")
+        return
+
+    t0 = time()
+    providers = [p.strip() for p in opt.providers.split(",") if p.strip()] or None
+    sess = ort.InferenceSession(opt.model_path, providers=providers)
+    logger.debug(f"\033[1;31mLoad model time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    inp = sess.get_inputs()[0]
+    input_name = inp.name
+    m_h, m_w, layout = infer_hw_layout(inp.shape)
+
+    img = cv2.imread(opt.test_img)
+    if img is None:
+        logger.error(f"Image not found or unreadable: {opt.test_img}")
+        return
+
+    # Preprocess (left-top letterbox, gray padding)
+    t0 = time()
+    orig_h, orig_w = img.shape[:2]
+    scale = min(m_h / orig_h, m_w / orig_w)
+    new_w, new_h = int(orig_w * scale), int(orig_h * scale)
+    resized = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+    padded = cv2.copyMakeBorder(
+        resized, 0, m_h - new_h, 0, m_w - new_w,
+        cv2.BORDER_CONSTANT, value=(127, 127, 127)
+    )
+    rgb = cv2.cvtColor(padded, cv2.COLOR_BGR2RGB)
+    if layout == "NHWC":
+        input_tensor = rgb[None, ...].astype(np.uint8)
+    else:
+        input_tensor = np.transpose(rgb, (2, 0, 1))[None, ...].astype(np.uint8)
+    logger.debug(f"\033[1;31mPre-process time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    # Inference
+    t0 = time()
+    ort_outputs = sess.run(None, {input_name: input_tensor})
+    out_metas = sess.get_outputs()
+    logger.debug(f"\033[1;31mForward time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    # Post-process
+    t0 = time()
+    strides = (8, 16, 32)
+    conf_raw = -np.log(1 / opt.score_thres - 1)
+    detections = []  # [cx, cy, w, h, theta, conf, cls_id]
+
+    output_items = []
+    for meta, data in zip(out_metas, ort_outputs):
+        shape = list(meta.shape)
+        if any(s is None or isinstance(s, str) for s in shape):
+            shape = list(data.shape)
+        output_items.append((data, shape))
+
+    for scale_idx, stride in enumerate(strides):
+        box_idx = scale_idx * 3
+        cls_idx = scale_idx * 3 + 1
+        ang_idx = scale_idx * 3 + 2
+        if ang_idx >= len(output_items):
+            continue
+
+        box_data, box_shape = output_items[box_idx]
+        cls_data, cls_shape = output_items[cls_idx]
+        ang_data, ang_shape = output_items[ang_idx]
+
+        H, W = box_shape[1], box_shape[2]
+        box_channels = box_shape[-1]
+        reg_max = None
+        if box_channels > 4 and box_channels % 4 == 0:
+            reg_max = box_channels // 4
+
+        box_data = box_data[0].reshape(-1, box_channels)
+        cls_data = cls_data[0].reshape(-1, cls_shape[-1])
+        ang_data = ang_data[0].reshape(-1, ang_shape[-1])
+
+        if cls_data.shape[-1] == 1:
+            cls_scores = cls_data[:, 0]
+            cls_ids = np.zeros(len(cls_scores), dtype=np.int32)
+        else:
+            cls_scores = np.max(cls_data, axis=1)
+            cls_ids = np.argmax(cls_data, axis=1)
+
+        valid = cls_scores >= conf_raw
+        if not np.any(valid):
+            continue
+
+        v_box = box_data[valid]
+        v_ang = ang_data[valid]
+        v_score = 1.0 / (1.0 + np.exp(-cls_scores[valid]))
+        v_id = cls_ids[valid]
+
+        gy, gx = np.indices((H, W))
+        anchors = np.stack((gx.ravel(), gy.ravel()), axis=-1).astype(np.float32) + 0.5
+        anchors = anchors[valid]
+
+        rboxes = decode_obb(v_box, v_ang, anchors, stride, reg_max)
+        rboxes = regularize_rbox(rboxes)
+        for i in range(len(rboxes)):
+            detections.append([*rboxes[i], v_score[i], int(v_id[i])])
+
+    logger.debug(f"\033[1;31mPost-process time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    if len(detections) == 0:
+        logger.info("No detections found.")
+        cv2.imwrite(opt.img_save_path, img)
+        return
+
+    detections = np.array(detections, dtype=np.float32)
+
+    # Rotated NMS
+    rotated_boxes = []
+    for det in detections:
+        cx, cy, w, h, theta = det[:5]
+        rotated_boxes.append(((float(cx), float(cy)), (float(w), float(h)), float(np.degrees(theta))))
+    scores = detections[:, 5].tolist()
+    keep = cv2.dnn.NMSBoxesRotated(rotated_boxes, scores, opt.score_thres, opt.nms_thres)
+    if len(keep) == 0:
+        logger.info("No detections after NMS.")
+        cv2.imwrite(opt.img_save_path, img)
+        return
+
+    keep = np.array(keep).flatten()
+    final = detections[keep]
+    final[:, :5] = scale_rboxes_lefttop(final[:, :5], scale, (orig_h, orig_w))
+
+    logger.info(f"\033[1;32mDraw Results ({len(final)} oriented objects):\033[0m")
+    for det in final:
+        cx, cy, w, h, theta, conf, cid = det
+        cid = int(cid)
+        name = DOTA_CLASSES[cid] if cid < len(DOTA_CLASSES) else f"cls{cid}"
+        color = DOTA_COLORS[cid % len(DOTA_COLORS)]
+        logger.info(f"  {name:20s} conf={conf:.2f} cx={cx:.1f} cy={cy:.1f} w={w:.1f} h={h:.1f} theta={np.degrees(theta):+.1f}deg")
+        corners = rbox_to_corners(det[:5]).astype(np.int32)
+        cv2.polylines(img, [corners], isClosed=True, color=color, thickness=2, lineType=cv2.LINE_AA)
+        label = f"{name} {conf:.2f}"
+        (tw, th), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+        x_text, y_text = int(corners[0][0]), max(0, int(corners[0][1]) - 5)
+        cv2.rectangle(img, (x_text, y_text - th - 2), (x_text + tw + 2, y_text + 2), color, -1)
+        cv2.putText(img, label, (x_text + 1, y_text - 1),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)
+
+    cv2.imwrite(opt.img_save_path, img)
+    logger.info(f"Saved to {opt.img_save_path}")
+
+
+if __name__ == "__main__":
+    main()

config.json

@@ -0,0 +1,32 @@
+{
+  "model_type": "ONNX",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "images",
+        "calibration_dataset": "../dota_cali.tar",
+        "calibration_size": 15,
+        "calibration_mean": [0, 0, 0],
+        "calibration_std": [255.0, 255.0, 255.0]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "precision_analysis_method":"EndToEnd"
+  },
+  "input_processors": [
+    {
+      "tensor_name": "images",
+      "tensor_format": "BGR",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NHWC"
+    }
+  ],
+  "output_processors": [
+  ],
+  "compiler": {
+    "check": 0
+  }
+}

dota_cali.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af11ce2d4668a0e0cc08fa42968ab0d1a1fb0cbf57ac8109597853de104d31ff
+size 2621440

export_onnx.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+# =============================================================================
+# YOLO26-OBB Export ONNX Model Script
+#
+# Copyright (c) 2025, AXERA Semiconductor Co., Ltd. All rights reserved.
+#
+# Licensed under the BSD 3-Clause License (the "License"); you may not use
+# this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://opensource.org/licenses/BSD-3-Clause
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+# =============================================================================
+#
+# Author: GUOFANGMING
+#
+
+import torch
+from ultralytics import YOLO
+from ultralytics.nn.modules.head import OBB26
+import os
+import shutil
+
+
+def npu_obb26_forward(self, x):
+    """
+    YOLO26 OBB26 Head Modified for NPU.
+
+    OBB26 structure:
+        - cv2 / one2one_cv2: box regression layers (output 4*reg_max channels, reg_max=1 -> 4)
+        - cv3 / one2one_cv3: classification layers (output nc channels, nc=15 for DOTAv1)
+        - cv4 / one2one_cv4: angle regression layers (output ne channels, ne=1)
+
+    Note:
+        OBB26 outputs raw angle predictions (in radians) without sigmoid transformation,
+        which is different from the original OBB head where the angle is wrapped via
+        ``(angle.sigmoid() - 0.25) * pi`` in ``forward_head``. The post-process therefore
+        consumes the raw angle directly via ``cos(angle)`` / ``sin(angle)``.
+
+    Output:
+        List of Tensors (9 items: 3 scales * 3 outputs), Layout: NHWC for all branches.
+        For each scale:
+          - Box_Raw   (B, H, W, 4*reg_max),  <-- bbox regression (ltrb distance, reg_max=1)
+          - Cls_Raw   (B, H, W, nc),         <-- class scores (raw logits)
+          - Angle_Raw (B, H, W, ne),         <-- rotation angle (raw radians, ne=1)
+    """
+    if not isinstance(x, (list, tuple)):
+        x = [x]
+
+    res = []
+
+    # Box / Cls use one2one branch (end2end mode) when available
+    if hasattr(self, 'one2one_cv2') and hasattr(self, 'one2one_cv3'):
+        box_layers = self.one2one_cv2
+        cls_layers = self.one2one_cv3
+    else:
+        box_layers = self.cv2
+        cls_layers = self.cv3
+
+    # Angle uses one2one_cv4 in end2end mode
+    if hasattr(self, 'one2one_cv4'):
+        angle_layers = self.one2one_cv4
+    else:
+        angle_layers = self.cv4
+
+    for i in range(self.nl):
+        # 1. Box branch - NHWC (4 * reg_max channels, reg_max=1 -> 4)
+        bboxes = box_layers[i](x[i]).permute(0, 2, 3, 1)
+
+        # 2. Cls branch - NHWC (nc channels, raw logits)
+        scores = cls_layers[i](x[i]).permute(0, 2, 3, 1)
+
+        # 3. Angle branch - NHWC (ne channels, raw radians)
+        angle = angle_layers[i](x[i]).permute(0, 2, 3, 1)
+
+        res.append(bboxes)
+        res.append(scores)
+        res.append(angle)
+
+    return res
+
+
+def batch_export_yolo26_obb():
+    variants = ['n', 's', 'm', 'l', 'x']
+    imgsz = 1024  # YOLO26-OBB officially uses 1024x1024 (DOTAv1 pretrained)
+
+    # Execute Monkey Patch
+    OBB26.forward = npu_obb26_forward
+    print("Monkey patch applied for OBB26: Output Layout forced to NHWC (Box, Cls, Angle for each scale).")
+
+    for v in variants:
+        model_name = f"yolo26{v}-obb"
+        pt_path = f"{model_name}.pt"
+        onnx_final_name = f"{model_name}_{imgsz}x{imgsz}.onnx"
+        print(f"\n--- Processing {model_name} ---")
+        try:
+            # Load model
+            model = YOLO(pt_path)
+
+            # Reapply monkey patch
+            OBB26.forward = npu_obb26_forward
+
+            # Ensure the model's head also uses the new forward
+            if hasattr(model.model, 'model') and len(model.model.model) > 0:
+                head = model.model.model[-1]
+                if isinstance(head, OBB26):
+                    head.forward = lambda x: npu_obb26_forward(head, x)
+
+            # Execute export
+            exported_path = model.export(
+                format="onnx",
+                imgsz=imgsz,
+                dynamic=False,
+                opset=11,
+                simplify=True,
+                nms=False
+            )
+
+            # Move and rename
+            if exported_path:
+                shutil.move(exported_path, onnx_final_name)
+                print(f"Success: {onnx_final_name}")
+        except Exception as e:
+            print(f"Failed to export {model_name}: {e}")
+            import traceback
+            traceback.print_exc()
+
+
+if __name__ == "__main__":
+    batch_export_yolo26_obb()

onnx_infer.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+# =============================================================================
+# YOLO26-OBB Inference Script (ONNXRuntime)
+#
+# Copyright (c) 2025, AXERA Semiconductor Co., Ltd. All rights reserved.
+#
+# Licensed under the BSD 3-Clause License (the "License"); you may not use
+# this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# https://opensource.org/licenses/BSD-3-Clause
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+# =============================================================================
+#
+# Author: GUOFANGMING
+#
+
+import onnxruntime as ort
+import cv2
+import numpy as np
+import argparse
+import os
+
+
+# DOTAv1 class names (15 classes), order matches Ultralytics DOTAv1.yaml
+DOTA_CLASSES = [
+    "plane", "ship", "storage tank", "baseball diamond", "tennis court",
+    "basketball court", "ground track field", "harbor", "bridge",
+    "large vehicle", "small vehicle", "helicopter", "roundabout",
+    "soccer ball field", "swimming pool"
+]
+
+# Distinct BGR colors for the 15 DOTA categories
+DOTA_COLORS = [
+    (255, 56, 56),   (255, 159, 56),  (255, 207, 56),  (180, 255, 56),
+    (102, 255, 56),  (56, 255, 122),  (56, 255, 207),  (56, 207, 255),
+    (56, 122, 255),  (102, 56, 255),  (180, 56, 255),  (255, 56, 207),
+    (255, 56, 122),  (200, 200, 200), (128, 128, 255),
+]
+
+
+def preprocess_image(image, input_size=(1024, 1024)):
+    """Letterbox preprocess (left-top aligned).
+
+    Args:
+        image: BGR image (H, W, C)
+        input_size: (height, width) target size (default 1024x1024 for OBB)
+
+    Returns:
+        input_tensor: (1, 3, H, W) float32 normalized to [0, 1]
+        scale: scalar resize ratio
+        original_shape: (orig_h, orig_w)
+    """
+    orig_h, orig_w = image.shape[:2]
+    m_h, m_w = input_size
+    scale = min(m_h / orig_h, m_w / orig_w)
+    new_w, new_h = int(orig_w * scale), int(orig_h * scale)
+    img_resized = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+    input_bgr = cv2.copyMakeBorder(
+        img_resized, 0, m_h - new_h, 0, m_w - new_w,
+        cv2.BORDER_CONSTANT, value=(114, 114, 114)
+    )
+    input_rgb = cv2.cvtColor(input_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    input_tensor = np.transpose(input_rgb, (2, 0, 1))[None, ...]
+    return input_tensor, scale, (orig_h, orig_w)
+
+
+def softmax(x, axis=-1):
+    e_x = np.exp(x - np.max(x, axis=axis, keepdims=True))
+    return e_x / np.sum(e_x, axis=axis, keepdims=True)
+
+
+def dfl_decode(box_pred, reg_max):
+    """Decode DFL box predictions of shape (N, 4*reg_max) -> (N, 4)."""
+    N = box_pred.shape[0]
+    box_pred = box_pred.reshape(N, 4, reg_max)
+    box_pred = softmax(box_pred, axis=-1)
+    proj = np.arange(reg_max, dtype=np.float32)
+    return np.sum(box_pred * proj, axis=-1)
+
+
+def decode_obb(box_preds, angle_preds, anchors, stride, reg_max=None):
+    """Decode oriented bounding boxes from predictions.
+
+    Mirrors ``ultralytics.utils.tal.dist2rbox``:
+        lt, rb = box[:2], box[2:]
+        cos, sin = cos(angle), sin(angle)
+        xf, yf = (rb - lt) / 2
+        x = xf*cos - yf*sin + anchor_x
+        y = xf*sin + yf*cos + anchor_y
+        w = l + r,  h = t + b
+        (xy, wh) are in feature units, then multiplied by stride to get pixels.
+
+    Args:
+        box_preds: (N, 4) or (N, 4*reg_max) raw ltrb distances (in feature units).
+        angle_preds: (N, 1) or (N,) raw angle in radians (no sigmoid applied).
+        anchors: (N, 2) - feature-space anchor centers (gx+0.5, gy+0.5).
+        stride: scalar stride for the current scale.
+        reg_max: if not None, apply DFL to box_preds first.
+
+    Returns:
+        rboxes: (N, 5) array in [cx, cy, w, h, theta] format (pixel units, theta in radians).
+    """
+    if reg_max is not None and box_preds.shape[-1] == 4 * reg_max and reg_max > 1:
+        box_preds = dfl_decode(box_preds, reg_max)
+
+    angle = angle_preds.reshape(-1)  # raw radians
+    cos_a = np.cos(angle)
+    sin_a = np.sin(angle)
+
+    lt = box_preds[:, :2]
+    rb = box_preds[:, 2:]
+    xf = (rb[:, 0] - lt[:, 0]) * 0.5
+    yf = (rb[:, 1] - lt[:, 1]) * 0.5
+
+    cx = xf * cos_a - yf * sin_a + anchors[:, 0]
+    cy = xf * sin_a + yf * cos_a + anchors[:, 1]
+    w = lt[:, 0] + rb[:, 0]
+    h = lt[:, 1] + rb[:, 1]
+
+    rboxes = np.stack([cx * stride, cy * stride, w * stride, h * stride, angle], axis=1)
+    return rboxes
+
+
+def regularize_rbox(rboxes):
+    """Regularize rotated boxes: ensure w >= h and angle in [0, pi).
+
+    Matches Ultralytics' OBB convention: longer side is treated as width and
+    rotation is mapped into [0, pi). This makes IoU comparisons consistent.
+    """
+    rboxes = rboxes.copy()
+    swap = rboxes[:, 2] < rboxes[:, 3]
+    if np.any(swap):
+        w_old = rboxes[swap, 2].copy()
+        rboxes[swap, 2] = rboxes[swap, 3]
+        rboxes[swap, 3] = w_old
+        rboxes[swap, 4] = rboxes[swap, 4] + np.pi / 2.0
+    rboxes[:, 4] = np.mod(rboxes[:, 4], np.pi)
+    return rboxes
+
+
+def scale_rboxes_lefttop(rboxes, scale, orig_shape):
+    """Scale rotated boxes from network input back to original image."""
+    rboxes = rboxes.copy()
+    rboxes[:, :4] /= scale
+    rboxes[:, 0] = np.clip(rboxes[:, 0], 0, orig_shape[1])
+    rboxes[:, 1] = np.clip(rboxes[:, 1], 0, orig_shape[0])
+    return rboxes
+
+
+def rbox_to_corners(rbox):
+    """Convert (cx, cy, w, h, theta) to 4 corner points (x, y) in image space."""
+    cx, cy, w, h, ag = rbox
+    cos_a, sin_a = np.cos(ag), np.sin(ag)
+    wx, wy = w / 2 * cos_a, w / 2 * sin_a
+    hx, hy = -h / 2 * sin_a, h / 2 * cos_a
+    p1 = (cx - wx - hx, cy - wy - hy)
+    p2 = (cx + wx - hx, cy + wy - hy)
+    p3 = (cx + wx + hx, cy + wy + hy)
+    p4 = (cx - wx + hx, cy - wy + hy)
+    return np.array([p1, p2, p3, p4], dtype=np.float32)
+
+
+def main():
+    parser = argparse.ArgumentParser(description='YOLO26-OBB ONNX Inference')
+    parser.add_argument('-m', '--model', type=str, default='yolo26n-obb_1024x1024.onnx',
+                        dest='model_path', help='Path to YOLO26-OBB *.onnx Model.')
+    parser.add_argument('-i', '--img', type=str, default='boats.jpg',
+                        dest='test_img', help='Path to Test Image.')
+    parser.add_argument('-o', '--output', type=str, default='result_yolo26_obb.jpg',
+                        dest='img_save_path', help='Path to Save Result Image.')
+    parser.add_argument('--score-thres', type=float, default=0.25,
+                        help='Confidence threshold.')
+    parser.add_argument('--nms-thres', type=float, default=0.45,
+                        help='IoU threshold for rotated NMS.')
+    parser.add_argument('--num-classes', type=int, default=15,
+                        help='Number of classes (DOTAv1: 15).')
+    opt = parser.parse_args()
+
+    if not os.path.exists(opt.model_path):
+        print(f"Error: Model not found: {opt.model_path}")
+        return
+    if not os.path.exists(opt.test_img):
+        print(f"Error: Image not found: {opt.test_img}")
+        return
+
+    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+    try:
+        session = ort.InferenceSession(opt.model_path, providers=providers)
+    except Exception:
+        session = ort.InferenceSession(opt.model_path, providers=['CPUExecutionProvider'])
+
+    input_name = session.get_inputs()[0].name
+    output_names = [o.name for o in session.get_outputs()]
+    input_shape = session.get_inputs()[0].shape
+    imgsz = (int(input_shape[2]), int(input_shape[3]))
+
+    img0 = cv2.imread(opt.test_img)
+    if img0 is None:
+        print(f"Error: Cannot read image: {opt.test_img}")
+        return
+
+    img, scale, orig_shape = preprocess_image(img0.copy(), imgsz)
+
+    outputs = session.run(output_names, {input_name: img})
+
+    # Post-process: 9 outputs (3 scales * (box, cls, angle))
+    strides = [8, 16, 32]
+    conf_raw = -np.log(1 / opt.score_thres - 1)
+    detections = []  # each: [cx, cy, w, h, theta, conf, cls_id]
+
+    for scale_idx, stride in enumerate(strides):
+        box_idx = scale_idx * 3
+        cls_idx = scale_idx * 3 + 1
+        ang_idx = scale_idx * 3 + 2
+        if ang_idx >= len(outputs):
+            continue
+
+        box_data = outputs[box_idx]    # (1, H, W, 4*reg_max)
+        cls_data = outputs[cls_idx]    # (1, H, W, nc)
+        ang_data = outputs[ang_idx]    # (1, H, W, 1)
+
+        H, W = box_data.shape[1:3]
+        box_channels = box_data.shape[-1]
+        reg_max = None
+        if box_channels > 4 and box_channels % 4 == 0:
+            reg_max = box_channels // 4
+
+        box_data = box_data[0].reshape(-1, box_channels)
+        cls_data = cls_data[0].reshape(-1, cls_data.shape[-1])
+        ang_data = ang_data[0].reshape(-1, ang_data.shape[-1])
+
+        if cls_data.shape[-1] == 1:
+            cls_scores = cls_data[:, 0]
+            cls_ids = np.zeros(len(cls_scores), dtype=np.int32)
+        else:
+            cls_scores = np.max(cls_data, axis=1)
+            cls_ids = np.argmax(cls_data, axis=1)
+
+        valid = cls_scores >= conf_raw
+        if not np.any(valid):
+            continue
+
+        v_box = box_data[valid]
+        v_ang = ang_data[valid]
+        v_score = 1.0 / (1.0 + np.exp(-cls_scores[valid]))
+        v_id = cls_ids[valid]
+
+        gy, gx = np.indices((H, W))
+        anchors = np.stack((gx.ravel(), gy.ravel()), axis=-1).astype(np.float32) + 0.5
+        anchors = anchors[valid]
+
+        rboxes = decode_obb(v_box, v_ang, anchors, stride, reg_max)
+        rboxes = regularize_rbox(rboxes)
+
+        for i in range(len(rboxes)):
+            detections.append([*rboxes[i], v_score[i], int(v_id[i])])
+
+    if len(detections) == 0:
+        print("No detections found.")
+        cv2.imwrite(opt.img_save_path, img0)
+        return
+
+    detections = np.array(detections, dtype=np.float32)
+
+    # Rotated NMS: cv2.dnn.NMSBoxesRotated takes ((cx, cy), (w, h), angle_deg).
+    rotated_boxes = []
+    for det in detections:
+        cx, cy, w, h, theta = det[:5]
+        rotated_boxes.append(((float(cx), float(cy)), (float(w), float(h)), float(np.degrees(theta))))
+    scores = detections[:, 5].tolist()
+    keep = cv2.dnn.NMSBoxesRotated(rotated_boxes, scores, opt.score_thres, opt.nms_thres)
+    if len(keep) == 0:
+        print("No detections after NMS.")
+        cv2.imwrite(opt.img_save_path, img0)
+        return
+
+    keep = np.array(keep).flatten()
+    final = detections[keep]
+    final[:, :5] = scale_rboxes_lefttop(final[:, :5], scale, orig_shape)
+
+    print(f"Done! Found {len(final)} oriented objects.")
+    for det in final:
+        cx, cy, w, h, theta, conf, cid = det
+        cid = int(cid)
+        name = DOTA_CLASSES[cid] if cid < len(DOTA_CLASSES) else f"cls{cid}"
+        color = DOTA_COLORS[cid % len(DOTA_COLORS)]
+        print(f"  {name:20s} conf={conf:.2f} cx={cx:.1f} cy={cy:.1f} w={w:.1f} h={h:.1f} theta={np.degrees(theta):+.1f} deg")
+        corners = rbox_to_corners(det[:5]).astype(np.int32)
+        cv2.polylines(img0, [corners], isClosed=True, color=color, thickness=2, lineType=cv2.LINE_AA)
+        label = f"{name} {conf:.2f}"
+        (tw, th), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+        x_text, y_text = int(corners[0][0]), max(0, int(corners[0][1]) - 5)
+        cv2.rectangle(img0, (x_text, y_text - th - 2), (x_text + tw + 2, y_text + 2), color, -1)
+        cv2.putText(img0, label, (x_text + 1, y_text - 1),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)
+
+    cv2.imwrite(opt.img_save_path, img0)
+    print(f"Result saved to {opt.img_save_path}")
+
+
+if __name__ == "__main__":
+    main()

yolo26l-obb_1024x1024.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f538f74fe43905154f3e737e7d08686fb85e448819b98d4f98e97250dc6f9fe
+size 102621428

yolo26m-obb_1024x1024.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b22bded2093750fee2a7ba460ab4eea95564e1064fb773b68b6d8ea085b2c5d
+size 84971005

yolo26n-obb_1024x1024.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9540624d3d2a0c5094541bb5bf4b0ba79161b7b5828cd7ad982638a10bb8c425
+size 9917917

yolo26s-obb_1024x1024.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2721ca7d52bd73ecea72ef6989397d684f781460a2aa8ba300f64764a9cd8563
+size 39148849

yolo26x-obb_1024x1024.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2a941f8fadd3c1ebc081a41225c75ccd8f8401195762f5c689ca4013a633bfcf
+size 230436254