μ½˜ν…μΈ λ‘œ κ±΄λ„ˆλ›°κΈ°

μ°Έμ‘° ultralytics/utils/ops.py

μ°Έκ³ 

이 νŒŒμΌμ€ https://github.com/ultralytics/ ultralytics/blob/main/ ultralytics/utils/ops .pyμ—μ„œ 확인할 수 μžˆμŠ΅λ‹ˆλ‹€. 문제λ₯Ό λ°œκ²¬ν•˜λ©΄ ν’€ λ¦¬ν€˜μŠ€νŠΈ (πŸ› οΈ)λ₯Ό μ œμΆœν•˜μ—¬ 문제λ₯Ό ν•΄κ²°ν•˜λ„λ‘ λ„μ™€μ£Όμ„Έμš”. κ°μ‚¬ν•©λ‹ˆλ‹€ πŸ™!



ultralytics.utils.ops.Profile

기지: ContextDecorator

YOLOv8 ν”„λ‘œν•„ 클래슀. Profile()을 μ‚¬μš©ν•˜μ—¬ λ°μ½”λ ˆμ΄ν„°λ‘œ μ‚¬μš©ν•˜κ±°λ‚˜ 'with Profile():'을 μ‚¬μš©ν•˜μ—¬ μ»¨ν…μŠ€νŠΈ κ΄€λ¦¬μžλ‘œ μ‚¬μš©ν•©λ‹ˆλ‹€.

예제
from ultralytics.utils.ops import Profile

with Profile(device=device) as dt:
    pass  # slow operation here

print(dt)  # prints "Elapsed time is 9.5367431640625e-07 s"
의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
class Profile(contextlib.ContextDecorator):
    """
    YOLOv8 Profile class. Use as a decorator with @Profile() or as a context manager with 'with Profile():'.

    Example:
        ```python
        from ultralytics.utils.ops import Profile

        with Profile(device=device) as dt:
            pass  # slow operation here

        print(dt)  # prints "Elapsed time is 9.5367431640625e-07 s"
        ```
    """

    def __init__(self, t=0.0, device: torch.device = None):
        """
        Initialize the Profile class.

        Args:
            t (float): Initial time. Defaults to 0.0.
            device (torch.device): Devices used for model inference. Defaults to None (cpu).
        """
        self.t = t
        self.device = device
        self.cuda = bool(device and str(device).startswith("cuda"))

    def __enter__(self):
        """Start timing."""
        self.start = self.time()
        return self

    def __exit__(self, type, value, traceback):  # noqa
        """Stop timing."""
        self.dt = self.time() - self.start  # delta-time
        self.t += self.dt  # accumulate dt

    def __str__(self):
        """Returns a human-readable string representing the accumulated elapsed time in the profiler."""
        return f"Elapsed time is {self.t} s"

    def time(self):
        """Get current time."""
        if self.cuda:
            torch.cuda.synchronize(self.device)
        return time.time()

__enter__()

μ‹œμž‘ 타이밍.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def __enter__(self):
    """Start timing."""
    self.start = self.time()
    return self

__exit__(type, value, traceback)

타이밍 쀑지.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def __exit__(self, type, value, traceback):  # noqa
    """Stop timing."""
    self.dt = self.time() - self.start  # delta-time
    self.t += self.dt  # accumulate dt

__init__(t=0.0, device=None)

ν”„λ‘œν•„ 클래슀λ₯Ό μ΄ˆκΈ°ν™”ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
t float

초기 μ‹œκ°„μž…λ‹ˆλ‹€. 기본값은 0.0μž…λ‹ˆλ‹€.

0.0
device device

λͺ¨λΈ 좔둠에 μ‚¬μš©λ˜λŠ” μž₯μΉ˜μž…λ‹ˆλ‹€. 기본값은 μ—†μŒ(CPU)μž…λ‹ˆλ‹€.

None
의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def __init__(self, t=0.0, device: torch.device = None):
    """
    Initialize the Profile class.

    Args:
        t (float): Initial time. Defaults to 0.0.
        device (torch.device): Devices used for model inference. Defaults to None (cpu).
    """
    self.t = t
    self.device = device
    self.cuda = bool(device and str(device).startswith("cuda"))

__str__()

ν”„λ‘œνŒŒμΌλŸ¬μ—μ„œ λˆ„μ λœ κ²½κ³Ό μ‹œκ°„μ„ λ‚˜νƒ€λ‚΄λŠ” μ‚¬λžŒμ΄ 읽을 수 μžˆλŠ” λ¬Έμžμ—΄μ„ λ°˜ν™˜ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def __str__(self):
    """Returns a human-readable string representing the accumulated elapsed time in the profiler."""
    return f"Elapsed time is {self.t} s"

time()

ν˜„μž¬ μ‹œκ°„μ„ κ°€μ Έμ˜΅λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def time(self):
    """Get current time."""
    if self.cuda:
        torch.cuda.synchronize(self.device)
    return time.time()



ultralytics.utils.ops.segment2box(segment, width=640, height=640)

1개의 μ„Έκ·Έλ¨ΌνŠΈ λ ˆμ΄λΈ”μ„ 1개의 λ°•μŠ€ λ ˆμ΄λΈ”λ‘œ λ³€ν™˜ν•˜κ³ , 이미지 λ‚΄λΆ€ μ œμ•½ 쑰건(예: (xy1, xy2, ...)을 (xyxy)둜 μ μš©ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
segment Tensor

μ„Έκ·Έλ¨ΌνŠΈ λ ˆμ΄λΈ”

ν•„μˆ˜
width int

μ΄λ―Έμ§€μ˜ λ„ˆλΉ„μž…λ‹ˆλ‹€. 기본값은 640μž…λ‹ˆλ‹€.

640
height int

μ΄λ―Έμ§€μ˜ λ†’μ΄μž…λ‹ˆλ‹€. 기본값은 640μž…λ‹ˆλ‹€.

640

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
ndarray

μ„Έκ·Έλ¨ΌνŠΈμ˜ μ΅œμ†Œκ°’κ³Ό μ΅œλŒ€κ°’μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def segment2box(segment, width=640, height=640):
    """
    Convert 1 segment label to 1 box label, applying inside-image constraint, i.e. (xy1, xy2, ...) to (xyxy).

    Args:
        segment (torch.Tensor): the segment label
        width (int): the width of the image. Defaults to 640
        height (int): The height of the image. Defaults to 640

    Returns:
        (np.ndarray): the minimum and maximum x and y values of the segment.
    """
    x, y = segment.T  # segment xy
    inside = (x >= 0) & (y >= 0) & (x <= width) & (y <= height)
    x = x[inside]
    y = y[inside]
    return (
        np.array([x.min(), y.min(), x.max(), y.max()], dtype=segment.dtype)
        if any(x)
        else np.zeros(4, dtype=segment.dtype)
    )  # xyxy



ultralytics.utils.ops.scale_boxes(img1_shape, boxes, img0_shape, ratio_pad=None, padding=True, xywh=False)

경계 μƒμž(기본값은 xyxy ν˜•μ‹)의 크기λ₯Ό μ›λž˜ (1_shape)에 μ§€μ •λœ 이미지 λͺ¨μ–‘μ—μ„œ μ§€μ •ν•œ μ΄λ―Έμ§€μ˜ λͺ¨μ–‘μ—μ„œ λ‹€λ₯Έ μ΄λ―Έμ§€μ˜ λͺ¨μ–‘(img0_shape)으둜 μž¬μ‘°μ •ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
img1_shape tuple

경계 μƒμžκ°€ μœ„μΉ˜ν•  μ΄λ―Έμ§€μ˜ λͺ¨μ–‘μœΌλ‘œ, (높이, λ„ˆλΉ„) ν˜•μ‹μž…λ‹ˆλ‹€.

ν•„μˆ˜
boxes Tensor

이미지에 μžˆλŠ” 객체의 경계 μƒμžλ₯Ό (x1, y1, x2, y2) ν˜•μ‹μœΌλ‘œ μ§€μ •ν•©λ‹ˆλ‹€.

ν•„μˆ˜
img0_shape tuple

λŒ€μƒ μ΄λ―Έμ§€μ˜ λͺ¨μ–‘을 (높이, λ„ˆλΉ„) ν˜•μ‹μœΌλ‘œ μž…λ ₯ν•©λ‹ˆλ‹€.

ν•„μˆ˜
ratio_pad tuple

μƒμž 크기 μ‘°μ ˆμ„ μœ„ν•œ (λΉ„μœ¨, νŒ¨λ“œ)의 νŠœν”Œμž…λ‹ˆλ‹€. μ œκ³΅ν•˜μ§€ μ•ŠμœΌλ©΄ λΉ„μœ¨κ³Ό νŒ¨λ“œλŠ” 두 μ΄λ―Έμ§€μ˜ 크기 차이에 따라 κ°€ 두 μ΄λ―Έμ§€μ˜ 크기 차이에 따라 κ³„μ‚°λ©λ‹ˆλ‹€.

None
padding bool

True이면 μƒμžκ°€ yolo μŠ€νƒ€μΌλ‘œ λ³΄κ°•λœ 이미지λ₯Ό 기반으둜 ν•œλ‹€κ³  κ°€μ •ν•©λ‹ˆλ‹€. False이면 μ •κΈ°μ μœΌλ‘œ λ¦¬μŠ€μΌ€μΌλ§μ„ μˆ˜ν–‰ν•©λ‹ˆλ‹€.

True
xywh bool

μƒμž ν˜•μ‹μ€ xywh μ—¬λΆ€, κΈ°λ³Έκ°’=Falseμž…λ‹ˆλ‹€.

False

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
boxes Tensor

μŠ€μΌ€μΌλ§λœ λ°”μš΄λ”© λ°•μŠ€λŠ” (x1, y1, x2, y2) ν˜•μ‹μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def scale_boxes(img1_shape, boxes, img0_shape, ratio_pad=None, padding=True, xywh=False):
    """
    Rescales bounding boxes (in the format of xyxy by default) from the shape of the image they were originally
    specified in (img1_shape) to the shape of a different image (img0_shape).

    Args:
        img1_shape (tuple): The shape of the image that the bounding boxes are for, in the format of (height, width).
        boxes (torch.Tensor): the bounding boxes of the objects in the image, in the format of (x1, y1, x2, y2)
        img0_shape (tuple): the shape of the target image, in the format of (height, width).
        ratio_pad (tuple): a tuple of (ratio, pad) for scaling the boxes. If not provided, the ratio and pad will be
            calculated based on the size difference between the two images.
        padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular
            rescaling.
        xywh (bool): The box format is xywh or not, default=False.

    Returns:
        boxes (torch.Tensor): The scaled bounding boxes, in the format of (x1, y1, x2, y2)
    """
    if ratio_pad is None:  # calculate from img0_shape
        gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])  # gain  = old / new
        pad = (
            round((img1_shape[1] - img0_shape[1] * gain) / 2 - 0.1),
            round((img1_shape[0] - img0_shape[0] * gain) / 2 - 0.1),
        )  # wh padding
    else:
        gain = ratio_pad[0][0]
        pad = ratio_pad[1]

    if padding:
        boxes[..., 0] -= pad[0]  # x padding
        boxes[..., 1] -= pad[1]  # y padding
        if not xywh:
            boxes[..., 2] -= pad[0]  # x padding
            boxes[..., 3] -= pad[1]  # y padding
    boxes[..., :4] /= gain
    return clip_boxes(boxes, img0_shape)



ultralytics.utils.ops.make_divisible(x, divisor)

주어진 제수둜 λ‚˜λˆŒ 수 μžˆλŠ” κ°€μž₯ κ°€κΉŒμš΄ 숫자λ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x int

λ‚˜λˆŒ 수 μžˆλŠ” μˆ«μžμž…λ‹ˆλ‹€.

ν•„μˆ˜
divisor int | Tensor

μ œμˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
int

제수둜 λ‚˜λˆŒ 수 μžˆλŠ” κ°€μž₯ κ°€κΉŒμš΄ μˆ˜μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def make_divisible(x, divisor):
    """
    Returns the nearest number that is divisible by the given divisor.

    Args:
        x (int): The number to make divisible.
        divisor (int | torch.Tensor): The divisor.

    Returns:
        (int): The nearest number divisible by the divisor.
    """
    if isinstance(divisor, torch.Tensor):
        divisor = int(divisor.max())  # to int
    return math.ceil(x / divisor) * divisor



ultralytics.utils.ops.nms_rotated(boxes, scores, threshold=0.45)

ν”„λ‘œλΉ„μš°μ™€ νŒ¨μŠ€νŠΈμ—”μ— μ— μ˜ν•΄ κ΅¬λ™λ˜λŠ” 였브젝트용 NMS.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
boxes Tensor

(N, 5), xywhr.

ν•„μˆ˜
scores Tensor

(N, ).

ν•„μˆ˜
threshold float

Iou μž„κ³„κ°’.

0.45

λ°˜ν™˜ν•©λ‹ˆλ‹€:

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def nms_rotated(boxes, scores, threshold=0.45):
    """
    NMS for obbs, powered by probiou and fast-nms.

    Args:
        boxes (torch.Tensor): (N, 5), xywhr.
        scores (torch.Tensor): (N, ).
        threshold (float): Iou threshold.

    Returns:
    """
    if len(boxes) == 0:
        return np.empty((0,), dtype=np.int8)
    sorted_idx = torch.argsort(scores, descending=True)
    boxes = boxes[sorted_idx]
    ious = batch_probiou(boxes, boxes).triu_(diagonal=1)
    pick = torch.nonzero(ious.max(dim=0)[0] < threshold).squeeze_(-1)
    return sorted_idx[pick]



ultralytics.utils.ops.non_max_suppression(prediction, conf_thres=0.25, iou_thres=0.45, classes=None, agnostic=False, multi_label=False, labels=(), max_det=300, nc=0, max_time_img=0.05, max_nms=30000, max_wh=7680, in_place=True, rotated=False)

마슀크 및 μƒμžλ‹Ή μ—¬λŸ¬ 개의 λ ˆμ΄λΈ”μ„ μ§€μ›ν•˜μ—¬ μƒμž μ„ΈνŠΈμ— λŒ€ν•΄ λΉ„μ΅œλŒ€ μ–΅μ œ(NMS)λ₯Ό μˆ˜ν–‰ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
prediction Tensor

tensor λͺ¨μ–‘(batch_size, num_classes + 4 + num_masks, num_boxes) 예츑된 μƒμž, 클래슀 및 마슀크λ₯Ό ν¬ν•¨ν•©λ‹ˆλ‹€. tensor 은 λ‹€μŒκ³Ό 같은 ν˜•μ‹μ΄μ–΄μ•Ό ν•©λ‹ˆλ‹€. ν˜•μ‹μ΄μ–΄μ•Ό ν•©λ‹ˆλ‹€(예: YOLO).

ν•„μˆ˜
conf_thres float

μƒμžκ°€ ν•„ν„°λ§λ˜λŠ” 신뒰도 μž„κ³„κ°’μž…λ‹ˆλ‹€. μœ νš¨ν•œ 값은 0.0μ—μ„œ 1.0 μ‚¬μ΄μž…λ‹ˆλ‹€.

0.25
iou_thres float

NMS 쀑에 μƒμžκ°€ ν•„ν„°λ§λ˜λŠ” IoU μž„κ³„κ°’μž…λ‹ˆλ‹€. μœ νš¨ν•œ 값은 0.0μ—μ„œ 1.0 μ‚¬μ΄μž…λ‹ˆλ‹€.

0.45
classes List[int]

κ³ λ €ν•  클래슀 인덱슀 λͺ©λ‘μž…λ‹ˆλ‹€. None을 μ„ νƒν•˜λ©΄ λͺ¨λ“  ν΄λž˜μŠ€κ°€ κ³ λ €λ©λ‹ˆλ‹€.

None
agnostic bool

True이면 λͺ¨λΈμ€ 클래슀 μˆ˜μ— ꡬ애받지 μ•Šκ³  λͺ¨λ“  ν΄λž˜μŠ€κ°€ λͺ¨λ‘ ν•˜λ‚˜λ‘œ κ°„μ£Όλ©λ‹ˆλ‹€.

False
multi_label bool

True인 경우 각 μƒμžμ— μ—¬λŸ¬ 개의 λ ˆμ΄λΈ”μ΄ μžˆμ„ 수 μžˆμŠ΅λ‹ˆλ‹€.

False
labels List[List[Union[int, float, Tensor]]]

λͺ©λ‘μ˜ λͺ©λ‘μœΌλ‘œ, 각 λ‚΄λΆ€ λͺ©λ‘μ—λŠ” 주어진 이미지에 λŒ€ν•œ μ„ ν—˜μ  λ ˆμ΄λΈ”μ΄ ν¬ν•¨λ©λ‹ˆλ‹€. λͺ©λ‘μ€ 데이터 λ‘œλ”κ°€ 좜λ ₯ν•˜λŠ” ν˜•μ‹μ΄μ–΄μ•Ό ν•˜λ©°, 각 λ ˆμ΄λΈ”μ€ (class_index, x1, y1, x2, y2)의 νŠœν”Œμ΄μ–΄μ•Ό ν•©λ‹ˆλ‹€.

()
max_det int

NMS 이후 보관할 μ΅œλŒ€ μƒμž μˆ˜μž…λ‹ˆλ‹€.

300
nc int

λͺ¨λΈμ΄ 좜λ ₯ν•˜λŠ” 클래슀 μˆ˜μž…λ‹ˆλ‹€. 이 μ΄ν›„μ˜ μΈλ±μŠ€λŠ” λͺ¨λ‘ 마슀크둜 κ°„μ£Όλ©λ‹ˆλ‹€.

0
max_time_img float

이미지 ν•˜λ‚˜λ₯Ό μ²˜λ¦¬ν•˜λŠ” 데 κ±Έλ¦¬λŠ” μ΅œλŒ€ μ‹œκ°„(초)μž…λ‹ˆλ‹€.

0.05
max_nms int

μ΅œλŒ€ μƒμž 수λ₯Ό torchvision.ops.nms()에 넣을 수 μžˆμŠ΅λ‹ˆλ‹€.

30000
max_wh int

μ΅œλŒ€ μƒμž λ„ˆλΉ„μ™€ 높이(ν”½μ…€ λ‹¨μœ„)μž…λ‹ˆλ‹€.

7680
in_place bool

True이면 μž…λ ₯ 예츑 tensor 이 μ œμžλ¦¬μ—μ„œ μˆ˜μ •λ©λ‹ˆλ‹€.

True

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
List[Tensor]

각 μš”μ†Œκ°€ tensor 의 길이 batch_size λͺ©λ‘μž…λ‹ˆλ‹€. λͺ¨μ–‘(num_boxes, 6 + num_masks), λ³΄κ΄€λœ μƒμžλ₯Ό ν¬ν•¨ν•˜λŠ” μ—΄( (x1, y1, x2, y2, confidence, class, mask1, mask2, ...).

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def non_max_suppression(
    prediction,
    conf_thres=0.25,
    iou_thres=0.45,
    classes=None,
    agnostic=False,
    multi_label=False,
    labels=(),
    max_det=300,
    nc=0,  # number of classes (optional)
    max_time_img=0.05,
    max_nms=30000,
    max_wh=7680,
    in_place=True,
    rotated=False,
):
    """
    Perform non-maximum suppression (NMS) on a set of boxes, with support for masks and multiple labels per box.

    Args:
        prediction (torch.Tensor): A tensor of shape (batch_size, num_classes + 4 + num_masks, num_boxes)
            containing the predicted boxes, classes, and masks. The tensor should be in the format
            output by a model, such as YOLO.
        conf_thres (float): The confidence threshold below which boxes will be filtered out.
            Valid values are between 0.0 and 1.0.
        iou_thres (float): The IoU threshold below which boxes will be filtered out during NMS.
            Valid values are between 0.0 and 1.0.
        classes (List[int]): A list of class indices to consider. If None, all classes will be considered.
        agnostic (bool): If True, the model is agnostic to the number of classes, and all
            classes will be considered as one.
        multi_label (bool): If True, each box may have multiple labels.
        labels (List[List[Union[int, float, torch.Tensor]]]): A list of lists, where each inner
            list contains the apriori labels for a given image. The list should be in the format
            output by a dataloader, with each label being a tuple of (class_index, x1, y1, x2, y2).
        max_det (int): The maximum number of boxes to keep after NMS.
        nc (int, optional): The number of classes output by the model. Any indices after this will be considered masks.
        max_time_img (float): The maximum time (seconds) for processing one image.
        max_nms (int): The maximum number of boxes into torchvision.ops.nms().
        max_wh (int): The maximum box width and height in pixels.
        in_place (bool): If True, the input prediction tensor will be modified in place.

    Returns:
        (List[torch.Tensor]): A list of length batch_size, where each element is a tensor of
            shape (num_boxes, 6 + num_masks) containing the kept boxes, with columns
            (x1, y1, x2, y2, confidence, class, mask1, mask2, ...).
    """

    # Checks
    assert 0 <= conf_thres <= 1, f"Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0"
    assert 0 <= iou_thres <= 1, f"Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0"
    if isinstance(prediction, (list, tuple)):  # YOLOv8 model in validation model, output = (inference_out, loss_out)
        prediction = prediction[0]  # select only inference output

    bs = prediction.shape[0]  # batch size
    nc = nc or (prediction.shape[1] - 4)  # number of classes
    nm = prediction.shape[1] - nc - 4
    mi = 4 + nc  # mask start index
    xc = prediction[:, 4:mi].amax(1) > conf_thres  # candidates

    # Settings
    # min_wh = 2  # (pixels) minimum box width and height
    time_limit = 2.0 + max_time_img * bs  # seconds to quit after
    multi_label &= nc > 1  # multiple labels per box (adds 0.5ms/img)

    prediction = prediction.transpose(-1, -2)  # shape(1,84,6300) to shape(1,6300,84)
    if not rotated:
        if in_place:
            prediction[..., :4] = xywh2xyxy(prediction[..., :4])  # xywh to xyxy
        else:
            prediction = torch.cat((xywh2xyxy(prediction[..., :4]), prediction[..., 4:]), dim=-1)  # xywh to xyxy

    t = time.time()
    output = [torch.zeros((0, 6 + nm), device=prediction.device)] * bs
    for xi, x in enumerate(prediction):  # image index, image inference
        # Apply constraints
        # x[((x[:, 2:4] < min_wh) | (x[:, 2:4] > max_wh)).any(1), 4] = 0  # width-height
        x = x[xc[xi]]  # confidence

        # Cat apriori labels if autolabelling
        if labels and len(labels[xi]) and not rotated:
            lb = labels[xi]
            v = torch.zeros((len(lb), nc + nm + 4), device=x.device)
            v[:, :4] = xywh2xyxy(lb[:, 1:5])  # box
            v[range(len(lb)), lb[:, 0].long() + 4] = 1.0  # cls
            x = torch.cat((x, v), 0)

        # If none remain process next image
        if not x.shape[0]:
            continue

        # Detections matrix nx6 (xyxy, conf, cls)
        box, cls, mask = x.split((4, nc, nm), 1)

        if multi_label:
            i, j = torch.where(cls > conf_thres)
            x = torch.cat((box[i], x[i, 4 + j, None], j[:, None].float(), mask[i]), 1)
        else:  # best class only
            conf, j = cls.max(1, keepdim=True)
            x = torch.cat((box, conf, j.float(), mask), 1)[conf.view(-1) > conf_thres]

        # Filter by class
        if classes is not None:
            x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]

        # Check shape
        n = x.shape[0]  # number of boxes
        if not n:  # no boxes
            continue
        if n > max_nms:  # excess boxes
            x = x[x[:, 4].argsort(descending=True)[:max_nms]]  # sort by confidence and remove excess boxes

        # Batched NMS
        c = x[:, 5:6] * (0 if agnostic else max_wh)  # classes
        scores = x[:, 4]  # scores
        if rotated:
            boxes = torch.cat((x[:, :2] + c, x[:, 2:4], x[:, -1:]), dim=-1)  # xywhr
            i = nms_rotated(boxes, scores, iou_thres)
        else:
            boxes = x[:, :4] + c  # boxes (offset by class)
            i = torchvision.ops.nms(boxes, scores, iou_thres)  # NMS
        i = i[:max_det]  # limit detections

        # # Experimental
        # merge = False  # use merge-NMS
        # if merge and (1 < n < 3E3):  # Merge NMS (boxes merged using weighted mean)
        #     # Update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)
        #     from .metrics import box_iou
        #     iou = box_iou(boxes[i], boxes) > iou_thres  # iou matrix
        #     weights = iou * scores[None]  # box weights
        #     x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True)  # merged boxes
        #     redundant = True  # require redundant detections
        #     if redundant:
        #         i = i[iou.sum(1) > 1]  # require redundancy

        output[xi] = x[i]
        if (time.time() - t) > time_limit:
            LOGGER.warning(f"WARNING ⚠️ NMS time limit {time_limit:.3f}s exceeded")
            break  # time limit exceeded

    return output



ultralytics.utils.ops.clip_boxes(boxes, shape)

경계 μƒμž λͺ©λ‘κ³Ό λ„ν˜•(높이, λ„ˆλΉ„)을 κ°€μ Έμ™€μ„œ 경계 μƒμžλ₯Ό λ„ν˜•μ— ν΄λ¦½ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
boxes Tensor

클립할 경계 μƒμž

ν•„μˆ˜
shape tuple

μ΄λ―Έμ§€μ˜ λͺ¨μ–‘

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
Tensor | ndarray

μž˜λΌλ‚Έ μƒμž

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def clip_boxes(boxes, shape):
    """
    Takes a list of bounding boxes and a shape (height, width) and clips the bounding boxes to the shape.

    Args:
        boxes (torch.Tensor): the bounding boxes to clip
        shape (tuple): the shape of the image

    Returns:
        (torch.Tensor | numpy.ndarray): Clipped boxes
    """
    if isinstance(boxes, torch.Tensor):  # faster individually (WARNING: inplace .clamp_() Apple MPS bug)
        boxes[..., 0] = boxes[..., 0].clamp(0, shape[1])  # x1
        boxes[..., 1] = boxes[..., 1].clamp(0, shape[0])  # y1
        boxes[..., 2] = boxes[..., 2].clamp(0, shape[1])  # x2
        boxes[..., 3] = boxes[..., 3].clamp(0, shape[0])  # y2
    else:  # np.array (faster grouped)
        boxes[..., [0, 2]] = boxes[..., [0, 2]].clip(0, shape[1])  # x1, x2
        boxes[..., [1, 3]] = boxes[..., [1, 3]].clip(0, shape[0])  # y1, y2
    return boxes



ultralytics.utils.ops.clip_coords(coords, shape)

이미지 경계에 μ„  μ’Œν‘œλ₯Ό ν΄λ¦½ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
coords Tensor | ndarray

μ„  μ’Œν‘œ λͺ©λ‘μž…λ‹ˆλ‹€.

ν•„μˆ˜
shape tuple

μ΄λ―Έμ§€μ˜ 크기(높이, λ„ˆλΉ„)λ₯Ό ν˜•μ‹(높이, λ„ˆλΉ„)으둜 λ‚˜νƒ€λ‚΄λŠ” μ •μˆ˜ νŠœν”Œμž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
Tensor | ndarray

잘린 μ’Œν‘œ

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def clip_coords(coords, shape):
    """
    Clip line coordinates to the image boundaries.

    Args:
        coords (torch.Tensor | numpy.ndarray): A list of line coordinates.
        shape (tuple): A tuple of integers representing the size of the image in the format (height, width).

    Returns:
        (torch.Tensor | numpy.ndarray): Clipped coordinates
    """
    if isinstance(coords, torch.Tensor):  # faster individually (WARNING: inplace .clamp_() Apple MPS bug)
        coords[..., 0] = coords[..., 0].clamp(0, shape[1])  # x
        coords[..., 1] = coords[..., 1].clamp(0, shape[0])  # y
    else:  # np.array (faster grouped)
        coords[..., 0] = coords[..., 0].clip(0, shape[1])  # x
        coords[..., 1] = coords[..., 1].clip(0, shape[0])  # y
    return coords



ultralytics.utils.ops.scale_image(masks, im0_shape, ratio_pad=None)

마슀크λ₯Ό κ°€μ Έμ™€μ„œ 원본 이미지 크기둜 크기λ₯Ό μ‘°μ •ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
masks ndarray

크기 μ‘°μ • 및 νŒ¨λ”©λœ 마슀크/이미지, [h, w, num]/[h, w, 3].

ν•„μˆ˜
im0_shape tuple

원본 이미지 λͺ¨μ–‘

ν•„μˆ˜
ratio_pad tuple

원본 이미지에 λŒ€ν•œ νŒ¨λ”©μ˜ λΉ„μœ¨μž…λ‹ˆλ‹€.

None

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
masks Tensor

λ°˜ν’ˆλ˜λŠ” λ§ˆμŠ€ν¬μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def scale_image(masks, im0_shape, ratio_pad=None):
    """
    Takes a mask, and resizes it to the original image size.

    Args:
        masks (np.ndarray): resized and padded masks/images, [h, w, num]/[h, w, 3].
        im0_shape (tuple): the original image shape
        ratio_pad (tuple): the ratio of the padding to the original image.

    Returns:
        masks (torch.Tensor): The masks that are being returned.
    """
    # Rescale coordinates (xyxy) from im1_shape to im0_shape
    im1_shape = masks.shape
    if im1_shape[:2] == im0_shape[:2]:
        return masks
    if ratio_pad is None:  # calculate from im0_shape
        gain = min(im1_shape[0] / im0_shape[0], im1_shape[1] / im0_shape[1])  # gain  = old / new
        pad = (im1_shape[1] - im0_shape[1] * gain) / 2, (im1_shape[0] - im0_shape[0] * gain) / 2  # wh padding
    else:
        # gain = ratio_pad[0][0]
        pad = ratio_pad[1]
    top, left = int(pad[1]), int(pad[0])  # y, x
    bottom, right = int(im1_shape[0] - pad[1]), int(im1_shape[1] - pad[0])

    if len(masks.shape) < 2:
        raise ValueError(f'"len of masks shape" should be 2 or 3, but got {len(masks.shape)}')
    masks = masks[top:bottom, left:right]
    masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]))
    if len(masks.shape) == 2:
        masks = masks[:, :, None]

    return masks



ultralytics.utils.ops.xyxy2xywh(x)

λ°”μš΄λ”© λ°•μŠ€ μ’Œν‘œλ₯Ό (x1, y1, x2, y2) ν˜•μ‹μ—μ„œ (x, y, λ„ˆλΉ„, 높이) ν˜•μ‹μœΌλ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. μ™Όμͺ½ 상단 λͺ¨μ„œλ¦¬μ΄κ³  (x2, y2)λŠ” 였λ₯Έμͺ½ ν•˜λ‹¨ λͺ¨μ„œλ¦¬μž…λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x ndarray | Tensor

μž…λ ₯ λ°”μš΄λ”©λ°•μŠ€ μ’Œν‘œλŠ” (x1, y1, x2, y2) ν˜•μ‹μž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
y ndarray | Tensor

경계 μƒμž μ’Œν‘œλŠ” (x, y, λ„ˆλΉ„, 높이) ν˜•μ‹μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xyxy2xywh(x):
    """
    Convert bounding box coordinates from (x1, y1, x2, y2) format to (x, y, width, height) format where (x1, y1) is the
    top-left corner and (x2, y2) is the bottom-right corner.

    Args:
        x (np.ndarray | torch.Tensor): The input bounding box coordinates in (x1, y1, x2, y2) format.

    Returns:
        y (np.ndarray | torch.Tensor): The bounding box coordinates in (x, y, width, height) format.
    """
    assert x.shape[-1] == 4, f"input shape last dimension expected 4 but input shape is {x.shape}"
    y = torch.empty_like(x) if isinstance(x, torch.Tensor) else np.empty_like(x)  # faster than clone/copy
    y[..., 0] = (x[..., 0] + x[..., 2]) / 2  # x center
    y[..., 1] = (x[..., 1] + x[..., 3]) / 2  # y center
    y[..., 2] = x[..., 2] - x[..., 0]  # width
    y[..., 3] = x[..., 3] - x[..., 1]  # height
    return y



ultralytics.utils.ops.xywh2xyxy(x)

λ°”μš΄λ”© λ°•μŠ€ μ’Œν‘œλ₯Ό (x, y, λ„ˆλΉ„, 높이) ν˜•μ‹μ—μ„œ (x1, y1, x2, y2) ν˜•μ‹μœΌλ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€. μ™Όμͺ½ 상단 λͺ¨μ„œλ¦¬μ΄κ³  (x2, y2)λŠ” 였λ₯Έμͺ½ ν•˜λ‹¨ λͺ¨μ„œλ¦¬μž…λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x ndarray | Tensor

μž…λ ₯ λ°”μš΄λ”©λ°•μŠ€ μ’Œν‘œλŠ” (x, y, λ„ˆλΉ„, 높이) ν˜•μ‹μž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
y ndarray | Tensor

λ°”μš΄λ”© λ°•μŠ€ μ’Œν‘œλŠ” (x1, y1, x2, y2) ν˜•μ‹μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xywh2xyxy(x):
    """
    Convert bounding box coordinates from (x, y, width, height) format to (x1, y1, x2, y2) format where (x1, y1) is the
    top-left corner and (x2, y2) is the bottom-right corner.

    Args:
        x (np.ndarray | torch.Tensor): The input bounding box coordinates in (x, y, width, height) format.

    Returns:
        y (np.ndarray | torch.Tensor): The bounding box coordinates in (x1, y1, x2, y2) format.
    """
    assert x.shape[-1] == 4, f"input shape last dimension expected 4 but input shape is {x.shape}"
    y = torch.empty_like(x) if isinstance(x, torch.Tensor) else np.empty_like(x)  # faster than clone/copy
    dw = x[..., 2] / 2  # half-width
    dh = x[..., 3] / 2  # half-height
    y[..., 0] = x[..., 0] - dw  # top left x
    y[..., 1] = x[..., 1] - dh  # top left y
    y[..., 2] = x[..., 0] + dw  # bottom right x
    y[..., 3] = x[..., 1] + dh  # bottom right y
    return y



ultralytics.utils.ops.xywhn2xyxy(x, w=640, h=640, padw=0, padh=0)

μ •κ·œν™”λœ 경계 μƒμž μ’Œν‘œλ₯Ό ν”½μ…€ μ’Œν‘œλ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x ndarray | Tensor

경계 μƒμž μ’Œν‘œμž…λ‹ˆλ‹€.

ν•„μˆ˜
w int

μ΄λ―Έμ§€μ˜ λ„ˆλΉ„μž…λ‹ˆλ‹€. 기본값은 640μž…λ‹ˆλ‹€.

640
h int

μ΄λ―Έμ§€μ˜ λ†’μ΄μž…λ‹ˆλ‹€. 기본값은 640μž…λ‹ˆλ‹€.

640
padw int

νŒ¨λ”© λ„ˆλΉ„. 기본값은 0μž…λ‹ˆλ‹€.

0
padh int

νŒ¨λ”© 높이. 기본값은 0μž…λ‹ˆλ‹€.

0

λ°˜ν™˜ν•©λ‹ˆλ‹€: y (np.ndarray | torch.Tensor): [x1, y1, x2, y2] ν˜•μ‹μ˜ λ°”μš΄λ”© λ°•μŠ€μ˜ μ’Œν‘œμž…λ‹ˆλ‹€. x1,y1은 λ°”μš΄λ”© λ°•μŠ€μ˜ μ™Όμͺ½ 상단 λͺ¨μ„œλ¦¬, x2,y2λŠ” 였λ₯Έμͺ½ ν•˜λ‹¨ λͺ¨μ„œλ¦¬μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xywhn2xyxy(x, w=640, h=640, padw=0, padh=0):
    """
    Convert normalized bounding box coordinates to pixel coordinates.

    Args:
        x (np.ndarray | torch.Tensor): The bounding box coordinates.
        w (int): Width of the image. Defaults to 640
        h (int): Height of the image. Defaults to 640
        padw (int): Padding width. Defaults to 0
        padh (int): Padding height. Defaults to 0
    Returns:
        y (np.ndarray | torch.Tensor): The coordinates of the bounding box in the format [x1, y1, x2, y2] where
            x1,y1 is the top-left corner, x2,y2 is the bottom-right corner of the bounding box.
    """
    assert x.shape[-1] == 4, f"input shape last dimension expected 4 but input shape is {x.shape}"
    y = torch.empty_like(x) if isinstance(x, torch.Tensor) else np.empty_like(x)  # faster than clone/copy
    y[..., 0] = w * (x[..., 0] - x[..., 2] / 2) + padw  # top left x
    y[..., 1] = h * (x[..., 1] - x[..., 3] / 2) + padh  # top left y
    y[..., 2] = w * (x[..., 0] + x[..., 2] / 2) + padw  # bottom right x
    y[..., 3] = h * (x[..., 1] + x[..., 3] / 2) + padh  # bottom right y
    return y



ultralytics.utils.ops.xyxy2xywhn(x, w=640, h=640, clip=False, eps=0.0)

경계 μƒμž μ’Œν‘œλ₯Ό (x1, y1, x2, y2) ν˜•μ‹μ—μ„œ (x, y, λ„ˆλΉ„, 높이, μ •κ·œν™”λœ) ν˜•μ‹μœΌλ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€, λ„ˆλΉ„, λ†’μ΄λŠ” 이미지 크기둜 μ •κ·œν™”λ©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x ndarray | Tensor

μž…λ ₯ λ°”μš΄λ”©λ°•μŠ€ μ’Œν‘œλŠ” (x1, y1, x2, y2) ν˜•μ‹μž…λ‹ˆλ‹€.

ν•„μˆ˜
w int

μ΄λ―Έμ§€μ˜ λ„ˆλΉ„μž…λ‹ˆλ‹€. 기본값은 640μž…λ‹ˆλ‹€.

640
h int

μ΄λ―Έμ§€μ˜ λ†’μ΄μž…λ‹ˆλ‹€. 기본값은 640μž…λ‹ˆλ‹€.

640
clip bool

True이면 μƒμžκ°€ 이미지 κ²½κ³„λ‘œ μž˜λ¦½λ‹ˆλ‹€. 기본값은 Falseμž…λ‹ˆλ‹€.

False
eps float

μƒμžμ˜ λ„ˆλΉ„μ™€ λ†’μ΄μ˜ μ΅œμ†Œκ°’μž…λ‹ˆλ‹€. 기본값은 0.0μž…λ‹ˆλ‹€.

0.0

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
y ndarray | Tensor

경계 μƒμž μ’Œν‘œλŠ” (x, y, λ„ˆλΉ„, 높이, μ •κ·œν™”λœ) ν˜•μ‹μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xyxy2xywhn(x, w=640, h=640, clip=False, eps=0.0):
    """
    Convert bounding box coordinates from (x1, y1, x2, y2) format to (x, y, width, height, normalized) format. x, y,
    width and height are normalized to image dimensions.

    Args:
        x (np.ndarray | torch.Tensor): The input bounding box coordinates in (x1, y1, x2, y2) format.
        w (int): The width of the image. Defaults to 640
        h (int): The height of the image. Defaults to 640
        clip (bool): If True, the boxes will be clipped to the image boundaries. Defaults to False
        eps (float): The minimum value of the box's width and height. Defaults to 0.0

    Returns:
        y (np.ndarray | torch.Tensor): The bounding box coordinates in (x, y, width, height, normalized) format
    """
    if clip:
        x = clip_boxes(x, (h - eps, w - eps))
    assert x.shape[-1] == 4, f"input shape last dimension expected 4 but input shape is {x.shape}"
    y = torch.empty_like(x) if isinstance(x, torch.Tensor) else np.empty_like(x)  # faster than clone/copy
    y[..., 0] = ((x[..., 0] + x[..., 2]) / 2) / w  # x center
    y[..., 1] = ((x[..., 1] + x[..., 3]) / 2) / h  # y center
    y[..., 2] = (x[..., 2] - x[..., 0]) / w  # width
    y[..., 3] = (x[..., 3] - x[..., 1]) / h  # height
    return y



ultralytics.utils.ops.xywh2ltwh(x)

λ°”μš΄λ”© λ°•μŠ€ ν˜•μ‹μ„ [x, y, w, h]μ—μ„œ [x1, y1, w, h]둜 λ³€ν™˜ν•©λ‹ˆλ‹€. μ—¬κΈ°μ„œ x1, y1은 μ™Όμͺ½ 상단 μ’Œν‘œμž…λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x ndarray | Tensor

μž…λ ₯ tensor , λ°”μš΄λ”© λ°•μŠ€ μ’Œν‘œλŠ” xywh ν˜•μ‹μž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
y ndarray | Tensor

경계 μƒμž μ’Œν‘œλŠ” xyltwh ν˜•μ‹μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xywh2ltwh(x):
    """
    Convert the bounding box format from [x, y, w, h] to [x1, y1, w, h], where x1, y1 are the top-left coordinates.

    Args:
        x (np.ndarray | torch.Tensor): The input tensor with the bounding box coordinates in the xywh format

    Returns:
        y (np.ndarray | torch.Tensor): The bounding box coordinates in the xyltwh format
    """
    y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
    y[..., 0] = x[..., 0] - x[..., 2] / 2  # top left x
    y[..., 1] = x[..., 1] - x[..., 3] / 2  # top left y
    return y



ultralytics.utils.ops.xyxy2ltwh(x)

nx4 λ°”μš΄λ”© λ°•μŠ€λ₯Ό [x1, y1, x2, y2]μ—μ„œ [x1, y1, w, h]둜 λ³€ν™˜ν•©λ‹ˆλ‹€(μ—¬κΈ°μ„œ xy1=μ™Όμͺ½ 상단, xy2=였λ₯Έμͺ½ ν•˜λ‹¨).

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x ndarray | Tensor

tensor μž…λ ₯은 경계 μƒμž μ’Œν‘œκ°€ xyxy ν˜•μ‹μœΌλ‘œ λ˜μ–΄ μžˆμŠ΅λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
y ndarray | Tensor

경계 μƒμž μ’Œν‘œλŠ” xyltwh ν˜•μ‹μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xyxy2ltwh(x):
    """
    Convert nx4 bounding boxes from [x1, y1, x2, y2] to [x1, y1, w, h], where xy1=top-left, xy2=bottom-right.

    Args:
        x (np.ndarray | torch.Tensor): The input tensor with the bounding boxes coordinates in the xyxy format

    Returns:
        y (np.ndarray | torch.Tensor): The bounding box coordinates in the xyltwh format.
    """
    y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
    y[..., 2] = x[..., 2] - x[..., 0]  # width
    y[..., 3] = x[..., 3] - x[..., 1]  # height
    return y



ultralytics.utils.ops.ltwh2xywh(x)

nx4 λ°•μŠ€λ₯Ό [x1, y1, w, h]μ—μ„œ [x, y, w, h]둜 λ³€ν™˜ν•©λ‹ˆλ‹€(μ—¬κΈ°μ„œ xy1=μ™Όμͺ½ 상단, xy=쀑앙).

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x Tensor

μž…λ ₯ tensor

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
y ndarray | Tensor

경계 μƒμž μ’Œν‘œλŠ” xywh ν˜•μ‹μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def ltwh2xywh(x):
    """
    Convert nx4 boxes from [x1, y1, w, h] to [x, y, w, h] where xy1=top-left, xy=center.

    Args:
        x (torch.Tensor): the input tensor

    Returns:
        y (np.ndarray | torch.Tensor): The bounding box coordinates in the xywh format.
    """
    y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
    y[..., 0] = x[..., 0] + x[..., 2] / 2  # center x
    y[..., 1] = x[..., 1] + x[..., 3] / 2  # center y
    return y



ultralytics.utils.ops.xyxyxyxy2xywhr(corners)

배치된 λ°©ν–₯ λ°”μš΄λ”© λ°•μŠ€(OBB)λ₯Ό [xy1, xy2, xy3, xy4]μ—μ„œ [xywh, νšŒμ „]으둜 λ³€ν™˜ν•©λ‹ˆλ‹€. νšŒμ „ 값은 0μ—μ„œ 90 μ‚¬μ΄μ˜ κ°λ„λ‘œ μ˜ˆμƒλ©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
corners ndarray | Tensor

λ„ν˜•μ˜ λͺ¨μ„œλ¦¬(n, 8)λ₯Ό μž…λ ₯ν•©λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
ndarray | Tensor

λ„ν˜•(n, 5)의 [cx, cy, w, h, νšŒμ „] ν˜•μ‹μœΌλ‘œ λ³€ν™˜λœ λ°μ΄ν„°μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xyxyxyxy2xywhr(corners):
    """
    Convert batched Oriented Bounding Boxes (OBB) from [xy1, xy2, xy3, xy4] to [xywh, rotation]. Rotation values are
    expected in degrees from 0 to 90.

    Args:
        corners (numpy.ndarray | torch.Tensor): Input corners of shape (n, 8).

    Returns:
        (numpy.ndarray | torch.Tensor): Converted data in [cx, cy, w, h, rotation] format of shape (n, 5).
    """
    is_torch = isinstance(corners, torch.Tensor)
    points = corners.cpu().numpy() if is_torch else corners
    points = points.reshape(len(corners), -1, 2)
    rboxes = []
    for pts in points:
        # NOTE: Use cv2.minAreaRect to get accurate xywhr,
        # especially some objects are cut off by augmentations in dataloader.
        (x, y), (w, h), angle = cv2.minAreaRect(pts)
        rboxes.append([x, y, w, h, angle / 180 * np.pi])
    return (
        torch.tensor(rboxes, device=corners.device, dtype=corners.dtype)
        if is_torch
        else np.asarray(rboxes, dtype=points.dtype)
    )  # rboxes



ultralytics.utils.ops.xywhr2xyxyxyxy(rboxes)

배치된 λ°©ν–₯ λ°”μš΄λ”© λ°•μŠ€(OBB)λ₯Ό [xywh, νšŒμ „]μ—μ„œ [xy1, xy2, xy3, xy4]둜 λ³€ν™˜ν•©λ‹ˆλ‹€. νšŒμ „ 값은 λ‹€μŒκ³Ό κ°™μ•„μ•Ό ν•©λ‹ˆλ‹€. 0μ—μ„œ 90 μ‚¬μ΄μ˜ 각도 λ‹¨μœ„μ—¬μ•Ό ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
rboxes ndarray | Tensor

λͺ¨μ–‘ (n, 5) λ˜λŠ” (b, n, 5) ν˜•μ‹μ˜ [cx, cy, w, h, νšŒμ „] μƒμžμž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
ndarray | Tensor

λ„ν˜• (n, 4, 2) λ˜λŠ” (b, n, 4, 2)의 λ³€ν™˜λœ λͺ¨μ„œλ¦¬ μ μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def xywhr2xyxyxyxy(rboxes):
    """
    Convert batched Oriented Bounding Boxes (OBB) from [xywh, rotation] to [xy1, xy2, xy3, xy4]. Rotation values should
    be in degrees from 0 to 90.

    Args:
        rboxes (numpy.ndarray | torch.Tensor): Boxes in [cx, cy, w, h, rotation] format of shape (n, 5) or (b, n, 5).

    Returns:
        (numpy.ndarray | torch.Tensor): Converted corner points of shape (n, 4, 2) or (b, n, 4, 2).
    """
    is_numpy = isinstance(rboxes, np.ndarray)
    cos, sin = (np.cos, np.sin) if is_numpy else (torch.cos, torch.sin)

    ctr = rboxes[..., :2]
    w, h, angle = (rboxes[..., i : i + 1] for i in range(2, 5))
    cos_value, sin_value = cos(angle), sin(angle)
    vec1 = [w / 2 * cos_value, w / 2 * sin_value]
    vec2 = [-h / 2 * sin_value, h / 2 * cos_value]
    vec1 = np.concatenate(vec1, axis=-1) if is_numpy else torch.cat(vec1, dim=-1)
    vec2 = np.concatenate(vec2, axis=-1) if is_numpy else torch.cat(vec2, dim=-1)
    pt1 = ctr + vec1 + vec2
    pt2 = ctr + vec1 - vec2
    pt3 = ctr - vec1 - vec2
    pt4 = ctr - vec1 + vec2
    return np.stack([pt1, pt2, pt3, pt4], axis=-2) if is_numpy else torch.stack([pt1, pt2, pt3, pt4], dim=-2)



ultralytics.utils.ops.ltwh2xyxy(x)

λ°”μš΄λ”© λ°•μŠ€λ₯Ό [x1, y1, w, h]μ—μ„œ [x1, y1, x2, y2]둜 λ³€ν™˜ν•˜λ©°, μ—¬κΈ°μ„œ xy1=μ™Όμͺ½ 상단, xy2=였λ₯Έμͺ½ ν•˜λ‹¨μž…λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
x ndarray | Tensor

μž…λ ₯ 이미지

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
y ndarray | Tensor

λ°”μš΄λ”© λ°•μŠ€μ˜ xyxy μ’Œν‘œμž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def ltwh2xyxy(x):
    """
    It converts the bounding box from [x1, y1, w, h] to [x1, y1, x2, y2] where xy1=top-left, xy2=bottom-right.

    Args:
        x (np.ndarray | torch.Tensor): the input image

    Returns:
        y (np.ndarray | torch.Tensor): the xyxy coordinates of the bounding boxes.
    """
    y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)
    y[..., 2] = x[..., 2] + x[..., 0]  # width
    y[..., 3] = x[..., 3] + x[..., 1]  # height
    return y



ultralytics.utils.ops.segments2boxes(segments)

μ„Έκ·Έλ¨ΌνŠΈ λ ˆμ΄λΈ”μ„ λ°•μŠ€ λ ˆμ΄λΈ”λ‘œ λ³€ν™˜ν•©λ‹ˆλ‹€(예: (cls, xy1, xy2, ...)λ₯Ό (cls, xywh)둜 λ³€ν™˜ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
segments list

μ„Έκ·Έλ¨ΌνŠΈ λͺ©λ‘, 각 μ„Έκ·Έλ¨ΌνŠΈλŠ” 점 λͺ©λ‘, 각 점은 x, y μ’Œν‘œ λͺ©λ‘μž…λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
ndarray

λ°”μš΄λ”© λ°•μŠ€μ˜ κ°€λ‘œ μ„Έλ‘œ μ’Œν‘œμž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def segments2boxes(segments):
    """
    It converts segment labels to box labels, i.e. (cls, xy1, xy2, ...) to (cls, xywh)

    Args:
        segments (list): list of segments, each segment is a list of points, each point is a list of x, y coordinates

    Returns:
        (np.ndarray): the xywh coordinates of the bounding boxes.
    """
    boxes = []
    for s in segments:
        x, y = s.T  # segment xy
        boxes.append([x.min(), y.min(), x.max(), y.max()])  # cls, xyxy
    return xyxy2xywh(np.array(boxes))  # cls, xywh



ultralytics.utils.ops.resample_segments(segments, n=1000)

μ„Έκ·Έλ¨ΌνŠΈ λͺ©λ‘(n,2)을 μž…λ ₯ν•˜κ³  각각 n개의 포인트둜 μ—…μƒ˜ν”Œλ§λœ μ„Έκ·Έλ¨ΌνŠΈ λͺ©λ‘(n,2)을 λ°˜ν™˜ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
segments list

(n,2) λ°°μ—΄μ˜ λͺ©λ‘μœΌλ‘œ, μ—¬κΈ°μ„œ n은 μ„Έκ·Έλ¨ΌνŠΈμ˜ 점 μˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜
n int

μ„Έκ·Έλ¨ΌνŠΈλ₯Ό λ¦¬μƒ˜ν”Œλ§ν•  포인트 μˆ˜μž…λ‹ˆλ‹€. 기본값은 1000μž…λ‹ˆλ‹€.

1000

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
segments list

λ¦¬μƒ˜ν”Œλ§λœ μ„Έκ·Έλ¨ΌνŠΈμž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def resample_segments(segments, n=1000):
    """
    Inputs a list of segments (n,2) and returns a list of segments (n,2) up-sampled to n points each.

    Args:
        segments (list): a list of (n,2) arrays, where n is the number of points in the segment.
        n (int): number of points to resample the segment to. Defaults to 1000

    Returns:
        segments (list): the resampled segments.
    """
    for i, s in enumerate(segments):
        s = np.concatenate((s, s[0:1, :]), axis=0)
        x = np.linspace(0, len(s) - 1, n)
        xp = np.arange(len(s))
        segments[i] = (
            np.concatenate([np.interp(x, xp, s[:, i]) for i in range(2)], dtype=np.float32).reshape(2, -1).T
        )  # segment xy
    return segments



ultralytics.utils.ops.crop_mask(masks, boxes)

이 ν•¨μˆ˜λŠ” λ§ˆμŠ€ν¬μ™€ λ°”μš΄λ”© λ°•μŠ€λ₯Ό λ°›μ•„ λ°”μš΄λ”© λ°•μŠ€λ‘œ 잘린 마슀크λ₯Ό λ°˜ν™˜ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
masks Tensor

[n, h, w] tensor 마슀크 수

ν•„μˆ˜
boxes Tensor

μƒλŒ€μ  ν˜•μ‹μ˜ Bλ°•μŠ€ μ’Œν‘œ [n, 4] tensor

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
Tensor

λ§ˆμŠ€ν¬κ°€ 경계 μƒμžλ‘œ 잘리고 μžˆμŠ΅λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def crop_mask(masks, boxes):
    """
    It takes a mask and a bounding box, and returns a mask that is cropped to the bounding box.

    Args:
        masks (torch.Tensor): [n, h, w] tensor of masks
        boxes (torch.Tensor): [n, 4] tensor of bbox coordinates in relative point form

    Returns:
        (torch.Tensor): The masks are being cropped to the bounding box.
    """
    n, h, w = masks.shape
    x1, y1, x2, y2 = torch.chunk(boxes[:, :, None], 4, 1)  # x1 shape(n,1,1)
    r = torch.arange(w, device=masks.device, dtype=x1.dtype)[None, None, :]  # rows shape(1,1,w)
    c = torch.arange(h, device=masks.device, dtype=x1.dtype)[None, :, None]  # cols shape(1,h,1)

    return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))



ultralytics.utils.ops.process_mask_upsample(protos, masks_in, bboxes, shape)

마슀크 ν—€λ“œμ˜ 좜λ ₯을 λ°›μ•„ λ°”μš΄λ”© λ°•μŠ€μ— 마슀크λ₯Ό μ μš©ν•©λ‹ˆλ‹€. 더 높은 ν’ˆμ§ˆμ˜ 마슀크λ₯Ό μƒμ„±ν•˜μ§€λ§Œ 마슀크λ₯Ό μƒμ„±ν•˜μ§€λ§Œ 속도가 λŠλ¦½λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
protos Tensor

[마슀크_딀, 마슀크_H, 마슀크_W]

ν•„μˆ˜
masks_in Tensor

[n, mask_dim], n은 nms μ΄ν›„μ˜ 마슀크 μˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜
bboxes Tensor

[n, 4], n은 nms μ΄ν›„μ˜ 마슀크 μˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜
shape tuple

μž…λ ₯ μ΄λ―Έμ§€μ˜ 크기(H, W)

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
Tensor

μ—…μƒ˜ν”Œλ§λœ λ§ˆμŠ€ν¬μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def process_mask_upsample(protos, masks_in, bboxes, shape):
    """
    Takes the output of the mask head, and applies the mask to the bounding boxes. This produces masks of higher quality
    but is slower.

    Args:
        protos (torch.Tensor): [mask_dim, mask_h, mask_w]
        masks_in (torch.Tensor): [n, mask_dim], n is number of masks after nms
        bboxes (torch.Tensor): [n, 4], n is number of masks after nms
        shape (tuple): the size of the input image (h,w)

    Returns:
        (torch.Tensor): The upsampled masks.
    """
    c, mh, mw = protos.shape  # CHW
    masks = (masks_in @ protos.float().view(c, -1)).sigmoid().view(-1, mh, mw)
    masks = F.interpolate(masks[None], shape, mode="bilinear", align_corners=False)[0]  # CHW
    masks = crop_mask(masks, bboxes)  # CHW
    return masks.gt_(0.5)



ultralytics.utils.ops.process_mask(protos, masks_in, bboxes, shape, upsample=False)

마슀크 ν—€λ“œμ˜ 좜λ ₯을 μ‚¬μš©ν•˜μ—¬ λ°”μš΄λ”© λ°•μŠ€μ— 마슀크λ₯Ό μ μš©ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
protos Tensor

λͺ¨μ–‘ [mask_dim, mask_h, mask_w]의 tensor .

ν•„μˆ˜
masks_in Tensor

λͺ¨μ–‘ [n, 마슀크_딀]의 tensor , μ—¬κΈ°μ„œ n은 NMS μ΄ν›„μ˜ 마슀크 μˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜
bboxes Tensor

n, 4] λͺ¨μ–‘μ˜ tensor , μ—¬κΈ°μ„œ n은 NMS μ΄ν›„μ˜ 마슀크 μˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜
shape tuple

μž…λ ₯ μ΄λ―Έμ§€μ˜ 크기λ₯Ό (h, w) ν˜•μ‹μœΌλ‘œ λ‚˜νƒ€λ‚΄λŠ” μ •μˆ˜μ˜ νŠœν”Œμž…λ‹ˆλ‹€.

ν•„μˆ˜
upsample bool

마슀크λ₯Ό 원본 이미지 크기둜 μ—…μƒ˜ν”Œλ§ν• μ§€ μ—¬λΆ€λ₯Ό λ‚˜νƒ€λ‚΄λŠ” ν”Œλž˜κ·Έμž…λ‹ˆλ‹€. 기본값은 Falseμž…λ‹ˆλ‹€.

False

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
Tensor

n, h, w] λͺ¨μ–‘μ˜ λ°”μ΄λ„ˆλ¦¬ 마슀크 tensor , μ—¬κΈ°μ„œ n은 NMS μ΄ν›„μ˜ 마슀크 개수이고, h와 w λŠ” μž…λ ₯ μ΄λ―Έμ§€μ˜ 높이와 λ„ˆλΉ„μž…λ‹ˆλ‹€. λ§ˆμŠ€ν¬λŠ” 경계 μƒμžμ— μ μš©λ©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def process_mask(protos, masks_in, bboxes, shape, upsample=False):
    """
    Apply masks to bounding boxes using the output of the mask head.

    Args:
        protos (torch.Tensor): A tensor of shape [mask_dim, mask_h, mask_w].
        masks_in (torch.Tensor): A tensor of shape [n, mask_dim], where n is the number of masks after NMS.
        bboxes (torch.Tensor): A tensor of shape [n, 4], where n is the number of masks after NMS.
        shape (tuple): A tuple of integers representing the size of the input image in the format (h, w).
        upsample (bool): A flag to indicate whether to upsample the mask to the original image size. Default is False.

    Returns:
        (torch.Tensor): A binary mask tensor of shape [n, h, w], where n is the number of masks after NMS, and h and w
            are the height and width of the input image. The mask is applied to the bounding boxes.
    """

    c, mh, mw = protos.shape  # CHW
    ih, iw = shape
    masks = (masks_in @ protos.float().view(c, -1)).sigmoid().view(-1, mh, mw)  # CHW

    downsampled_bboxes = bboxes.clone()
    downsampled_bboxes[:, 0] *= mw / iw
    downsampled_bboxes[:, 2] *= mw / iw
    downsampled_bboxes[:, 3] *= mh / ih
    downsampled_bboxes[:, 1] *= mh / ih

    masks = crop_mask(masks, downsampled_bboxes)  # CHW
    if upsample:
        masks = F.interpolate(masks[None], shape, mode="bilinear", align_corners=False)[0]  # CHW
    return masks.gt_(0.5)



ultralytics.utils.ops.process_mask_native(protos, masks_in, bboxes, shape)

마슀크 ν—€λ“œμ˜ 좜λ ₯을 κ°€μ Έμ™€μ„œ λ°”μš΄λ”© λ°•μŠ€λ‘œ μ—…μƒ˜ν”Œλ§ν•œ ν›„ μžλ¦…λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
protos Tensor

[마슀크_딀, 마슀크_H, 마슀크_W]

ν•„μˆ˜
masks_in Tensor

[n, mask_dim], n은 nms μ΄ν›„μ˜ 마슀크 μˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜
bboxes Tensor

[n, 4], n은 nms μ΄ν›„μ˜ 마슀크 μˆ˜μž…λ‹ˆλ‹€.

ν•„μˆ˜
shape tuple

μž…λ ₯ μ΄λ―Έμ§€μ˜ 크기(H, W)

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
masks Tensor

μΉ˜μˆ˜κ°€ [h, w, n]인 λ°˜ν™˜λœ λ§ˆμŠ€ν¬μž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def process_mask_native(protos, masks_in, bboxes, shape):
    """
    It takes the output of the mask head, and crops it after upsampling to the bounding boxes.

    Args:
        protos (torch.Tensor): [mask_dim, mask_h, mask_w]
        masks_in (torch.Tensor): [n, mask_dim], n is number of masks after nms
        bboxes (torch.Tensor): [n, 4], n is number of masks after nms
        shape (tuple): the size of the input image (h,w)

    Returns:
        masks (torch.Tensor): The returned masks with dimensions [h, w, n]
    """
    c, mh, mw = protos.shape  # CHW
    masks = (masks_in @ protos.float().view(c, -1)).sigmoid().view(-1, mh, mw)
    masks = scale_masks(masks[None], shape)[0]  # CHW
    masks = crop_mask(masks, bboxes)  # CHW
    return masks.gt_(0.5)



ultralytics.utils.ops.scale_masks(masks, shape, padding=True)

μ„Έκ·Έλ¨ΌνŠΈ 마슀크의 크기λ₯Ό λ‹€μ‹œ μ‘°μ •ν•˜μ—¬ λͺ¨μ–‘을 λ§Œλ“­λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
masks Tensor

(N, C, H, W).

ν•„μˆ˜
shape tuple

높이와 λ„ˆλΉ„.

ν•„μˆ˜
padding bool

True이면 μƒμžκ°€ yolo μŠ€νƒ€μΌλ‘œ λ³΄κ°•λœ 이미지λ₯Ό 기반으둜 ν•œλ‹€κ³  κ°€μ •ν•©λ‹ˆλ‹€. False이면 μ •κΈ°μ μœΌλ‘œ λ¦¬μŠ€μΌ€μΌλ§μ„ μˆ˜ν–‰ν•©λ‹ˆλ‹€.

True
의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def scale_masks(masks, shape, padding=True):
    """
    Rescale segment masks to shape.

    Args:
        masks (torch.Tensor): (N, C, H, W).
        shape (tuple): Height and width.
        padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular
            rescaling.
    """
    mh, mw = masks.shape[2:]
    gain = min(mh / shape[0], mw / shape[1])  # gain  = old / new
    pad = [mw - shape[1] * gain, mh - shape[0] * gain]  # wh padding
    if padding:
        pad[0] /= 2
        pad[1] /= 2
    top, left = (int(pad[1]), int(pad[0])) if padding else (0, 0)  # y, x
    bottom, right = (int(mh - pad[1]), int(mw - pad[0]))
    masks = masks[..., top:bottom, left:right]

    masks = F.interpolate(masks, shape, mode="bilinear", align_corners=False)  # NCHW
    return masks



ultralytics.utils.ops.scale_coords(img1_shape, coords, img0_shape, ratio_pad=None, normalize=False, padding=True)

μ„Έκ·Έλ¨ΌνŠΈ μ’Œν‘œ(xy)의 λ°°μœ¨μ„ img1_shapeμ—μ„œ img0_shape둜 μž¬μ‘°μ •ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
img1_shape tuple

μ’Œν‘œμ˜ μΆœμ²˜κ°€ λ˜λŠ” μ΄λ―Έμ§€μ˜ λͺ¨μ–‘μž…λ‹ˆλ‹€.

ν•„μˆ˜
coords Tensor

μ’Œν‘œλŠ” n,2의 λ°°μœ¨μ„ μ μš©ν•©λ‹ˆλ‹€.

ν•„μˆ˜
img0_shape tuple

μ„ΈλΆ„ν™”κ°€ 적용되고 μžˆλŠ” μ΄λ―Έμ§€μ˜ λͺ¨μ–‘μž…λ‹ˆλ‹€.

ν•„μˆ˜
ratio_pad tuple

이미지 크기와 νŒ¨λ”©λœ 이미지 크기의 λΉ„μœ¨μž…λ‹ˆλ‹€.

None
normalize bool

True이면 μ’Œν‘œκ°€ [0, 1] λ²”μœ„λ‘œ μ •κ·œν™”λ©λ‹ˆλ‹€. 기본값은 Falseμž…λ‹ˆλ‹€.

False
padding bool

True이면 μƒμžκ°€ yolo μŠ€νƒ€μΌλ‘œ λ³΄κ°•λœ 이미지λ₯Ό 기반으둜 ν•œλ‹€κ³  κ°€μ •ν•©λ‹ˆλ‹€. False이면 μ •κΈ°μ μœΌλ‘œ λ¦¬μŠ€μΌ€μΌλ§μ„ μˆ˜ν–‰ν•©λ‹ˆλ‹€.

True

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
coords Tensor

배율된 μ’Œν‘œμž…λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def scale_coords(img1_shape, coords, img0_shape, ratio_pad=None, normalize=False, padding=True):
    """
    Rescale segment coordinates (xy) from img1_shape to img0_shape.

    Args:
        img1_shape (tuple): The shape of the image that the coords are from.
        coords (torch.Tensor): the coords to be scaled of shape n,2.
        img0_shape (tuple): the shape of the image that the segmentation is being applied to.
        ratio_pad (tuple): the ratio of the image size to the padded image size.
        normalize (bool): If True, the coordinates will be normalized to the range [0, 1]. Defaults to False.
        padding (bool): If True, assuming the boxes is based on image augmented by yolo style. If False then do regular
            rescaling.

    Returns:
        coords (torch.Tensor): The scaled coordinates.
    """
    if ratio_pad is None:  # calculate from img0_shape
        gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])  # gain  = old / new
        pad = (img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2  # wh padding
    else:
        gain = ratio_pad[0][0]
        pad = ratio_pad[1]

    if padding:
        coords[..., 0] -= pad[0]  # x padding
        coords[..., 1] -= pad[1]  # y padding
    coords[..., 0] /= gain
    coords[..., 1] /= gain
    coords = clip_coords(coords, img0_shape)
    if normalize:
        coords[..., 0] /= img0_shape[1]  # width
        coords[..., 1] /= img0_shape[0]  # height
    return coords



ultralytics.utils.ops.regularize_rboxes(rboxes)

νšŒμ „λœ μƒμžλ₯Ό [0, pi/2] λ²”μœ„μ—μ„œ μ •κ·œν™”ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
rboxes Tensor

(N, 5), xywhr.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
Tensor

μ •κ·œν™”λœ μƒμž.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def regularize_rboxes(rboxes):
    """
    Regularize rotated boxes in range [0, pi/2].

    Args:
        rboxes (torch.Tensor): (N, 5), xywhr.

    Returns:
        (torch.Tensor): The regularized boxes.
    """
    x, y, w, h, t = rboxes.unbind(dim=-1)
    # Swap edge and angle if h >= w
    w_ = torch.where(w > h, w, h)
    h_ = torch.where(w > h, h, w)
    t = torch.where(w > h, t, t + math.pi / 2) % math.pi
    return torch.stack([x, y, w_, h_, t], dim=-1)  # regularized boxes



ultralytics.utils.ops.masks2segments(masks, strategy='largest')

이 ν•¨μˆ˜λŠ” 마슀크(n,h,w) λͺ©λ‘μ„ λ°›μ•„ μ„Έκ·Έλ¨ΌνŠΈ(n,xy) λͺ©λ‘μ„ λ°˜ν™˜ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
masks Tensor

λͺ¨λΈμ˜ 좜λ ₯은 tensor λͺ¨μ–‘(batch_size, 160, 160)μž…λ‹ˆλ‹€.

ν•„μˆ˜
strategy str

'concat' λ˜λŠ” 'μ΅œλŒ€'. 기본값은 κ°€μž₯ 큰 κ°’μž…λ‹ˆλ‹€.

'largest'

λ°˜ν™˜ν•©λ‹ˆλ‹€:

이름 μœ ν˜• μ„€λͺ…
segments List

μ„Έκ·Έλ¨ΌνŠΈ 마슀크 λͺ©λ‘

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def masks2segments(masks, strategy="largest"):
    """
    It takes a list of masks(n,h,w) and returns a list of segments(n,xy)

    Args:
        masks (torch.Tensor): the output of the model, which is a tensor of shape (batch_size, 160, 160)
        strategy (str): 'concat' or 'largest'. Defaults to largest

    Returns:
        segments (List): list of segment masks
    """
    segments = []
    for x in masks.int().cpu().numpy().astype("uint8"):
        c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0]
        if c:
            if strategy == "concat":  # concatenate all segments
                c = np.concatenate([x.reshape(-1, 2) for x in c])
            elif strategy == "largest":  # select largest segment
                c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
        else:
            c = np.zeros((0, 2))  # no segments found
        segments.append(c.astype("float32"))
    return segments



ultralytics.utils.ops.convert_torch2numpy_batch(batch)

FP32 torch ν…μ„œ(0.0-1.0) 배치λ₯Ό NumPy uint8 λ°°μ—΄(0-255)둜 λ³€ν™˜ν•˜κ³ , λ ˆμ΄μ•„μ›ƒμ„ BCHWμ—μ„œ BHWC둜 λ³€κ²½ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
batch Tensor

tensor λ„ν˜• 배치(배치, 채널, 높이, λ„ˆλΉ„)λ₯Ό μž…λ ₯ν•˜κ³  dtype torch.float32λ₯Ό μž…λ ₯ν•©λ‹ˆλ‹€.

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
ndarray

λͺ¨μ–‘(배치, 높이, λ„ˆλΉ„, 채널)의 NumPy λ°°μ—΄ λ°°μΉ˜μ™€ dtype uint8을 좜λ ₯ν•©λ‹ˆλ‹€.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def convert_torch2numpy_batch(batch: torch.Tensor) -> np.ndarray:
    """
    Convert a batch of FP32 torch tensors (0.0-1.0) to a NumPy uint8 array (0-255), changing from BCHW to BHWC layout.

    Args:
        batch (torch.Tensor): Input tensor batch of shape (Batch, Channels, Height, Width) and dtype torch.float32.

    Returns:
        (np.ndarray): Output NumPy array batch of shape (Batch, Height, Width, Channels) and dtype uint8.
    """
    return (batch.permute(0, 2, 3, 1).contiguous() * 255).clamp(0, 255).to(torch.uint8).cpu().numpy()



ultralytics.utils.ops.clean_str(s)

특수 문자λ₯Ό 밑쀄 _둜 λŒ€μ²΄ν•˜μ—¬ λ¬Έμžμ—΄μ„ μ •λ¦¬ν•©λ‹ˆλ‹€.

λ§€κ°œλ³€μˆ˜:

이름 μœ ν˜• μ„€λͺ… κΈ°λ³Έκ°’
s str

특수 문자λ₯Ό λŒ€μ²΄ν•΄μ•Ό ν•˜λŠ” λ¬Έμžμ—΄

ν•„μˆ˜

λ°˜ν™˜ν•©λ‹ˆλ‹€:

μœ ν˜• μ„€λͺ…
str

λ°‘μ€„λ‘œ λŒ€μ²΄λœ 특수 λ¬Έμžκ°€ ν¬ν•¨λœ λ¬Έμžμ—΄ _.

의 μ†ŒμŠ€ μ½”λ“œ ultralytics/utils/ops.py
def clean_str(s):
    """
    Cleans a string by replacing special characters with underscore _

    Args:
        s (str): a string needing special characters replaced

    Returns:
        (str): a string with special characters replaced by an underscore _
    """
    return re.sub(pattern="[|@#!‘·$€%&()=?ΒΏ^*;:,¨´><+]", repl="_", string=s)





생성 2023-11-12, μ—…λ°μ΄νŠΈ 2024-01-23
μž‘μ„±μž: μ›ƒλŠ”-큐 (1), κΈ€λ Œ-쑰처 (4)