detectron2.structures¶

class detectron2.structures.Boxes(tensor: torch.Tensor)¶

基类: object

该结构将一系列边界框存储为Nx4的torch.Tensor张量。它支持关于边界框的常见操作 (area, clip, nonempty等)，同时也具有类似张量的行为特性 (支持索引操作、to(device)、.device属性，以及遍历所有边界框)

tensor¶

Nx4的浮点矩阵。每行为(x1, y1, x2, y2)。

Type: torch.Tensor

__getitem__(item) → detectron2.structures.Boxes ¶

Parameters: item – 整数、切片或布尔张量
Returns: 边界框 – 通过索引创建一个新的 Boxes。

以下用法是被允许的：

new_boxes = boxes[3]: 返回一个Boxes，其中仅包含一个框。
new_boxes = boxes[2:10]: 返回boxes的一个切片。
new_boxes = boxes[vector]，其中vector是一个torch.BoolTensor张量，其length = len(boxes)。向量中的非零元素将被选中。

请注意，返回的Boxes可能与当前Boxes共享存储空间，这取决于Pytorch的索引语义。

__init__(tensor: torch.Tensor)¶

Parameters: tensor (Tensor[float]) - 一个Nx4矩阵。每行表示(x1, y1, x2, y2)。

__iter__()¶: 每次生成一个形状为(4,)的张量形式的边界框。

area() → torch.Tensor ¶

计算所有框的面积。

Returns: torch.Tensor – 一个包含每个框面积的向量。

classmethod cat(boxes_list: List[边界框]) → detectron2.structures.Boxes [源代码]¶

将一组Boxes连接成一个单独的Boxes

Parameters: boxes_list (list[Boxes]) –
Returns: Boxes - 拼接后的边界框

clip(box_size: Tuple[int, int]) → None ¶

通过将x坐标限制在[0, width]范围内，y坐标限制在[0, height]范围内，对边界框进行裁剪（原地操作）。

Parameters: box_size (height, width) – 裁剪框的尺寸。

clone() → detectron2.structures.Boxes ¶

克隆边界框。

Returns: 边界框

property device¶

get_centers() → torch.Tensor ¶

Returns: 框的中心点坐标以Nx2数组形式表示，格式为(x, y)。

inside_box(box_size: Tuple[int, int], boundary_threshold: int = 0) → torch.Tensor ¶

Parameters

box_size (height, width) – 参考框的尺寸。
boundary_threshold (int) - 超出参考框边界超过boundary_threshold值的框将被视为"外部"。

Returns

一个二进制向量，表示每个框是否位于参考框内。

nonempty(threshold: float = 0.0) → torch.Tensor ¶

查找非空框。如果一个框的任一边长不大于阈值，则认为该框为空。

Returns: Tensor – 一个二进制向量，表示每个框是否为空（False）或非空（True）。

scale(scale_x: float, scale_y: float) → None ¶: 使用水平和垂直缩放因子缩放框

to(device: torch.device)¶

class detectron2.structures.BoxMode(value)¶

基类: enum.IntEnum

表示边界框的不同方式的枚举。

XYXY_ABS = 0¶

XYWH_ABS = 1¶

XYXY_REL = 2¶

XYWH_REL = 3¶

XYWHA_ABS = 4¶

static convert(box: Union[List[float], Tuple[float, …], torch.Tensor, numpy.ndarray], from_mode: detectron2.structures.BoxMode, to_mode: detectron2.structures.BoxMode) → Union[List[float], Tuple[float, …], torch.Tensor, numpy.ndarray][源代码]¶

Parameters

box – 可以是k元组、k列表或Nxk数组/张量，其中k = 4或5
from_mode (BoxMode) –
to_mode (BoxMode) –

Returns

转换后的同类型框。

detectron2.structures.pairwise_iou(boxes1: detectron2.structures.Boxes, boxes2: detectron2.structures.Boxes) → torch.Tensor ¶

给定两个大小分别为N和M的边界框列表，计算所有N x M对边界框之间的IoU（交并比）。边界框的坐标顺序必须为(xmin, ymin, xmax, ymax)。

Parameters

boxes1 (Boxes) – 两个Boxes。分别包含N和M个boxes。
boxes2 (Boxes) – 两个Boxes。分别包含N和M个boxes。

Returns

张量 – IoU，尺寸为[N,M]。

detectron2.structures.pairwise_ioa(boxes1: detectron2.structures.Boxes, boxes2: detectron2.structures.Boxes) → torch.Tensor ¶

类似于 pariwise_iou()，但计算的是IoA（boxes2区域上的交集比例）。

Parameters

boxes1 (Boxes) – 两个Boxes。分别包含N和M个boxes。
boxes2 (Boxes) – 两个Boxes。分别包含N和M个boxes。

Returns

张量 – IoA，尺寸为[N,M]。

detectron2.structures.pairwise_point_box_distance(points: torch.Tensor, boxes: detectron2.structures.Boxes)¶

N个点与M个边界框之间的成对距离。点与边界框的距离由该点到边界框4条边的距离表示。当点位于边界框内部时，所有距离均为正值。

Parameters

points – Nx2坐标点。每行为(x, y)
boxes – M个边界框

Returns

张量 –

大小为(N, M, 4)的距离值。这4个值分别表示从: 点到框体左侧、顶部、右侧和底部的距离。

class detectron2.structures.ImageList(tensor: torch.Tensor, image_sizes: List[Tuple[int, int]])¶

基类: object

一种数据结构，用于将可能尺寸不同的图像列表保存为单一张量。其工作原理是将图像填充至相同尺寸。每张图像的原始尺寸存储在image_sizes中。

image_sizes¶

每个元组是 (h, w)。在跟踪过程中，它会变成 list[Tensor] 而不是元组。

Type: list[tuple[int, int]]

__getitem__(idx) → torch.Tensor ¶

以原始尺寸访问单张图像。

Parameters: idx – 整数或切片
Returns: 张量 - 形状为 (H, W) 或 (C_1, ..., C_K, H, W) 的图像，其中 K >= 1

__init__(tensor: torch.Tensor, image_sizes: List[Tuple[int, int]])¶

Parameters

tensor (Tensor) - 形状为 (N, H, W) 或 (N, C_1, ..., C_K, H, W) 其中 K >= 1
image_sizes (list[tuple[int, int]]) - 每个元组表示 (高度, 宽度)。由于填充的原因，它可以比 (H, W) 更小。

property device¶

static from_tensors(tensors: List[torch.Tensor], size_divisibility: int = 0, pad_value: float = 0.0, padding_constraints: Optional[Dict[str, int]] = None) → detectron2.structures.ImageList [源代码]¶

Parameters

tensors – 一个由torch.Tensor组成的元组或列表，每个张量的形状为(Hi, Wi)或(C_1, ..., C_K, Hi, Wi)，其中K >= 1。这些张量将使用pad_value填充至相同形状。
size_divisibility (int) - 如果size_divisibility > 0，则添加填充以确保公共高度和宽度能被size_divisibility整除。这取决于模型，许多模型需要能被32整除。
pad_value (float) – 填充值。
padding_constraints (可选[Dict]) - 如果提供，其格式应为 {"size_divisibility": int, "square_size": int}，其中size_divisibility会覆盖上述值（如果存在），而square_size表示当square_size > 0时的正方形填充尺寸。

Returns

一个 ImageList。

to(*args: Any, **kwargs: Any) → detectron2.structures.ImageList ¶

class detectron2.structures.Instances(image_size: Tuple[int, int], **kwargs: Any)¶

基类: object

该类表示图像中的实例列表。它将实例的属性（如边界框、掩码、标签、分数）存储为"字段"。所有字段必须具有相同的__len__，即实例数量。

该类的所有其他（非字段）属性被视为私有：它们必须以'_'开头，且用户不可修改。

一些基本用法：

设置/获取/检查字段：

instances.gt_boxes = Boxes(...)
print(instances.pred_masks)  # 形状为(N, H, W)的张量
print('gt_masks' in instances)

len(instances) 返回实例的数量
索引操作：instances[indices] 会对所有字段应用索引并返回一个新的Instances对象。通常，indices是一个整数索引向量，或者是长度为num_instances的二进制掩码
```
category_3_detections = instances[instances.pred_classes == 3]
confident_detections = instances[instances.scores > 0.9]
```

__getitem__(item: Union[int, slice, torch.BoolTensor]) → detectron2.structures.Instances ¶

Parameters: item - 一个类似索引的对象，将用于索引所有字段。
Returns: 如果item是字符串，则返回对应字段的数据。否则，返回一个Instances对象，其中所有字段都通过item索引。

__init__(image_size: Tuple[int, int], **kwargs: Any)¶

Parameters

image_size (height, width) - 图像的空间尺寸。
kwargs – 要添加到这个Instances实例的字段。

static cat(instance_lists: List[Instances]) → detectron2.structures.Instances [源代码]¶

Parameters: instance_lists (list[Instances]) –
Returns: Instances

get(name: str) → Any¶: 返回名为name的字段。

get_fields() → Dict[str, Any]¶

Returns: 字典 – 一个将名称（字符串）映射到字段数据的字典

修改返回的字典将修改此实例。

has(name: str) → bool ¶

Returns: bool - 名为name的字段是否存在。

property image_size¶: 返回值: 元组: 高度, 宽度

remove(name: str) → None ¶: 移除名为name的字段。

set(name: str, value: Any) → None ¶: 将名为name的字段设置为value。 value的长度必须等于实例数量，并且必须与该对象中其他现有字段保持一致。

to(*args: Any, **kwargs: Any) → detectron2.structures.Instances ¶

Returns: Instances - 所有字段都会调用to(device)方法，只要该字段具备此方法。

class detectron2.structures.Keypoints(keypoints: Union[torch.Tensor, numpy.ndarray, List[List[float]]])¶

基类: object

存储关键点标注数据。GT实例具有gt_keypoints属性，包含每个关键点的x,y坐标位置和可见性标志。该张量的形状为(N, K, 3)，其中N是实例数量，K是每个实例的关键点数量。

可见性标志遵循COCO格式，必须是以下三个整数之一：

v=0: 未标记（此时x=y=0）
v=1: 已标注但不可见
v=2: 已标记且可见

__getitem__(item: Union[int, slice, torch.BoolTensor]) → detectron2.structures.Keypoints ¶

通过索引此关键点创建一个新的关键点。

以下用法是被允许的：

new_kpts = kpts[3]: 返回一个Keypoints，其中仅包含一个实例。
new_kpts = kpts[2:10]: 返回关键点的切片。
new_kpts = kpts[vector]，其中vector是一个torch.ByteTensor张量，具有length = len(kpts)长度。向量中的非零元素将被选中。

请注意，返回的Keypoints可能与当前Keypoints共享存储空间，这取决于Pytorch的索引语义。

__init__(keypoints: Union[torch.Tensor, numpy.ndarray, List[List[float]]])¶

Parameters: 关键点 - 一个张量、numpy数组或列表，包含每个关键点的x、y坐标和可见性。形状应为(N, K, 3)，其中N是实例数量，K是每个实例的关键点数量。

static cat(keypoints_list: List[关键点]) → detectron2.structures.Keypoints [源代码]¶

将一组关键点连接成一个单独的关键点

Parameters: keypoints_list (list[Keypoints]) –
Returns: 关键点 – 连接后的关键点

property device¶

to(*args: Any, **kwargs: Any) → detectron2.structures.Keypoints ¶

to_heatmap(boxes: torch.Tensor, heatmap_size: int) → torch.Tensor ¶

将关键点标注转换为用于训练的单热标签热图，如Mask R-CNN中所述。

Parameters

boxes – Nx4张量，用于绘制关键点的边界框

Returns

heatmaps – 形状为(N, K)的张量，每个元素表示输入中每个关键点的整数空间标签: 取值范围为[0, heatmap_size**2 - 1]。
valid:: 形状为(N, K)的张量，表示每个关键点是否在感兴趣区域内。

detectron2.structures.heatmaps_to_keypoints(maps: torch.Tensor, rois: torch.Tensor) → torch.Tensor ¶

从热图中提取预测的关键点位置。

Parameters

maps (Tensor) – (#ROIs, #keypoints, POOL_H, POOL_W)。预测的每个ROI和每个关键点的logits热图。
rois (Tensor) - (#ROIs, 4)。每个ROI的边界框。

Returns

形状为(#ROIs, #关键点, 4)的张量，最后一个维度对应每个关键点的(x, y, logit, 分数)。

在将NxN图像中的离散像素索引转换为连续关键点坐标时，我们通过使用Heckbert 1990提出的转换公式c = d + 0.5（其中d是离散坐标，c是连续坐标），保持与Keypoints.to_heatmap()的一致性。

class detectron2.structures.BitMasks(tensor: Union[torch.Tensor, numpy.ndarray])¶

基类: object

该类以位图形式存储一张图像中所有对象的分割掩码。

tensor¶: 布尔类型的N,H,W张量，表示图像中的N个实例。

__getitem__(item: Union[int, slice, torch.BoolTensor]) → detectron2.structures.BitMasks ¶

Returns: BitMasks – 通过索引创建一个新的 BitMasks。

以下用法是被允许的：

new_masks = masks[3]: 返回一个BitMasks，其中只包含一个掩码。
new_masks = masks[2:10]: 返回masks的一个切片。
new_masks = masks[vector]，其中vector是一个torch.BoolTensor张量，具有length = len(masks)长度。向量中的非零元素将被选中。

请注意，返回的对象可能与此对象共享存储空间，这取决于Pytorch的索引语义。

__init__(tensor: Union[torch.Tensor, numpy.ndarray])¶

Parameters: tensor – 一个N,H,W维度的布尔张量，表示图像中的N个实例。

static cat(bitmasks_list: List[BitMasks]) → detectron2.structures.BitMasks [源代码]¶

将一组BitMasks连接成一个单独的BitMasks

Parameters: bitmasks_list (list[BitMasks]) –
Returns: BitMasks – 拼接后的位掩码

crop_and_resize(boxes: torch.Tensor, mask_size: int) → torch.Tensor ¶

根据给定的边界框裁剪每个位掩码，并将结果调整为(mask_size, mask_size)大小。这可用于为Mask R-CNN准备训练目标。与多边形栅格化相比，该方法具有更小的重建误差。但我们观察到在准确度上没有差异，不过BitMasks需要更多内存来存储所有掩码。

Parameters

boxes (Tensor) – 存储每个掩码对应框的Nx4张量
mask_size (int) - 光栅化掩码的大小。

Returns

Tensor – 一个布尔类型的张量，形状为(N, mask_size, mask_size)，其中 N表示该图像预测框的数量。

property device¶

static from_polygon_masks(polygon_masks: Union[PolygonMasks, List[List[numpy.ndarray]]], height: int, width: int) → detectron2.structures.BitMasks [源代码]¶

Parameters

polygon_masks (list[list[ndarray]] 或 PolygonMasks) –
height (int) – 高度
width (int) –

static from_roi_masks(roi_masks: detectron2.structures.ROIMasks, height: int, width: int) → detectron2.structures.BitMasks [源代码]¶

Parameters

roi_masks –
height (int) – 高度
width (int) –

get_bounding_boxes() → detectron2.structures.Boxes ¶

Returns: 边界框 – 围绕位掩码的紧密外接矩形。如果掩码为空，其边界框将全为零。

nonempty() → torch.Tensor ¶

查找非空掩码。

Returns

张量 –

一个布尔张量，表示: 每个掩码是空(False)还是非空(True)。

to(*args: Any, **kwargs: Any) → detectron2.structures.BitMasks ¶

class detectron2.structures.PolygonMasks(polygons: List[List[Union[torch.Tensor, numpy.ndarray]]])¶

基类: object

该类以多边形形式存储一张图像中所有对象的分割掩码。

polygons¶: list[list[ndarray]]。每个ndarray是一个表示多边形的float64向量。

__getitem__(item: Union[int, slice, List[int], torch.BoolTensor]) → detectron2.structures.PolygonMasks ¶

支持对实例进行索引并返回一个PolygonMasks对象。 item可以是：

一个整数。它将返回一个仅包含单个实例的对象。
一个切片。它将返回一个包含所选实例的对象。
一个int类型的列表。它将返回一个包含所选实例的对象，对应于列表中的索引。
一个类型为BoolTensor的向量掩码，其长度为num_instances。它将返回一个包含非零掩码实例的对象。

__init__(polygons: List[List[Union[torch.Tensor, numpy.ndarray]]])¶

Parameters: polygons (list[list[np.ndarray]]) - 列表的第一层对应单个实例，第二层对应组成该实例的所有多边形，第三层对应多边形坐标。第三层数组的格式应为[x0, y0, x1, y1, ..., xn, yn] (n >= 3)。

__iter__() → Iterator[List[numpy.ndarray]]¶

Yields: list[ndarray] - 一个实例的多边形集合。每个张量都是一个表示多边形的float64向量。

area()¶

计算掩码的面积。仅适用于多边形，使用鞋带公式： https://stackoverflow.com/questions/24467972/calculate-area-of-polygon-given-x-y-coordinates

Returns: Tensor - 每个实例对应的向量区域

static cat(polymasks_list: List[PolygonMasks]) → detectron2.structures.PolygonMasks [源代码]¶

将多个PolygonMasks连接成一个单独的PolygonMasks

Parameters: polymasks_list (list[PolygonMasks]) –
Returns: PolygonMasks – 拼接后的PolygonMasks

crop_and_resize(boxes: torch.Tensor, mask_size: int) → torch.Tensor ¶

根据给定的边界框裁剪每个掩码，并将结果调整为(mask_size, mask_size)大小。这可用于为Mask R-CNN准备训练目标。

Parameters

boxes (Tensor) - 存储每个掩码对应框的Nx4张量
mask_size (int) - 光栅化掩码的大小。

Returns

Tensor - 一个形状为(N, mask_size, mask_size)的布尔张量，其中N表示该图像预测框的数量。

property device¶

get_bounding_boxes() → detectron2.structures.Boxes ¶

Returns: Boxes - 围绕多边形掩膜的紧密边界框。

nonempty() → torch.Tensor ¶

查找非空掩码。

Returns: Tensor – 一个布尔型张量，表示每个掩码是否为空（False表示空，True表示非空）。

to(*args: Any, **kwargs: Any) → detectron2.structures.PolygonMasks ¶

detectron2.structures.polygons_to_bitmask(polygons: List[numpy.ndarray], height: int, width: int) → numpy.ndarray ¶

Parameters

polygons (list[ndarray]) - 每个数组的形状为(Nx2,)
height (int) –
width (int) –

Returns

ndarray – 一个形状为(高度, 宽度)的布尔掩码

class detectron2.structures.ROIMasks(tensor: torch.Tensor)¶

基类: object

通过在一些ROI（感兴趣区域）中定义的N个较小掩码来表示掩码。一旦给出ROI框，可以通过将掩码“粘贴”到对应ROI框定义的区域来获得全图的位掩码。

__getitem__(item) → detectron2.structures.ROIMasks ¶

Returns: ROIMasks - 通过索引创建一个新的ROIMasks。

以下用法是被允许的：

new_masks = masks[2:10]: 返回masks的一个切片。
new_masks = masks[vector]，其中vector是一个torch.BoolTensor张量，具有length = len(masks)长度。向量中的非零元素将被选中。

请注意，返回的对象可能与此对象共享存储空间，这取决于Pytorch的索引语义。

__init__(tensor: torch.Tensor)¶

Parameters: tensor - 定义每个ROI内掩码的(N, M, M)维掩码张量。

property device¶

to(device: torch.device) → detectron2.structures.ROIMasks ¶

to_bitmasks(boxes: torch.Tensor, height, width, threshold=0.5)¶: 参数：参见 paste_masks_in_image() 的文档。

class detectron2.structures.RotatedBoxes(tensor: torch.Tensor)¶

基类: detectron2.structures.Boxes

该结构将旋转框列表存储为Nx5的torch.Tensor。它支持关于框的一些常用方法（area、clip、nonempty等），同时也具有类似Tensor的行为（支持索引、to(device)、.device以及对所有框进行迭代）。

__getitem__(item) → detectron2.structures.RotatedBoxes ¶

Returns: RotatedBoxes - 通过索引创建一个新的RotatedBoxes。

以下用法是被允许的：

new_boxes = boxes[3]: 返回一个RotatedBoxes，其中仅包含一个框。
new_boxes = boxes[2:10]: 返回boxes的一个切片。
new_boxes = boxes[vector]，其中vector是一个torch.ByteTensor，其length = len(boxes)。向量中的非零元素将被选中。

请注意，返回的RotatedBoxes可能与当前RotatedBoxes共享存储空间，这取决于Pytorch的索引语义。

__init__(tensor: torch.Tensor)¶

Parameters: tensor (Tensor[float]) – 一个Nx5矩阵。每行表示 (x中心点, y中心点, 宽度, 高度, 角度)，其中角度以度为单位表示。虽然没有严格的取值范围限制，但建议的主要范围在[-180, 180)度之间。

假设我们有一个水平框 B = (x_center, y_center, width, height)，其中 width 沿 x 轴方向，height 沿 y 轴方向。旋转框 B_rot (x_center, y_center, width, height, angle) 可以理解为：

当 angle == 0 时： B_rot == B
当角度 > 0时： B_rot是通过将B绕其中心逆时针旋转\(|angle|\)度得到的；
当角度 < 0 时： B_rot 是通过将 B 绕其中心顺时针旋转 \(|angle|\) 度得到的。

从数学角度来看，由于图像空间采用的是右手坐标系(y, x)，其中y轴方向为从上到下，x轴方向为从左到右，因此旋转矩形的4个顶点\((yr_i, xr_i)\)（i = 1, 2, 3, 4）可以通过以下方式从水平矩形顶点\((y_i, x_i)\)（i = 1, 2, 3, 4）计算得出（其中\(\theta = angle*\pi/180\)表示以弧度为单位的角度，\((y_c, x_c)\)为矩形中心点）：

\[ \begin{align}\begin{aligned}yr_i = \cos(\theta) (y_i - y_c) - \sin(\theta) (x_i - x_c) + y_c,\\xr_i = \sin(\theta) (y_i - y_c) + \cos(\theta) (x_i - x_c) + x_c,\end{aligned}\end{align} \]

这是标准的刚体旋转变换。

直观地说，这个角度是： (1) 在图像空间中从y轴到包围框高度向量（在框的局部坐标系中从上到下）的逆时针旋转角度； (2) 在图像空间中从x轴到包围框宽度向量（在框的局部坐标系中从左到右）的逆时针旋转角度。

更直观地说，考虑以下用(x1, y1, x2, y2)表示的横向矩形框ABCD：(3, 2, 7, 4)，它覆盖了连续坐标系中[3,7] x [2,4]的区域，看起来像这样：

O--------> x
|
|  A---B
|  |   |
|  D---C
|
v y

请注意，这里每个大写字母代表一个0维几何点，而非“方形像素”。

在上面的示例中，使用(x, y)表示一个点，我们有：

\[O = (0, 0), A = (3, 2), B = (7, 2), C = (7, 4), D = (3, 4)\]

我们将向量AB = 向量DC命名为盒子局部坐标系中的宽度向量，将向量AD = 向量BC命名为盒子局部坐标系中的高度向量。最初当角度为0度时，它们分别与图像空间中x轴和y轴的正方向对齐。

为了更好地说明，我们将框的中心表示为E，

O--------> x
|
|  A---B
|  | E |
|  D---C
|
v y

其中中心点 E = ((3+7)/2, (2+4)/2) = (5, 3)。

此外，

\[宽度 = |AB| = |CD| = 7 - 3 = 4, 高度 = |AD| = |BC| = 4 - 2 = 2.\]

因此，相同形状在旋转框中的对应表示采用(x_center, y_center, width, height, angle)格式为：

(5, 3, 4, 2, 0),

现在，让我们考虑(5, 3, 4, 2, 90)，根据定义这是逆时针旋转90度的结果。它看起来像这样：

O--------> x
|   B-C
|   | |
|   |E|
|   | |
|   A-D
v y

中心点E仍位于相同位置(5, 3)，而顶点ABCD相对于E逆时针旋转了90度： A = (4, 5), B = (4, 1), C = (6, 1), D = (6, 5)

这里，90度可以视为从y轴旋转到向量AD或向量BC（在框的局部坐标系中从上到下的高度向量）的逆时针角度，或者从x轴旋转到向量AB或向量DC（在框的局部坐标系中从左到右的宽度向量）的逆时针角度。

\[宽度 = |AB| = |CD| = 5 - 1 = 4, 高度 = |AD| = |BC| = 6 - 4 = 2.\]

接下来，以(5, 3, 4, 2, -90)为例，根据定义它顺时针旋转了90度（CW），看起来是这样的：

O--------> x
|   D-A
|   | |
|   |E|
|   | |
|   C-B
v y

中心点E仍位于同一位置(5, 3)，而顶点ABCD相对于E顺时针旋转了90度： A = (6, 1), B = (6, 5), C = (4, 5), D = (4, 1)

\[width = |AB| = |CD| = 5 - 1 = 4, height = |AD| = |BC| = 6 - 4 = 2.\]

这与(5, 3, 4, 2, 90)覆盖的区域完全相同，它们的IoU将为1。然而，这两个区域会生成不同的RoI池化结果，不应被视为相同的边界框。

另一方面，很容易看出 (X, Y, W, H, A) 与 (X, Y, W, H, A+360N) 是相同的，其中 N 为任意整数。例如 (5, 3, 4, 2, 270) 将与 (5, 3, 4, 2, -90) 相同，因为将形状逆时针旋转270度等同于将该形状顺时针旋转90度。

我们可以进一步旋转得到(5, 3, 4, 2, 180)，或者(5, 3, 4, 2, -180):

O--------> x
|
|  C---D
|  | E |
|  B---A
|
v y

\[ \begin{align}\begin{aligned}A = (7, 4), B = (3, 4), C = (3, 2), D = (7, 2),\\宽度 = |AB| = |CD| = 7 - 3 = 4, 高度 = |AD| = |BC| = 4 - 2 = 2.\end{aligned}\end{align} \]

最后，这是一个非常不精确（高度量化）的图示，展示了(5, 3, 4, 2, 60)的样子，以防有人好奇：

O--------> x
|     B            |    /  C
|   /E /
|  A  /
|   `D
v y

它仍然是一个中心点为(5, 3)、宽度为4、高度为2的矩形，但其角度（以及方向）介于 (5, 3, 4, 2, 0)和(5, 3, 4, 2, 90)之间。

__iter__()¶: 每次生成一个形状为(5,)的张量形式的边界框。

area() → torch.Tensor ¶

计算所有框的面积。

Returns: torch.Tensor – 一个包含每个框面积的向量。

classmethod cat(boxes_list: List[RotatedBoxes]) → detectron2.structures.RotatedBoxes [源代码]¶

将一组RotatedBoxes连接成一个单独的RotatedBoxes

Parameters: boxes_list (list[RotatedBoxes]) –
Returns: RotatedBoxes - 拼接后的旋转边界框

clip(box_size: Tuple[int, int], clip_angle_threshold: float = 1.0) → None ¶

通过将x坐标限制在[0, width]范围内，y坐标限制在[0, height]范围内，对边界框进行裁剪（原地操作）。

对于RRPN：仅裁剪那些几乎水平且角度容差在clip_angle_threshold范围内的边界框，以保持向后兼容性。

超过此阈值的旋转框不会被裁剪，原因有二：

存在多种可能的方法来裁剪旋转框，使其适应图像边界。
要让整个矩形框完全适配图像范围，同时又不遗漏关键像素区域，这相当具有挑战性。

因此我们依赖像RoIAlignRotated这样的操作来安全处理这种情况。

Parameters

box_size (height, width) - 裁剪框的尺寸。
clip_angle_threshold – 当且仅当 abs(normalized(angle)) <= clip_angle_threshold (以度为单位)时，我们将裁剪为水平框。

clone() → detectron2.structures.RotatedBoxes ¶

克隆旋转框(RotatedBoxes)。

Returns: RotatedBoxes

property device¶

get_centers() → torch.Tensor ¶

Returns: 框的中心点坐标以Nx2数组形式表示，格式为(x, y)。

inside_box(box_size: Tuple[int, int], boundary_threshold: int = 0) → torch.Tensor ¶

Parameters

box_size (height, width) - 参考框的大小，覆盖范围是 [0, width] x [0, height]
boundary_threshold (int) - 超出参考框边界超过boundary_threshold值的框将被视为"外部"。

对于RRPN来说，可能不需要调用此函数，因为旋转框超出图像边界是常见情况（clip函数仅会裁剪接近水平的框）

Returns: 一个二进制向量，表示每个框是否位于参考框内。

nonempty(threshold: float = 0.0) → torch.Tensor ¶

查找非空框。如果一个框的任一边长不大于阈值，则认为该框为空。

Returns: Tensor - 一个二进制向量，用于表示每个框是空（False）还是非空（True）。

normalize_angles() → None ¶: 将角度限制在[-180, 180)度的范围内

scale(scale_x: float, scale_y: float) → None ¶: 使用水平和垂直缩放因子缩放旋转后的矩形框注意：当scale_factor_x != scale_factor_y时，在调整大小变换下，如果角度不是90度的倍数，旋转后的矩形框将无法保持矩形形状。此时形状会变为平行四边形（带有倾斜）。这里我们通过将旋转矩形拟合到平行四边形上来进行近似处理。

to(device: torch.device)¶

detectron2.structures.pairwise_iou_rotated(boxes1: detectron2.structures.RotatedBoxes, boxes2: detectron2.structures.RotatedBoxes) → None ¶

给定两个旋转框列表，大小分别为N和M，计算所有N x M对框之间的IoU（交并比）。框的顺序必须为（x中心，y中心，宽度，高度，角度）。

Parameters

boxes1 (RotatedBoxes) – 两个RotatedBoxes。分别包含N和M个旋转框。
boxes2 (RotatedBoxes) – 两个RotatedBoxes。分别包含N和M个旋转框。

Returns

张量 – IoU，尺寸为[N,M]。