ConvModule. Args: in_channels (List[int]): Number of input channels per scale. out_channels (int): Number of output channels (use

ReFPN. Args: in_channels (List[int]): Number of input channels per scale. out_channels (int): Number of output channels (used at

ReResNet backbone. Please refer to the `paper <https://arxiv.org/abs/1512.03385>`_ for details. Args: depth (int): Network depth

RotatedIoULoss. Computing the IoU loss between a set of predicted rbboxes and target rbboxes. Args: linear (bool): If True, use l

Gaussian based loss. Args: loss_type (str): Type of loss. representation (str, optional): Coordinate System. fun (str, o

Gaussian based loss. Args: loss_type (str): Type of loss. fun (str, optional): The function applied to distance. Def

Kalman filter based loss. Args: fun (str, optional): The function applied to distance. Defaults to 'log1p'. reduction

Multi-layer perceptron implemented with ConvModule

Initializes the Gaussian mixture model and brings all tensors into their required shape. Args: n_components (int): number of componen

Oriented 2-D convolution. Args: in_channels (List[int]): Number of input channels per scale. out_channels (int): Number of output

Fake rotate anchor generator for 2D anchor-based detectors. Horizontal bounding box represented by (x,y,w,h,theta).

Rotating invariant pooling module. Args: nInputPlane (int): The number of Input plane. nOrientation (int, optional): The number o

Align Conv of `S2ANet`. Args: in_channels (int): Number of input channels. featmap_strides (list): The strides of featmap.

The module of AlignConv. Args: in_channels (int): Number of input channels. featmap_strides (list): The strides of featmap.

Context Anchor Attention

Down sampling layer

Feature refine module for `R3Det`. Args: in_channels (int): Number of input channels. featmap_strides (list): The strides of feat

Global Sigmoid-Gated Linear Unit, reproduced from paper <SIMPLE CNN FOR VISION>

Bottleneck with Inception module

Image to Patch Embedding

Poly Kernel Inception Block

Poly Kernel Inception Stage

ResLayer to build ReResNet style backbone. Args: block (nn.Module): Residual block used to build ResLayer. num_blocks (int): Numb

Rotated Anchor-based head (RotatedRPN, RotatedRetinaNet, etc.). Args: num_classes (int): Number of categories excluding the background

Rotated RepPoints head for SASM. Args: num_classes (int): Number of classes. in_channels (int): Number of input channels.

Stem layer

Assign a corresponding gt bbox or background to each bbox. Each proposals will be assigned with `0` or a positive integer indicating the grou

Assign a corresponding gt bbox or background to each bbox. Each proposals will be assigned with `0` or a positive integer indicating the grou

BCConvex GIoU loss. Computing the BCConvex GIoU loss between a set of predicted convexes and target convexes. Args: reduction (s

The function of BCConvex GIoU loss.

BasicBlock for ReResNet. Args: in_channels (int): Input channels of this block. out_channels (int): Output channels of this block

Bottleneck block for ReResNet. Args: in_channels (int): Input channels of this block. out_channels (int): Output channels of this

Circular Smooth Label Coder. `Circular Smooth Label (CSL) <https://link.springer.com/chapter/10.1007/978-3-030-58598-3_40>`_ . Args:

Use `Circular Smooth Label (CSL) <https://link.springer.com/chapter/10.1007/978-3-030-58598-3_40>`_ . in `FCOS <https://arxiv.org/abs/1904.01

Rotational Anchor-based refine head. Args: use_encoded_angle (bool): Decide whether to use encoded angle or gt angle as targe

Assign a corresponding gt bbox or background to each bbox. Each proposals will be assigned with `0` or a positive integer indicating the groun

Convex GIoU loss. Computing the Convex GIoU loss between a set of predicted convexes and target convexes. Args: reduction (str,

The function of Convex GIoU loss.

DIOR dataset for detection. Args: ann_file (str): Annotation file path. pipeline (list[dict]): Processing pipeline. img_s

DOTA dataset for detection. Args: ann_file (str): Annotation file path. pipeline (list[dict]): Processing pipeline. versi

DOTA dataset for detection. Args: ann_file (str): Annotation file path. pipeline (list[dict]): Processing pipeline. versi

Delta XYWHA HBBox coder. this coder encodes bbox (x1, y1, x2, y2) into delta (dx, dy, dw, dh, da) and decodes delta (dx, dy, dw, dh, da) back

Delta XYWHA OBBox coder. This coder is used for rotated objects detection (for example on task1 of DOTA dataset). this coder encodes bbox (xc,

Distance Angle Point BBox coder. This coder encodes gt bboxes (x, y, w, h, angle) into (top, bottom, left, right, angle) and decode it back t

DOTA dataset for detection. Args: ann_file (str): Annotation file path. pipeline (list[dict]): Processing pipeline. versi

Gliding Vertex's RoI bbox head. Args: with_avg_pool (bool, optional): If True, use ``avg_pool``. num_shared_fcs (int, optional):

Gliding vertex fix coder. this coder encodes bbox (cx, cy, w, h, a) into delta (dt, dr, dd, dl) and decodes delta (dt, dr, dd, dl) back to or

Gliding vertex ratio coder. this coder encodes bbox (cx, cy, w, h, a) into delta (ratios). Args: angle_range (str, optional): Angle

Gliding vertex roi head including one bbox head.

Implementation of `Gliding Vertex on the Horizontal Bounding Box for Multi-Oriented Object Detection <https://arxiv.org/pdf/1911.09358.pdf>`_

HRSC dataset for detection. Args: ann_file (str): Annotation file path. pipeline (list[dict]): Processing pipeline. img_s

Rotated Anchor-based refine head for KFIoU. It's a part of the Oriented Detection Module (ODM), which produces orientation-sensitive features for

Rotated Anchor-based head for KFIoU. The difference from `RRetinaHead` is that its loss_bbox requires bbox_pred, bbox_targets, pred_decode and

Rotational Anchor-based refine head. The difference from `RRetinaRefineHead` is that its loss_bbox requires bbox_pred, bbox_targets, pred_deco

Kullback-Leibler Divergence loss for RepPoints. Args: eps (float): Defaults to 1e-6. reduction (str, optional): The reduction met

Load an patch from the huge image. Similar with :obj:`LoadImageFromFile`, but only reserve a patch of ``results['img']`` according to ``resul

MMRotate handler to load torchscript or eager mode [state_dict] models.

Assign a corresponding gt bbox or background to each bbox. Each proposals will be assigned with `-1`, or a semi-positive integer indicating th

Mid point offset coder. This coder encodes bbox (x1, y1, x2, y2) into \ delta (dx, dy, dw, dh, da, db) and decodes delta (dx, dy, dw, dh, da, db)

Rotated Anchor-based refine head. It's a part of the Oriented Detection Module (ODM), which produces orientation-sensitive features for classi

r"""Feature Pyramid Network. This is an implementation of paper `Feature Pyramid Networks for Object Detection <https://arxiv.org/abs/1612.03

Implementation of `Oriented R-CNN for Object Detection.`__ __ https://openaccess.thecvf.com/content/ICCV2021/papers/Xie_Oriented_R-CNN_for_Object

Oriented RPN head for Oriented R-CNN.

Oriented RepPoints head -<https://arxiv.org/pdf/2105.11111v4.pdf>. The head contains initial and refined stages based on RepPoints. The initial

Oriented RCNN roi head including one bbox head.

Poly Kernel Inception Network

Rotate img & bbox. Reference: https://github.com/hukaixuan19970627/OrientedRepPoints_DOTA Args: rotate_ratio (float, optional): The r

Non-Standard pseudo anchor generator that is used to generate valid flags only!

Rotated Refinement RetinaNet.

2D Overlaps (e.g. IoUs, GIoUs) Calculator.

Rotate Mosaic augmentation. Inherit from `mmdet.datasets.pipelines.transforms.Mosaic`. Given 4 images, mosaic transform combines them into

Random crop the image & bboxes. The absolute `crop_size` is sampled based on `crop_type` and `image_size`, then the cropped results are gener

Args: flip_ratio (float | list[float], optional): The flipping probability. Default: None. direction(str | list[str]

Random sampler. Args: num (int): Number of samples pos_fraction (float): Fraction of positive samples neg_pos_up (int, op

Resize images & rotated bbox Inherit Resize pipeline class to handle rotated bboxes. Args: img_scale (tuple or list[tuple]): Images s

Implementation of `ReDet: A Rotation-equivariant Detector for Aerial Object Detection.`__ __ https://openaccess.thecvf.com/content/CVPR2021/p

RoI Trans cascade roi head including one bbox head. Args: num_stages (int): number of cascade stages. stage_loss_weights (list[fl

Implementation of `Learning RoI Transformer for Oriented Object Detection in Aerial Images.`__ __ https://openaccess.thecvf.com/content_CVPR_

r"""An anchor-based head used in `ATSS <https://arxiv.org/abs/1912.02424>`_. The head contains two subnetworks. The first classifies anchor b

Rotated Anchor-free head (Rotated FCOS, etc.). Args: num_classes (int): Number of categories excluding the background categor

Simplest RoI head, with only two fc layers for classification and regression respectively. Args: with_avg_pool (bool, optional): If T

Base class for rotated detectors.

r"""More general bbox head, with shared conv and fc layers and two optional separated branches. .. code-block:: none

Implementation of Rotated `FCOS.`__ __ https://arxiv.org/abs/1904.01355

Anchor-free head used in `FCOS <https://arxiv.org/abs/1904.01355>`_. The FCOS head does not use anchor boxes. Instead bounding boxes are predi

Implementation of Rotated `Faster R-CNN.`__ __ https://arxiv.org/abs/1506.01497

KFIoU RoI head.

Rotated RPN head for rotated bboxes. Args: in_channels (int): Number of channels in the input feature map. init_cfg (dict or list