सामग्री पर जाएं

के लिए संदर्भ ultralytics/utils/ops.py

नोट

यह फ़ाइल यहाँ उपलब्ध है https://github.com/ultralytics/ultralytics/बूँद/मुख्य/ultralytics/utils/ops.py का उपयोग करें। यदि आप कोई समस्या देखते हैं तो कृपया पुल अनुरोध का योगदान करके इसे ठीक करने में मदद करें 🛠️। 🙏 धन्यवाद !



ultralytics.utils.ops.Profile

का रूप: ContextDecorator

YOLOv8 प्रोफ़ाइल वर्ग। @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
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 424344454647 4849505152 53 54 555657585960 616263
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

मॉडल अनुमान के लिए उपयोग किए जाने वाले उपकरण। कोई नहीं (सीपीयू) के लिए डिफ़ॉल्ट।

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

सेगमेंट का न्यूनतम और अधिकतम x और y मान।

में स्रोत कोड ultralytics/utils/ops.py
66 67 68 69 70 71 72 73 74 75 76 7778798081 82 83 8485 86
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 के प्रारूप में) को उस छवि के आकार से रीस्केल करता है जो वे मूल रूप से थे एक अलग छवि (img0_shape) के आकार के लिए (img1_shape) में निर्दिष्ट।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
img1_shape tuple

छवि का आकार जिसके लिए बाउंडिंग बॉक्स (ऊंचाई, चौड़ाई) के प्रारूप में हैं।

आवश्यक
boxes Tensor

छवि में वस्तुओं के बाउंडिंग बॉक्स, (x1, y1, x2, y2) के प्रारूप में

आवश्यक
img0_shape tuple

लक्ष्य छवि का आकार, (ऊंचाई, चौड़ाई) के प्रारूप में।

आवश्यक
ratio_pad tuple

बक्से को स्केल करने के लिए (अनुपात, पैड) का एक टुपल। यदि प्रदान नहीं किया गया है, तो अनुपात और पैड क्या होगा? दो छवियों के बीच आकार अंतर के आधार पर गणना की जाती है।

None
padding bool

यदि सही है, तो यह मानते हुए कि बॉक्स द्वारा संवर्धित छवि पर आधारित है yolo वर्तिका। अगर गलत है तो नियमित करें पुनः स्केलिंग।

True
xywh bool

बॉक्स प्रारूप xywh है या नहीं, डिफ़ॉल्ट = गलत।

False

देता:

नाम प्रकार विवरण: __________
boxes Tensor

स्केल किए गए बाउंडिंग बॉक्स, (x1, y1, x2, y2) के प्रारूप में

में स्रोत कोड ultralytics/utils/ops.py
 89 90 91 92 93 94 95 96 97 98  99 100 101 102 103 104 105 106 107  108 109 110 111 112  113 114 115 116 117 118119 120   121 122 123 124
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
127 128 129 130 131 132 133 134 135 136 137 138139140
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)

ओब्स के लिए एनएमएस, प्रोबियू और फास्ट-एनएमएस द्वारा संचालित।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
boxes Tensor

(एन, 5), xywhr।

आवश्यक
scores Tensor

(एन,)।

आवश्यक
threshold float

Iou दहलीज।

0.45

देता:

में स्रोत कोड ultralytics/utils/ops.py
143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158159 160
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)

बक्से के एक सेट पर गैर-अधिकतम दमन (एनएमएस) करें, मास्क और प्रति बॉक्स कई लेबल के समर्थन के साथ।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
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

IoU थ्रेशोल्ड जिसके नीचे NMS के दौरान बॉक्स को फ़िल्टर किया जाएगा। मान्य मान 0.0 और 1.0 के बीच हैं.

0.45
classes List[int]

विचार करने के लिए वर्ग सूचकांकों की एक सूची। यदि कोई नहीं, तो सभी वर्गों पर विचार किया जाएगा।

None
agnostic bool

यदि सच है, तो मॉडल वर्गों की संख्या के लिए अज्ञेयवादी है, और सभी कक्षाओं को एक माना जाएगा।

False
multi_label bool

यदि सही है, तो प्रत्येक बॉक्स में कई लेबल हो सकते हैं।

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

सूचियों की एक सूची, जहां प्रत्येक आंतरिक सूची में किसी दिए गए छवि के लिए Apriori लेबल होते हैं। सूची प्रारूप में होनी चाहिए डेटालोडर द्वारा आउटपुट, प्रत्येक लेबल (class_index, x1, y1, x2, y2) का टपल होता है।

()
max_det int

एनएमएस के बाद रखने के लिए बक्से की अधिकतम संख्या।

300
nc int

मॉडल द्वारा आउटपुट कक्षाओं की संख्या। इसके बाद किसी भी सूचकांक को मास्क माना जाएगा।

0
max_time_img float

एक छवि को संसाधित करने के लिए अधिकतम समय (सेकंड)।

0.05
max_nms int

torchvision.ops.nms() में बक्से की अधिकतम संख्या।

30000
max_wh int

पिक्सेल में अधिकतम बॉक्स चौड़ाई और ऊंचाई।

7680
in_place bool

यदि सही है, तो इनपुट भविष्यवाणी tensor जगह में संशोधित किया जाएगा।

True

देता:

प्रकार विवरण: __________
List[Tensor]

लंबाई batch_size की एक सूची, जहां प्रत्येक तत्व एक tensor का आकृति (num_boxes, 6 + num_masks) जिसमें रखे गए बक्से हैं, कॉलम के साथ (x1, y1, x2, y2, आत्मविश्वास, वर्ग, मुखौटा 1, मास्क 2, ...)।

में स्रोत कोड 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
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320321 322 323 324
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
327 328 329 330 331 332 333 334 335 336 337 338339 340 341 342343 344
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

आकार बदलने और गद्देदार मास्क/छवियां, [एच, डब्ल्यू, न्यूम]/[एच, डब्ल्यू, 3]।

आवश्यक
im0_shape tuple

मूल छवि आकृति

आवश्यक
ratio_pad tuple

मूल छवि के लिए पैडिंग का अनुपात।

None

देता:

नाम प्रकार विवरण: __________
masks Tensor

जो मास्क लौटाए जा रहे हैं।

में स्रोत कोड ultralytics/utils/ops.py
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369370 371 372 373 374 375 376 377 378379
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, चौड़ाई, ऊंचाई) प्रारूप में कनवर्ट करें जहां (x1, y1) ऊपरी-बाएँ कोने और (x2, y2) निचले-दाएँ कोने हैं।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
x ndarray | Tensor

इनपुट बाउंडिंग बॉक्स (x1, y1, x2, y2) प्रारूप में समन्वय करता है।

आवश्यक

देता:

नाम प्रकार विवरण: __________
y ndarray | Tensor

बाउंडिंग बॉक्स (x, y, चौड़ाई, ऊंचाई) प्रारूप में समन्वय करता है।

में स्रोत कोड ultralytics/utils/ops.py
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
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) प्रारूप में कनवर्ट करें जहां (x1, y1) ऊपरी-बाएँ कोने और (x2, y2) निचले-दाएँ कोने हैं।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
x ndarray | Tensor

इनपुट बाउंडिंग बॉक्स (x, y, चौड़ाई, ऊंचाई) प्रारूप में समन्वय करता है।

आवश्यक

देता:

नाम प्रकार विवरण: __________
y ndarray | Tensor

बाउंडिंग बॉक्स (x1, y1, x2, y2) प्रारूप में निर्देशांक करता है।

में स्रोत कोड ultralytics/utils/ops.py
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418419 420421
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

देता: वाई (एनपी.नदररे | torch.Tensor): प्रारूप में बाउंडिंग बॉक्स के निर्देशांक [x1, y1, x2, y2] जहां X1, Y1 ऊपरी-बाएँ कोने है, x2, y2 बाउंडिंग बॉक्स का निचला-दायाँ कोना है।

में स्रोत कोड ultralytics/utils/ops.py
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442443444
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

यदि सही है, तो बॉक्स छवि सीमाओं पर क्लिप किए जाएंगे। डिफ़ॉल्ट से गलत

False
eps float

बॉक्स की चौड़ाई और ऊंचाई का न्यूनतम मान. 0.0 के लिए डिफ़ॉल्ट

0.0

देता:

नाम प्रकार विवरण: __________
y ndarray | Tensor

बाउंडिंग बॉक्स (x, y, चौड़ाई, ऊंचाई, सामान्यीकृत) प्रारूप में समन्वय करता है

में स्रोत कोड ultralytics/utils/ops.py
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
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
473 474 475 476 477 478479 480 481 482 483 484 485 486
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
489 490 491 492 493 494 495 496 497 498 499500 501502
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
505 506 507 508 509510 511 512 513 514 515 516517518
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

आकार के इनपुट कोने (एन, 8)।

आवश्यक

देता:

प्रकार विवरण: __________
ndarray | Tensor

आकार के [cx, cy, w, h, रोटेशन] प्रारूप (n, 5) में परिवर्तित डेटा।

में स्रोत कोड ultralytics/utils/ops.py
521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538539540 541 542 543 544545
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

आकार के [cx, cy, w, h, रोटेशन] प्रारूप (n, 5) या (b, n, 5) में बॉक्स।

आवश्यक

देता:

प्रकार विवरण: __________
ndarray | Tensor

आकृति के परिवर्तित कोने बिंदु (n, 4, 2) या (b, n, 4, 2)।

में स्रोत कोड ultralytics/utils/ops.py
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568569 570571572 573
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
576 577 578 579 580 581 582 583 584 585 586587588 589
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

खंडों की सूची, प्रत्येक खंड बिंदुओं की एक सूची है, प्रत्येक बिंदु एक्स, वाई निर्देशांक की एक सूची है

आवश्यक

देता:

प्रकार विवरण: __________
ndarray

XYWH बाउंडिंग बॉक्स का निर्देशांक करता है।

में स्रोत कोड ultralytics/utils/ops.py
592 593 594 595 596 597 598599 600 601 602603 604 605 606
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)

खंडों (एन, 2) की एक सूची इनपुट करता है और खंडों की एक सूची (एन, 2) देता है जो प्रत्येक को एन बिंदुओं पर नमूना देता है।

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
segments list

(एन, 2) सरणियों की एक सूची, जहां एन खंड में बिंदुओं की संख्या है।

आवश्यक
n int

सेगमेंट को फिर से नमूना देने के लिए अंकों की संख्या। 1000 के लिए डिफ़ॉल्ट

1000

देता:

नाम प्रकार विवरण: __________
segments list

पुन: नमूना खंड।

में स्रोत कोड ultralytics/utils/ops.py
609610 611 612 613 614 615 616 617 618619620 621 622 623 624 625 626627
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

[एन, एच, डब्ल्यू] tensor मास्क की संख्या

आवश्यक
boxes Tensor

[एन, 4] tensor bbox निर्देशांक का सापेक्ष बिंदु रूप में

आवश्यक

देता:

प्रकार विवरण: __________
Tensor

मास्क को बाउंडिंग बॉक्स में क्रॉप किया जा रहा है।

में स्रोत कोड ultralytics/utils/ops.py
630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645646
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

[mask_dim, mask_h, mask_w]

आवश्यक
masks_in Tensor

[एन, mask_dim], एन एनएमएस के बाद मास्क की संख्या है

आवश्यक
bboxes Tensor

[एन, 4], एन एनएमएस के बाद मास्क की संख्या है

आवश्यक
shape tuple

इनपुट छवि का आकार (H,W)

आवश्यक

देता:

प्रकार विवरण: __________
Tensor

ऊपर उठे हुए मुखौटे।

में स्रोत कोड ultralytics/utils/ops.py
649 650 651 652 653 654 655 656 657 658659 660 661 662 663 664 665 666 667
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

एक tensor आकार का [mask_dim, mask_h, mask_w]।

आवश्यक
masks_in Tensor

एक tensor आकार का [एन, mask_dim], जहां एनएमएस के बाद एन मास्क की संख्या है।

आवश्यक
bboxes Tensor

एक tensor आकार का [एन, 4], जहां एन एनएमएस के बाद मास्क की संख्या है।

आवश्यक
shape tuple

पूर्णांकों का एक टपल, जो प्रारूप में इनपुट छवि के आकार का प्रतिनिधित्व करता है (h, w).

आवश्यक
upsample bool

यह इंगित करने के लिए एक ध्वज कि क्या मुखौटा को मूल छवि आकार में अपसैम्पल करना है। डिफ़ॉल्ट ग़लत है.

False

देता:

प्रकार विवरण: __________
Tensor

एक बाइनरी मास्क tensor आकार का [एन, एच, डब्ल्यू], जहां एनएमएस के बाद एन मास्क की संख्या है, और एच और डब्ल्यू इनपुट छवि की ऊंचाई और चौड़ाई हैं। मास्क को बाउंडिंग बॉक्स पर लगाया जाता है।

में स्रोत कोड ultralytics/utils/ops.py
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691692 693 694 695 696 697 698 699
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

[mask_dim, mask_h, mask_w]

आवश्यक
masks_in Tensor

[एन, mask_dim], एन एनएमएस के बाद मास्क की संख्या है

आवश्यक
bboxes Tensor

[एन, 4], एन एनएमएस के बाद मास्क की संख्या है

आवश्यक
shape tuple

इनपुट छवि का आकार (H,W)

आवश्यक

देता:

नाम प्रकार विवरण: __________
masks Tensor

आयामों के साथ लौटे हुए मास्क [एच, डब्ल्यू, एन]

में स्रोत कोड ultralytics/utils/ops.py
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717718719
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

(एन, सी, एच, डब्ल्यू)।

आवश्यक
shape tuple

ऊंचाई और चौड़ाई।

आवश्यक
padding bool

यदि सही है, तो यह मानते हुए कि बॉक्स द्वारा संवर्धित छवि पर आधारित है yolo वर्तिका। अगर गलत है तो नियमित करें पुनः स्केलिंग।

True
में स्रोत कोड ultralytics/utils/ops.py
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738739 740 741 742 743
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

कॉर्ड को आकार एन, 2 के स्केल किया जाना है।

आवश्यक
img0_shape tuple

छवि का आकार जिस पर विभाजन लागू किया जा रहा है।

आवश्यक
ratio_pad tuple

छवि आकार का गद्देदार छवि आकार का अनुपात।

None
normalize bool

यदि सही है, तो निर्देशांक सीमा [0, 1] के लिए सामान्यीकृत किए जाएंगे। डिफ़ॉल्ट रूप से गलत है.

False
padding bool

यदि सही है, तो यह मानते हुए कि बॉक्स द्वारा संवर्धित छवि पर आधारित है yolo वर्तिका। अगर गलत है तो नियमित करें पुनः स्केलिंग।

True

देता:

नाम प्रकार विवरण: __________
coords Tensor

स्केल किए गए निर्देशांक।

में स्रोत कोड ultralytics/utils/ops.py
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
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

(एन, 5), xywhr।

आवश्यक

देता:

प्रकार विवरण: __________
Tensor

नियमित बक्से।

में स्रोत कोड ultralytics/utils/ops.py
781 782 783 784 785 786 787 788789790 791 792 793 794 795 796
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')

यह मास्क (एन, एच, डब्ल्यू) की एक सूची लेता है और खंडों की एक सूची देता है (एन, एक्सवाई)

पैरामीटर:

नाम प्रकार विवरण: __________ चूक
masks Tensor

मॉडल का आउटपुट, जो एक tensor आकार की (batch_size, 160, 160)

आवश्यक
strategy str

'कॉनकैट' या 'सबसे बड़ा'। सबसे बड़ा करने के लिए चूक

'largest'

देता:

नाम प्रकार विवरण: __________
segments List

सेगमेंट मास्क की सूची

में स्रोत कोड ultralytics/utils/ops.py
799 800 801 802 803 804 805 806 807 808809 810 811 812 813 814 815 816 817 818819820821
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
824 825 826 827 828 829830 831 832 833834
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
837 838 839 840 841 842 843 844 845 846847 
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)