v-j0ddlmZddlZddlZddlmZddlmZddlZddl Z ddl Z ddl m Z ddlmZddlmZmZddlmZmZmZdd lmZdd lmZdd lmZdd lmZm Z m!Z!dd l"m#Z#m$Z$m%Z%dZ&dZ'GddZ(GddZ)Gdde(Z*Gdde*Z+Gdde*Z,Gdde*Z-Gdde(Z.Gdde(Z/Gd d!e(Z0Gd"d#e(Z1Gd$d%e*Z2Gd&d'e(Z3Gd(d)e(Z4Gd*d+e4Z5Gd,d-e(Z6Gd.d/e(Z7d\d]d7Z8d8e&e'd9dfd^dCZ9d8e&e'dddDdEddFdGdGd0dEd9fd_dUZ:GdVdWZ;GdXdYZ<GdZd[Z=dS)`) annotationsN)deepcopy)Any)Image) functional)polygons2maskspolygons2masks_overlap)LOGGERIterableSimpleNamespacecolorstr) check_version) Instances)bbox_ioa) segment2box xywh2xyxyxyxyxyxy2xywhr)TORCHVISION_0_10TORCHVISION_0_11TORCHVISION_0_13)rr)?rrc6eZdZdZdZdZddZddZddZdS) BaseTransformanBase class for image transformations in the Ultralytics library. This class provides a unified interface for applying transformations to images, object instances, and semantic segmentation masks. Subclasses should override `apply_image`, `apply_instances`, and/or `apply_semantic` for simple transforms, or override `__call__` directly for complex transforms that need shared state between image and annotation modifications. Methods: get_params: Compute transformation parameters shared across image, instances, and semantic mask. apply_image: Apply transformation to the image in labels['img']. apply_instances: Apply transformation to object instances in labels['instances']. apply_semantic: Apply transformation to semantic mask in labels['semantic_mask']. __call__: Orchestrate the transformation pipeline. c||}|||}|||}|||}|S)zApply transformation to labels dict. Args: labels (dict): Dictionary containing 'img', optionally 'instances' and 'semantic_mask'. Returns: (dict): Transformed labels dictionary. ) get_params apply_imageapply_instancesapply_semanticselflabelsparamss X/var/www/html/banglarbhumi/venv/lib/python3.11/site-packages/ultralytics/data/augment.py__call__zBaseTransform.__call__,sY((!!&&11%%ff55$$VV44 ciS)aCompute and return transformation parameters. This method allows sharing random state or computed matrices (e.g. affine matrix, flip decision) between image, instances, and semantic mask transformations. Args: labels (dict): Input labels dictionary. Returns: (dict): Parameters to pass to apply_image, apply_instances, and apply_semantic. )r r!s r#rzBaseTransform.get_params;s  r%Nc|S)zApply transformation to image. Args: labels (dict): Dictionary containing 'img'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels dictionary. r'rs r#rzBaseTransform.apply_imageI  r%c|S)zApply transformation to object instances. Args: labels (dict): Dictionary containing 'instances'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels dictionary. r'rs r#rzBaseTransform.apply_instancesUr)r%c|S)a Apply transformation to semantic segmentation mask. Args: labels (dict): Dictionary containing 'semantic_mask'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels dictionary. r'rs r#rzBaseTransform.apply_semanticar)r%N) __name__ __module__ __qualname____doc__r$rrrrr'r%r#rrsx                      r%rcFeZdZdZdZdZdZdZdd Zdd Z d Z dZ dS)ComposeaA class for composing multiple image transformations. Attributes: transforms (list[Callable]): A list of transformation functions to be applied sequentially. Methods: __call__: Apply a series of transformations to input data. append: Append a new transform to the existing list of transforms. insert: Insert a new transform at a specified index in the list of transforms. __getitem__: Retrieve a specific transform or a set of transforms using indexing. __setitem__: Set a specific transform or a set of transforms using indexing. tolist: Convert the list of transforms to a standard Python list. Examples: >>> transforms = [RandomFlip(), RandomPerspective(30)] >>> compose = Compose(transforms) >>> transformed_data = compose(data) >>> compose.append(CenterCrop((224, 224))) >>> compose.insert(0, RandomFlip()) cDt|tr|n|g|_dS)zInitialize the Compose object with a list of transforms. Args: transforms (list[Callable]): A list of callable transform objects to be applied sequentially. N) isinstancelist transforms)r r6s r#__init__zCompose.__init__s$ )3:t(D(DV**:,r%c0|jD] }||}|S)awApply a series of transformations to input data. This method sequentially applies each transformation in the Compose object's transforms to the input data. Args: data (Any): The input data to be transformed. This can be of any type, depending on the transformations in the list. Returns: (Any): The transformed data after applying all transformations in sequence. Examples: >>> transforms = [Transform1(), Transform2(), Transform3()] >>> compose = Compose(transforms) >>> transformed_data = compose(input_data) r6)r datats r#r$zCompose.__call__s)"  A1T77DD r%c:|j|dS)a2Append a new transform to the existing list of transforms. Args: transform (BaseTransform): The transformation to be added to the composition. Examples: >>> compose = Compose([RandomFlip(), RandomPerspective()]) >>> compose.append(RandomHSV()) N)r6append)r transforms r#r=zCompose.appends  y)))))r%c<|j||dS)aInsert a new transform at a specified index in the existing list of transforms. Args: index (int): The index at which to insert the new transform. transform (BaseTransform): The transform object to be inserted. Examples: >>> compose = Compose([Transform1(), Transform2()]) >>> compose.insert(1, Transform3()) >>> len(compose.transforms) 3 N)r6insert)r indexr>s r#r@zCompose.inserts" ui00000r%rA list | intreturnct|ttfsJdt|t|trt fd|Dn j|S)a Retrieve a specific transform or a set of transforms using indexing. Args: index (int | list[int]): Index or list of indices of the transforms to retrieve. Returns: (Compose | Any): A new Compose object if index is a list, or a single transform if index is an int. Raises: AssertionError: If the index is not of type int or list. Examples: >>> transforms = [RandomFlip(), RandomPerspective(10), RandomHSV(0.5, 0.5, 0.5)] >>> compose = Compose(transforms) >>> single_transform = compose[1] # Returns the RandomPerspective transform directly >>> multiple_transforms = compose[[0, 1]] # Returns a Compose object with RandomFlip and RandomPerspective 6The indices should be either list or int type but got c*g|]}j|Sr'r9.0ir s r# z'Compose.__getitem__..s :::q*:::r%)r4intr5typer2r6)r rAs` r# __getitem__zCompose.__getitem__s|$%#t--uu/uhlmrhshs/u/uuu-?I%QU?V?Vrw::::E:::;;;\`\klq\rrr%valueNonect|ttfsJdt|t|tr?t|ts*Jdt|dt|t|tr|g|g}}t ||D]J\}}|t |jks#Jd|dt |jd||j|<KdS)aSet one or more transforms in the composition using indexing. Args: index (int | list[int]): Index or list of indices to set transforms at. value (Any | list[Any]): Transform or list of transforms to set at the specified index(es). Raises: AssertionError: If index type is invalid, value type doesn't match index type, or index is out of range. Examples: >>> compose = Compose([Transform1(), Transform2(), Transform3()]) >>> compose[1] = NewTransform() # Replace second transform >>> compose[[0, 1]] = [NewTransform1(), NewTransform2()] # Replace first two transforms rEz7The indices should be the same type as values, but got z and z list index z out of range .N)r4rKr5rLziplenr6)r rArNrIvs r# __setitem__zCompose.__setitem__s,%#t--uu/uhlmrhshs/u/uuu- eT " " eT**  i$u++ii\`af\g\gii  * eS ! ! ,!7UG5Eu%% # #DAqs4?+++++-c1-c-cCPTP_L`L`-c-c-c+++!"DOA   # #r%c|jS)aConvert the list of transforms to a standard Python list. Returns: (list): A list containing all the transform objects in the Compose instance. Examples: >>> transforms = [RandomFlip(), RandomPerspective(10), CenterCrop()] >>> compose = Compose(transforms) >>> transform_list = compose.tolist() >>> print(len(transform_list)) 3 r9r s r#tolistzCompose.tolists r%cj|jjddd|jDdS)aReturn a string representation of the Compose object. Returns: (str): A string representation of the Compose object, including the list of transforms. Examples: >>> transforms = [RandomFlip(), RandomPerspective(degrees=10, translate=0.1, scale=0.1)] >>> compose = Compose(transforms) >>> print(compose) Compose([ RandomFlip(), RandomPerspective(degrees=10, translate=0.1, scale=0.1) ]) (, cg|]}|Sr'r')rHr;s r#rJz$Compose.__repr__.. s6W6W6W!!v6W6W6Wr%)) __class__r-joinr6rWs r#__repr__zCompose.__repr__s=.)[[DII6W6Wt6W6W6W,X,X[[[[r%N)rArBrCr2)rArBrNrBrCrO) r-r.r/r0r7r$r=r@rMrUrXr`r'r%r#r2r2ns*WWW* * * * 1 1 1ssss*####4   \\\\\r%r2cJeZdZdZd ddZdd Zdd Zd Zedd Z dS)BaseMixTransformaBase class for mix transformations like Cutmix, MixUp and Mosaic. This class provides a foundation for implementing mix transformations on datasets. It handles the probability-based application of transforms and manages the mixing of multiple images and labels. Attributes: dataset (Any): The dataset object containing images and labels. pre_transform (Callable | None): Optional transform to apply before mixing. p (float): Probability of applying the mix transformation. Methods: __call__: Apply the mix transformation to the input labels. get_params: Prepare mixed labels and update text labels. get_indexes: Abstract method to get indexes of images to be mixed. _update_label_text: Update label text for mixed images. Examples: >>> class CustomMixTransform(BaseMixTransform): ... def apply_image(self, labels, params=None): ... # Implement custom image mixing here ... return labels ... ... def get_indexes(self): ... return [random.randint(0, len(self.dataset) - 1) for _ in range(3)] >>> dataset = YourDataset() >>> transform = CustomMixTransform(dataset, p=0.5) >>> mixed_labels = transform(original_labels) NrrCrOc0||_||_||_dS)aInitialize the BaseMixTransform object for mix transformations like CutMix, MixUp and Mosaic. This class serves as a base for implementing mix transformations in image processing pipelines. Args: dataset (Any): The dataset object containing images and labels for mixing. pre_transform (Callable | None): Optional transform to apply before mixing. p (float): Probability of applying the mix transformation. Should be in the range [0.0, 1.0]. Ndataset pre_transformp)r rerfrgs r#r7zBaseMixTransform.__init__*s *r%r!dict[str, Any]c tjdd|jkr|S||}|||}|||}|||}|dd|S)aApply pre-processing transforms and cutmix/mixup/mosaic transforms to labels data. This method determines whether to apply the mix transform based on a probability factor. If applied, it selects additional images, applies pre-transforms if specified, and then performs the mix transform. Args: labels (dict[str, Any]): A dictionary containing label data for an image. Returns: (dict[str, Any]): The transformed labels dictionary, which may include mixed data from other images. Examples: >>> transform = BaseMixTransform(dataset, pre_transform=None, p=0.5) >>> result = transform({"image": img, "bboxes": boxes, "cls": classes}) r mix_labelsN)randomuniformrgrrrrpoprs r#r$zBaseMixTransform.__call__8s >!Q  $& ( (M((!!&&11%%ff55$$VV44 <&&& r%c}t|tr|g}fd|D}j-t |D]\}}|||<||d<|d|iS)a Prepare mixed labels and update text labels. Args: labels (dict[str, Any]): A dictionary containing label data for an image. Returns: (dict[str, Any]): Parameters for apply_image, apply_instances, and apply_semantic. cDg|]}j|Sr')reget_image_and_labelrGs r#rJz/BaseMixTransform.get_params..as)KKKadl66q99KKKr%Nrk) get_indexesr4rKrf enumerate_update_label_text)r r!indexesrkrIr:s` r#rzBaseMixTransform.get_paramsRs""$$ gs # # iGLKKK7KKK   )$Z00 9 94 $ 2 24 8 8 1 )| '''j))r%cVtjdt|jdz S)aGet a random index for mosaic augmentation. Returns: (int): A random index from the dataset. Examples: >>> transform = BaseMixTransform(dataset) >>> index = transform.get_indexes() >>> print(index) # 7 rrjrlrandintrSrerWs r#rrzBaseMixTransform.get_indexesls%~aT\!2!2Q!6777r%cd|vr|Sg|dd|dD}td|D}dt|D}|g|dzD]}t|ddD]>\}}|dt |}|t ||d|<?||d<|S)aUpdate label text and class IDs for mixed labels in image augmentation. This method processes the 'texts' and 'cls' fields of the input labels dictionary and any mixed labels, creating a unified set of text labels and updating class IDs accordingly. Args: labels (dict[str, Any]): A dictionary containing label information, including 'texts' and 'cls' fields, and optionally a 'mix_labels' field with additional label dictionaries. Returns: (dict[str, Any]): The updated labels dictionary with unified text labels and updated class IDs. Examples: >>> labels = { ... "texts": [["cat"], ["dog"]], ... "cls": torch.tensor([[0], [1]]), ... "mix_labels": [{"texts": [["bird"], ["fish"]], "cls": torch.tensor([[0], [1]])}], ... } >>> updated_labels = BaseMixTransform._update_label_text(labels) >>> print(updated_labels["texts"]) [['cat'], ['dog'], ['bird'], ['fish']] >>> print(updated_labels["cls"]) tensor([[0], [1]]) >>> print(updated_labels["mix_labels"][0]["cls"]) tensor([[2], [3]]) textsc30K|]}|dD]}|VdS)rzNr')rHxitems r# z6BaseMixTransform._update_label_text..s7(c(c!XYZaXb(c(cPT(c(c(c(c(c(c(cr%rkc,h|]}t|Sr')tuplerHr|s r# z6BaseMixTransform._update_label_text..s666q%((666r%ci|]\}}|| Sr'r')rHrItexts r# z7BaseMixTransform._update_label_text..s???wq$4???r%cls)r5rssqueezerXrKr)r! mix_textstext2idlabelrIrrs r#rtz#BaseMixTransform._update_label_textys< & MdfWod(c(cvl7K(c(c(cd 66I66677 ??)I*>*>???X| 44 ' 'E#E%L$8$8$<$<$C$C$E$EFF 7 73W~c#hh/")%++"6e Q&E'NN r%Nr)rCrOr!rhrCrh) r-r.r/r0r7r$rrr staticmethodrtr'r%r#rbrb s:     4****4 8 8 8)))\)))r%rbcxeZdZdZddfd Zd Zd fd Zd!d"dZd!d"dZd!d"dZ e d!d#dZ d$dZ xZ S)%MosaicaMosaic augmentation for image datasets. This class performs mosaic augmentation by combining multiple (4 or 9) images into a single mosaic image. The augmentation is applied to a dataset with a given probability. Attributes: dataset: The dataset on which the mosaic augmentation is applied. imgsz (int): Image size (height and width) after mosaic pipeline of a single image. p (float): Probability of applying the mosaic augmentation. Must be in the range 0-1. n (int): The grid size, either 4 (for 2x2) or 9 (for 3x3). border (tuple[int, int]): Border size for height and width. Methods: get_indexes: Return a list of random indexes from the dataset. get_params: Compute mosaic layout parameters. apply_image: Allocate canvas and paste images into mosaic. apply_instances: Concatenate and clip instances for mosaic. _update_labels: Update labels with padding. _cat_labels: Concatenate labels and clips mosaic border instances. Examples: >>> from ultralytics.data.augment import Mosaic >>> dataset = YourDataset(...) # Your image dataset >>> mosaic_aug = Mosaic(dataset, imgsz=640, p=0.5, n=4) >>> augmented_labels = mosaic_aug(original_labels) rimgszrKrgfloatnc d|cxkrdksnJd|d|dvs Jdt||||_| dz| dzf|_||_|jjd k|_d S) a]Initialize the Mosaic augmentation object. This class performs mosaic augmentation by combining multiple (4 or 9) images into a single mosaic image. The augmentation is applied to a dataset with a given probability. Args: dataset (Any): The dataset on which the mosaic augmentation is applied. imgsz (int): Image size (height and width) after mosaic pipeline of a single image. p (float): Probability of applying the mosaic augmentation. Must be in the range 0-1. n (int): The grid size, either 4 (for 2x2) or 9 (for 3x3). rr3The probability should be in range [0, 1], but got rQ>r zgrid must be equal to 4 or 9.)rergramN)superr7rborderrrecachebuffer_enabled)r rerrgrr^s r#r7zMosaic.__init__sA}}}}}}}}}XTUXXX}}}F{{{;{{{ A... v{UFaK0 "l0E9r%cjr5tjtjjjdz Sfdtjdz DS)aReturn a list of random indexes from the dataset for mosaic augmentation. This method selects random image indexes either from a buffer or from the entire dataset, depending on the 'buffer_enabled' attribute. It is used to choose images for creating mosaic augmentations. Returns: (list[int]): A list of random image indexes. The length of the list is n-1, where n is the number of images used in the mosaic (either 3 or 8, depending on whether n is 4 or 9). Examples: >>> mosaic = Mosaic(dataset, imgsz=640, p=1.0, n=4) >>> indexes = mosaic.get_indexes() >>> print(len(indexes)) # Output: 3 rjkcdg|],}tjdtjdz -Srrjrw)rH_r s r#rJz&Mosaic.get_indexes..s4XXXFN1c$,&7&7!&;<<XXXr%)rrlchoicesr5rebufferrrangerWs`r#rrzMosaic.get_indexessb   Y>$t|':";";tvzJJJ JXXXXeDFUVJFWFWXXX Xr%r!rhrCctt|}|d Jdt|dgs Jd|jg}|jdkrfd|jD\}}tdD]}|dkr|n|d|d z }|d }|d |jdd \} } |dkrFt|| z dt|| z d||f\} } } }| | | z z | || z z | | f\}}}}n|d krS|t|| z dt|| zd z|f\} } } }d| || z z t| | | z | f\}}}}n|d krSt|| z d||td z|| zf\} } } }| | | z z d| t|| z | f\}}}}nf|d kr`||t|| zd ztd z|| zf\} } } }ddt| | | z t|| z | f\}}}}| |z }| |z }| || | | |||||||| | fd ސn|jdkrd\}}d\}}tdD]}|dkr|n|d|d z }|d }|d |jdd \} } |dkr| z| zf}| | }}n|d kr | z | zf}n|d kr|z| z |z| zf}n|d kr|z|z| z| zf}n|dkr|z|z|z| z|z| zf}n{|dkr|z| z |z|z|z| zf}n\|dkr|z|z | z |z|z|z |z| zf}n7|dkr| z |z| z |zf}n|dkr| z |z|z | z |z|z f}|dd \}}d|D\}}}}| |||||||| | fd| | }}||d<|S)zCompute mosaic layout parameters. Args: labels (dict[str, Any]): Input labels dictionary. Returns: (dict[str, Any]): Parameters including 'layout' with per-patch geometry. rect_shapeNz'rect and mosaic are mutually exclusive.rkz-There are no other images for mosaic augment.rc3jK|]-}ttj| dz|zV.dS)rN)rKrlrm)rHr|ss r#r~z$Mosaic.get_params..sANNQc&.!QUQY7788NNNNNNr%rrjimg resized_shaper) labels_patchx1ay1ax2ay2ax1by1bx2by2bpadwpadh img_shaper)rrNNc36K|]}t|dVdS)rN)maxrs r#r~z$Mosaic.get_params..8s*!7!7#a))!7!7!7!7!7!7r%)rx1y1x2y2rrrlayout) rrgetrSrrrrshaperminr=) r r!r"rycxcrIrrhwrrrrrrrrrrhpwph0w0crrrrrr^s @r#rzMosaic.get_paramss##F++zz,''//1Z///6::lB//00aa2aaa0 J 6Q;;NNNN$+NNNFB1XX! ! )*avvVL5I!a%5P "5)#''2A2GG166),R!VQR!VQR)O&Cc3)*cCi!sSy/1a)O&Cc33!VV)+Sa^^SaQ=O=OQS)S&Cc3)*AsOSC#I=N=NPQ)Q&Cc33!VV),R!VQRQUBQRFASAS)S&Cc3)*cCi!QC#Iq@Q@Q)Q&Cc33!VV)+RR!VQU1C1CSQPRUVPVEWEW)W&Cc3)*As1cCi/@/@#cCiQRBSBS)S&Cc3SySy (4"""""""" $ $&'V  %! DVq[[FBFB1XX% % )*avvVL5I!a%5P "5)#''2A2GG1661a!eQU*ABB!VV1q5!a%*AA!VVBAq2vz14AA!VVB1r6A:q1u4AA!VVBBB AFQJ>AA!VVB AFAFAFQJ>AA!VVB aRR"a"fqjHAA!VVAq2vz1a"f4AA!VVAq2v{Q1r6B;>ArrU d!7!7Q!7!7!7BB (4    $ $&'V     AB!x r%Nr"dict[str, Any] | Nonec|d}|jdkrtj|jdz|jdz|djdfdtj}|D]o}|d}|d}|d|d |d |d f\}} } } |d |d |d|df\} } }}|| || |f|| | || f<p||d<n|jdkrtj|jdz|jdz|djdfdtj}|D]v}|d}|d}|d|d|d|df\}}}}|d|d}}||z ||z } } | ||z z| ||z z}}|| || |f|||||f<w||jd |jd|jd |jdf|d<|S)aApply mosaic augmentation to the image. Args: labels (dict[str, Any]): Dictionary containing 'img'. params (dict | None): Parameters from get_params, including 'layout'. Returns: (dict): Updated labels with mosaic image. rrrrrdtyperrrrrrrrrrrrrrrrrrrj)rnpfullrruint8r)r r!r"rimg4r}rrrrrrrrrrimg9rrrrrrs r#rzMosaic.apply_imageIs6! 6Q;;7DJNDJNF5MSWc#g%&& F5MM Vq[[7DJNDJNF5M!ADKPQN?UYU`abUcCc!cdF5M r%c |d}g}|D]}|jdkr|d}|d}n,|d|jdz}|d|jdz}||d|||d}||||} || |S) a5Apply mosaic augmentation to instances. Args: labels (dict[str, Any]): Dictionary containing 'instances' and 'cls'. params (dict | None): Parameters from get_params, including 'layout'. Returns: (dict): Updated labels with concatenated instances. rrrrrrjrr)rr_update_labelsrr= _cat_labelsupdate) r r!r"r mosaic_labelsr}rrr final_labelss r#rzMosaic.apply_instancesjs!  / /Dv{{F|F|F|dk!n4F|dk!n4..tN/CT4QUQYQYZeQfQfggL   . . . .'' 66  l### r%c8|d/td|dgDr|S|d}|jdkrtj|jdz|jdzfdtj }|D]}|d }|d}|"|d |d |d |df\}} } } |d|d|d|df\} } }}|| || |f|| | || f<||d<n|jdkrtj|jdz|jdzfdtj }|D]}|d }|d}|"|d|d|d|df\}}}}|d|d}}||z ||z } } | ||z z| ||z z}}|| || |f|||||f<||jd |jd|jd |jdf|d<|S)a#Apply mosaic augmentation to semantic mask. Args: labels (dict[str, Any]): Dictionary containing 'semantic_mask'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels with concatenated semantic mask. semantic_maskNc3DK|]}|dduVdS)rN)r)rHms r#r~z(Mosaic.apply_semantic..sD7 7 /0AEE/ " "d *7 7 7 7 7 7 r%rkrrrrrrrrrrrrrrrrrrrrrrrj)rallrrrrrr)r r!r"rmask4r}rmaskrrrrrrrrmask9rrrrrrs r#rzMosaic.apply_semantics ::o & & .37 7 4:JJ|R4P4P7 7 7 4 4 .M! 6Q;;GTZ!^TZ!^>> labels = {"img": np.zeros((100, 100, 3)), "instances": Instances(...)} >>> padw, padh = 50, 50 >>> updated_labels = Mosaic._update_labels(labels, padw, padh) Nrr instancesxyxyformat)r convert_bbox denormalize add_padding)r!rrrnhnws r#rzMosaic._update_labelss},(39LRaR9PB{(((777{''B///{''d333 r%rlist[dict[str, Any]]c|siSg}g}|jdz}|D]8}||d||d9|dd|dd||ftj|dt j|dd}|d|||d}|d||d<d |dvr|dd |d <|S) a=Concatenate and process labels for mosaic augmentation. This method combines labels from multiple images used in mosaic augmentation, clips instances to the mosaic border, and removes zero-area boxes. Args: mosaic_labels (list[dict[str, Any]]): A list of label dictionaries for each image in the mosaic. Returns: (dict[str, Any]): A dictionary containing concatenated and processed labels for the mosaic image, including: - im_file (str): File path of the first image in the mosaic. - ori_shape (tuple[int, int]): Original shape of the first image. - resized_shape (tuple[int, int]): Shape of the mosaic image (imgsz * 2, imgsz * 2). - cls (np.ndarray): Concatenated class labels. - instances (Instances): Concatenated instance annotations. - texts (list[str], optional): Text labels if present in the original labels. Examples: >>> mosaic = Mosaic(dataset, imgsz=640) >>> mosaic_labels = [{"cls": np.array([0, 1]), "instances": Instances(...)} for _ in range(4)] >>> result = mosaic._cat_labels(mosaic_labels) >>> print(result.keys()) dict_keys(['im_file', 'ori_shape', 'resized_shape', 'cls', 'instances']) rrrrim_file ori_shapeaxis)rrrrrrz)rr=r concatenaterclipremove_zero_area_boxes)r rrrrr!rgoods r#rzMosaic._cat_labelss)2 I  Q# 2 2F JJve} % % %   VK0 1 1 1 1%Q' 2&q)+6#U^>#q))".yqAAA    [!&&ue444K(??AA*51$7 U mA& & &$1!$4W$=L !r%)rrr)rrKrgrrrKrr,r!rhr"rrCrh)rrKrrKrrrCrh)rrrCrh)r-r.r/r0r7rrrrrrrrr __classcell__r^s@r#rrs 6:::::::(YYY(]]]]]]~B2(((((T\6........r%rcPeZdZdZddfd Zdfd ZdddZdddZdddZxZ S)MixUpaApply MixUp augmentation to image datasets. This class implements the MixUp augmentation technique as described in the paper [mixup: Beyond Empirical Risk Minimization](https://arxiv.org/abs/1710.09412). MixUp combines two images and their labels using a random weight. Attributes: dataset (Any): The dataset to which MixUp augmentation will be applied. pre_transform (Callable | None): Optional transform to apply before MixUp. p (float): Probability of applying MixUp augmentation. Methods: get_params: Compute MixUp parameters including blend ratio. apply_image: Blend images using MixUp. apply_instances: Concatenate instances for MixUp. Examples: >>> from ultralytics.data.augment import MixUp >>> dataset = YourDataset(...) # Your image dataset >>> mixup = MixUp(dataset, p=0.5) >>> augmented_labels = mixup(original_labels) NrrgrrCrOcPt|||dS)a=Initialize the MixUp augmentation object. MixUp is an image augmentation technique that combines two images by taking a weighted sum of their pixel values and labels. This implementation is designed for use with the Ultralytics YOLO framework. Args: dataset (Any): The dataset to which MixUp augmentation will be applied. pre_transform (Callable | None): Optional transform to apply to images before MixUp. p (float): Probability of applying MixUp augmentation to an image. Must be in the range [0, 1]. rdN)rr7)r rerfrgr^s r#r7zMixUp.__init__s*  KKKKKr%r!rhct|}tjdd|d<|S)zCompute MixUp parameters. Args: labels (dict[str, Any]): Input labels dictionary. Returns: (dict[str, Any]): Parameters including mix ratio 'r'. g@@r)rrrrlbetar r!r"r^s r#rzMixUp.get_paramss:##F++innT400s  r%r"rc|d}|dd}|d|z|dd|z zztj|d<|S)a Blend images using MixUp. Args: labels (dict[str, Any]): Dictionary containing 'img'. params (dict | None): Parameters from get_params, including 'r'. Returns: (dict): Updated labels with blended image. rrkrrrj)astyperr)r r!r"rlabels2s r#rzMixUp.apply_image+sU 3K&q)*WU^q1u-EEMMbhWWu  r%c|dd}tj|d|dgd|d<tj|d|dgd|d<|S)aConcatenate instances for MixUp. Args: labels (dict[str, Any]): Dictionary containing 'instances' and 'cls'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels with concatenated instances. rkrrrr)rrr)r r!r"r s r#rzMixUp.apply_instances:se&q)'3VK5H'R]J^4_fghhh{u wu~'FJJu  r%c|d|S|dd}|d|S|d}|dkr|d|d<|S)aApply MixUp augmentation to semantic segmentation masks. Args: labels (dict[str, Any]): Primary image labels containing 'semantic_mask' and 'mix_labels'. params (dict[str, Any] | None): Parameters dict with key 'r' (mix ratio). Defaults to None. Returns: (dict[str, Any]): Updated labels with the semantic mask replaced by the mixed image's mask if r < 0.5. rNrkrr?)rcopy)r r!r"r rs r#rzMixUp.apply_semanticIss ::o & & .M&q) ;; ' ' /M 3K s77&-o&>&C&C&E&EF? # r%r)rgrrCrOrr,r) r-r.r/r0r7rrrrrrs@r#rrs, L L L L L L L                r%rcXeZdZdZddfd ZddZdfd ZdddZdddZdddZ xZ S) CutMixaApply CutMix augmentation to image datasets as described in the paper https://arxiv.org/abs/1905.04899. CutMix combines two images by replacing a random rectangular region of one image with the corresponding region from another image, and adjusts the labels proportionally to the area of the mixed region. Attributes: dataset (Any): The dataset to which CutMix augmentation will be applied. pre_transform (Callable | None): Optional transform to apply before CutMix. p (float): Probability of applying CutMix augmentation. beta (float): Beta distribution parameter for sampling the mixing ratio. num_areas (int): Number of areas to try to cut and mix. Methods: get_params: Compute CutMix parameters including cut area and filtered indexes. apply_image: Copy patch from secondary image into primary image. apply_instances: Clip and concatenate instances for CutMix. _rand_bbox: Generate random bounding box coordinates for the cut region. Examples: >>> from ultralytics.data.augment import CutMix >>> dataset = YourDataset(...) # Your image dataset >>> cutmix = CutMix(dataset, p=0.5) >>> augmented_labels = cutmix(original_labels) Nrrrrgrr  num_areasrKrCrOclt|||||_||_dS)aInitialize the CutMix augmentation object. Args: dataset (Any): The dataset to which CutMix augmentation will be applied. pre_transform (Callable | None): Optional transform to apply before CutMix. p (float): Probability of applying CutMix augmentation. beta (float): Beta distribution parameter for sampling the mixing ratio. num_areas (int): Number of areas to try to cut and mix. rdN)rr7r r)r rerfrgr rr^s r#r7zCutMix.__init__ys6  KKK "r%widthheighttuple[int, int, int, int]c4tj|j|j}tjd|z }t ||z}t ||z}tj|}tj|}tj||dzz d|} tj||dzz d|} tj||dzzd|} tj||dzzd|} | | | | fS)aGenerate random bounding box coordinates for the cut region. Args: width (int): Width of the image. height (int): Height of the image. Returns: (tuple[int]): (x1, y1, x2, y2) coordinates of the bounding box. rrr)rrlr sqrtrKrxr) r rrlam cut_ratiocut_wcut_hcxcyrrrrs r# _rand_bboxzCutMix._rand_bboxsinnTY 22GC#I&& EI%&&FY&''Y  u % % Y  v & &WR%1*_a / / WR%1*_a 0 0 WR%1*_a / / WR%1*_a 0 02r2~r%r!rhcl t|}|djdd\ tj fdt jDtj}t||dj }tj | dd kd }t|d krd |d <|S|d d }|tj |}t|d|dj d }tj |t|djrd ndkd } t| d krd |d <|S||d<| |d< |d< |d<|S)zCompute CutMix parameters. Args: labels (dict[str, Any]): Input labels dictionary. Returns: (dict[str, Any]): Parameters including 'skip', 'area', and 'indexes2'. rNrc<g|]}Sr')r!)rHrrr rs r#rJz%CutMix.get_params..s'UUU!1 5 5UUUr%rrrjrrTskiprk{Gz?皙?areaindexes2rr)rrrrasarrayrrfloat32rbboxesnonzerosumrSrlchoicersegments) r r!r" cut_areasioa1idxr r'ioa2r(rrr^s ` @@r#rzCutMix.get_paramss##F++e}"2A2&1JUUUUUUuT^?T?TUUU]_]ghhh  6+#6#=>>jq))Q.//2 s88q==!F6NM&q)))#../T GK$8$?@@HHKK:ds6+3F3O/P/P'YttVYZ[[\]^ x==A  !F6NMv%zs s  r%r"rc|dr|S|dtj\}}}}|dd}|d||||f|d||||f<|S)zApply CutMix to the image. Args: labels (dict[str, Any]): Dictionary containing 'img'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels with mixed image. r$r'rkrr)rr rint32)r r!r"rrrrr s r#rzCutMix.apply_images ::f   M..rx88BB&q)&-enRUBrE\&Bu beRUl# r%cz|dr|S|dd}|d|d}}|d}|d}|d|}|d ||||tj\} } } } || | || | z | | z || | t j|d |d |gd |d <tj|d|gd |d<|S) a Apply CutMix to instances. Args: labels (dict[str, Any]): Dictionary containing 'instances' and 'cls'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels with mixed instances. r$rkrrrr'r(rrrr) rrrr rr5rrrr) r r!r"r rrr'r( instances2rrrrs r#rzCutMix.apply_instancessE ::f   M&q)c{F3K1f~*%[)(3 '''q!$$$RX..BBsRC(((Rb)))r2&&&u wu~h7O'PWXYYYu '3VK5H*4U\]^^^{ r%ct|dr|S|d|S|dtj\}}}}|dd}|d<|d}|d||||f|||||f<||d<|S)aApply CutMix augmentation to semantic segmentation masks. Args: labels (dict[str, Any]): Primary image labels containing 'semantic_mask' and 'mix_labels'. params (dict[str, Any] | None): Parameters dict with 'area' (bounding box coordinates) and 'skip' (bool flag). Defaults to None. Returns: (dict[str, Any]): Updated labels with the semantic mask region replaced by the mixed image's mask. r$rNr'rkr)rr rr5r) r r!r"rrrrr rs r#rzCutMix.apply_semantics ::f   M ::o & & .M..rx88BB&q) ;; ' ' 3/*//11D!(!9"R%B,!GDB2 &*F? # r%)Nrrr)rgrr rrrKrCrO)rrKrrKrCrrr,r) r-r.r/r0r7r!rrrrrrs@r#rr_s2 # # # # # # #:B"<r%rceZdZdZ d1d2dZd3dZd4dZd5d6dZd5d6dZd7dZ d8d"Z d9d$Z d5d6d%Z e d:d;d0ZdS)<RandomPerspectiveajImplement random perspective and affine transformations on images and corresponding annotations. This class applies random rotations, translations, scaling, shearing, and perspective transformations to images and their associated bounding boxes, segments, and keypoints. It can be used as part of an augmentation pipeline for object detection and instance segmentation tasks. Attributes: degrees (float): Maximum absolute degree range for random rotations. translate (float): Maximum translation as a fraction of the image size. scale (float): Scaling factor range, e.g., scale=0.1 means 0.9-1.1. shear (float): Maximum shear angle in degrees. perspective (float): Perspective distortion factor. size (tuple[int, int] | None): Output size (width, height). If None, uses the input image size. Methods: get_params: Compute affine transformation matrix and related parameters. apply_image: Warp the image using the affine matrix. apply_instances: Transform bounding boxes, segments, and keypoints. apply_semantic: Placeholder for semantic segmentation mask transformation. apply_bboxes: Transform bounding boxes using the affine matrix. apply_segments: Transform segments and generate new bounding boxes. apply_keypoints: Transform keypoints using the affine matrix. box_candidates: Filter transformed bounding boxes based on size and aspect ratio. Examples: >>> transform = RandomPerspective(degrees=10, translate=0.1, scale=0.1, shear=10) >>> image = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8) >>> labels = {"img": image, "cls": np.array([0, 1]), "instances": Instances(...)} >>> result = transform(labels) >>> transformed_image = result["img"] >>> transformed_instances = result["instances"] rr&rNdegreesr translatescalefloat | tuple[float, float]shear perspectivesizercZ||_||_||_||_||_||_dS)aInitialize RandomPerspective object with transformation parameters. This class implements random perspective and affine transformations on images and corresponding bounding boxes, segments, and keypoints. Transformations include rotation, translation, scaling, and shearing. Args: degrees (float): Degree range for random rotations. translate (float): Fraction of total width and height for random translation. scale (float | tuple[float, float]): Scaling factor interval. If float, e.g. 0.5 means resize between 50%-150%. If tuple, interpreted as absolute (min, max) scale factors. shear (float): Shear intensity (angle in degrees). perspective (float): Perspective distortion factor. size (tuple[int, int] | None): Output size (width, height). If None, uses the input image size. Nr;r<r=r?r@rA)r r;r<r=r?r@rAs r#r7zRandomPerspective.__init__.s3. "  & r%r np.ndarraytuple[int, int]rCtuple[np.ndarray, float]cvtjdtj}|jd dz |d<|jd dz |d<tjdtj}t j|j |j|d<t j|j |j|d <tjdtj}t j|j |j}t|j ttfr,t j|j d|j d}n%t jd|j z d|j z}tj |d | |d d<tjdtj}tjt j|j |jtjzd z |d<tjt j|j |jtjzd z |d<tjdtj} t jd|jz d|jz|dz| d<t jd|jz d|jz|dz| d<| |z|z|z|z} | |fS)atCompute the affine transformation matrix without applying it. Args: img (np.ndarray): Input image used to determine center and dimensions. size (tuple[int, int]): Size of the output image (width, height) used for clipping translation transform. Returns: (M, scale): 3x3 transformation matrix and scale factor. rrrjr)rrrrjr)rr)rrjrr)anglecenterr=Nr)rjrr)reyer*rrlrmr@r;r4r=rr5cv2getRotationMatrix2Dmathtanr?pir<) r rrACPRarSTMs r#_compute_affine_matrixz(RandomPerspective._compute_affine_matrixLsI F1BJ ' ' '9Q<-!#$9Q<-!#$ F1BJ ' ' '.$"2!2D4DEE$.$"2!2D4DEE$ F1BJ ' ' ' NDL=$, 7 7 dj5$- 0 0 ?tz!}djm<>A'aaHHH"1" F1BJ ' ' '(6>4:+tzBBTWLsRSS$(6>4:+tzBBTWLsRSS$ F1BJ ' ' '.t~!5sT^7KLLtTUwV$.t~!5sT^7KLLtTUwV$ EAIMA !t r%r!rhc|d}|j|jd|jdfn|j}|jdd}|||\}}||||dS)a%Compute affine transformation parameters shared across image and instances. Args: labels (dict[str, Any]): Input labels dictionary containing 'img'. Returns: (dict): Parameters including 'M' (affine matrix), 'scale', 'orig_shape', and 'size'. rNrjrr)rYr= orig_shaperA)rArrZ)r r!rrAr\rYr=s r#rzRandomPerspective.get_paramsxskUm/3y/@ ! cil++diYrr] ..sD995j$OOOr%r"rc|d}|d}|d}|d|jdksA|d|jdks*|tjdkrS|jrt j|||d}n t j||d d |d}|jd kr|d }||d<|jd d |d <|S) a-Apply affine warp to the image. Args: labels (dict[str, Any]): Dictionary containing 'img'. params (dict | None): Parameters from get_params, including 'M' and 'size'. Returns: (dict): Updated labels with warped image and 'resized_shape'. rrYrArrjr)rrr)dsize borderValueNr.Nr) rrrManyr@rNwarpPerspective warpAffinendim)r r!r"rrYrAs r#rzRandomPerspective.apply_imagesUm 3Kf~ Gsy| # #tAw#)A,'>'>APQNCWCWCYCY'> Z)#q/ZZZnS!BQB%tYYYx1}})nu "%)BQB- r%c|d}|d}|d|j|dddd|d}|d }||j|}|j}|j} t|r ||||d \}}| | | ||d } t||| dd } | j |d | ||d | |jj| jjt|rdnd} | | |d<|| |d<|S)aQApply affine transformation to object instances. Args: labels (dict[str, Any]): Dictionary containing 'instances' and 'cls'. params (dict | None): Parameters from get_params, including 'M' and 'scale'. Returns: (dict): Updated labels with transformed and filtered instances. rrrrr\NrrYr=rAF) bbox_format normalizedT)scale_wscale_h bbox_onlyr%r&)box1box2area_thr)rnrr apply_bboxesr+r/ keypointsrSapply_segmentsapply_keypointsrrr=box_candidatesrX) r r!r"rrrYr=r+r/ro new_instancesrIs r#rz!RandomPerspective.apply_instancessUmJJ{++ f--- vl3DDbD9:: 3Kw""9#3Q77%' x== P#228QvOO FH  ,,Y6&>JJI!&(I6^cddd  F6N++ uEEE   !#-*>*@SVW_S`S`Kj44fj   ,A.{Au  r%r+rYct|}|dkr|Stj|dzdf|j}|ddgdf|dzd|ddddf<||jz}|jr|ddddf|ddddfz n |ddddf|d}|ddgd f}|ddgd f}tj|d |d | d | d f|jd|jS) aApply affine transformation to bounding boxes. This function applies an affine transformation to a set of bounding boxes using the provided transformation matrix. Args: bboxes (np.ndarray): Bounding boxes in xyxy format with shape (N, 4), where N is the number of bounding boxes. M (np.ndarray): Affine transformation matrix with shape (3, 3). Returns: (np.ndarray): Transformed bounding boxes in xyxy format with shape (N, 4). Examples: >>> rp = RandomPerspective() >>> bboxes = np.array([[10, 10, 20, 20], [30, 30, 40, 40]], dtype=np.float32) >>> M = np.eye(3, dtype=np.float32) >>> transformed_bboxes = rp.apply_bboxes(bboxes, M) rrrrN)rrjrrrrrrjrr)rrrr)rjrrrrj) rSronesrreshaperXr@rrr)r r+rYrxyr|ys r#rnzRandomPerspective.apply_bboxessh( KK 66M Wa!eQZv| 4 4 411166667??AqII111bqb5 !#X(,(8GbBQBi"QQQ!V*$$bBQBi P PQRTU V V qqq,,,  qqq,,, ~quuQxxq15588QUU1XXFfl[[[ccdeghiikkr%r/tuple[np.ndarray, np.ndarray]c`|jdd\}}|dkrg|fStj||zdf|j}|dd}||ddddf<||jz}|ddddf|ddddfz }||dd}tjfd|Dd}|d|dddd f|ddddf|d<|d |ddd df|dddd f|d <||fS) aApply affine transformations to segments and generate new bounding boxes. This function applies affine transformations to input segments and generates new bounding boxes based on the transformed segments. It clips the transformed segments to fit within the new bounding boxes. Args: segments (np.ndarray): Input segments with shape (N, M, 2), where N is the number of segments and M is the number of points in each segment. M (np.ndarray): Affine transformation matrix with shape (3, 3). size (tuple[int, int]): Size of the output image (width, height) used for clipping the segments. Returns: bboxes (np.ndarray): New bounding boxes with shape (N, 4) in xyxy format. segments (np.ndarray): Transformed and clipped segments with shape (N, M, 2). Examples: >>> rp = RandomPerspective() >>> segments = np.random.rand(10, 500, 2) # 10 segments with 500 points each >>> M = np.eye(3) # Identity transformation matrix >>> new_bboxes, new_segments = rp.apply_segments(segments, M) NrrrrrcJg|]}t|dd Sr)r)rHrwrAs r#rJz4RandomPerspective.apply_segments.. s-PPP;r47DG<<PPPr%.rrj.rjr)rrrurrvrXstackr)r r/rYrArnumrwr+s ` r#rpz RandomPerspective.apply_segmentssn0#3 66x<  Wa#gq\ 8 8 8##B**111bqb5 !#X 2A2YAAAqsF #::aQ''PPPPxPPPRSTT#F+001Q31Q3PP#F+001Q31Q3PPxr%roc\|jdd\}}|dkr|Stj||zdf|j}|d||zd}|dddf||zd|ddddf<||jz}|ddddf|ddddfz }|dddfdk|dddfdkz|dddf|dkz|dddf|dkz}d||<tj||gd ||dS) auApply affine transformation to keypoints. This method transforms the input keypoints using the provided affine transformation matrix. It handles perspective rescaling if necessary and updates the visibility of keypoints that fall outside the image boundaries after transformation. Args: keypoints (np.ndarray): Array of keypoints with shape (N, K, 3), where N is the number of instances, K is the number of keypoints per instance, and 3 represents (x, y, visibility). M (np.ndarray): 3x3 affine transformation matrix. size (tuple[int, int]): Size of the output image (width, height) used to determine visibility of keypoints. Returns: (np.ndarray): Transformed keypoints array with the same shape as input (N, K, 3). Examples: >>> random_perspective = RandomPerspective() >>> keypoints = np.random.rand(5, 17, 3) # 5 instances, 17 keypoints each >>> M = np.eye(3) # Identity transformation >>> transformed_keypoints = random_perspective.apply_keypoints(keypoints, M) Nrrrr).rrj.rr)rrrurrvrXr) r rorYrArnkptrwvisibleout_masks r#rqz!RandomPerspective.apply_keypointssi,/"1"%4 66  Wa$h])/ : : :F#++AHa88c2A2g&..q4x;;111bqb5 !#X 2A2YAAAqsF #qqq!tHqLR1X\2bAha6HIRPQPQPQSTPTXX\]^X_M_`~r7m"555==aqIIIr%cd|vs|d|S|d}|d}|d}|d|jdksA|d|jdks*|tjdkrV|jr$t j|||t jd }n+t j||dd |t jd }||d<|S) aKApply affine transformation to semantic segmentation mask. Args: labels (dict[str, Any]): Dictionary containing 'semantic_mask'. params (dict | None): Parameters from get_params, including 'M' and 'size'. Returns: (dict): Updated labels with transformed semantic mask. rNrYrArrjrr)r^flagsr_r) rrrMrar@rNrb INTER_NEARESTrc)r r!r"rrYrAs r#rz RandomPerspective.apply_semantic4s & ( (F?,C,KMo& 3Kf~ Gtz!} $ $Q4:a=(@(@a26RS99nEYEYE[E[(@ i*4$cFWehiii~dAbqbESEVdghhh"& r%rd缉ؗҜ>> random_perspective = RandomPerspective() >>> box1 = np.array([[0, 0, 100, 100], [0, 0, 50, 50]]).T >>> box2 = np.array([[10, 10, 90, 90], [5, 5, 45, 45]]).T >>> candidates = random_perspective.box_candidates(box1, box2) >>> print(candidates) [True True] rrrrj)rmaximum) rkrlrrrmrw1h1w2h2ars r#rrz RandomPerspective.box_candidatesKsNa47"DGd1g$5Ba47"DGd1g$5B Zb3hrCx 9 9V V ,R27S=0IH0TUY[^dYdeer%)rr&rrrN) r;rr<rr=r>r?rr@rrAr)rrDrArErCrFrr,r)r+rDrYrDrCrD)r/rDrYrDrArErCry)rorDrYrDrArErCrD)rrr&r)rkrDrlrDrrKrrKrmrrrrCrD)r-r.r/r0r7rZrrrrnrprqrrrrr'r%r#r:r: sFF-0 '+<****X P P P P0(((((T l l l lD% % % % N J J J JD. )f)f)f)f\)f)f)fr%r:c&eZdZdZddd Zddd Zd S) RandomHSVaRandomly adjust the Hue, Saturation, and Value (HSV) channels of an image. This class applies random HSV augmentation to images within predefined limits set by hgain, sgain, and vgain. Attributes: hgain (float): Maximum variation for hue. Range is typically [0, 1]. sgain (float): Maximum variation for saturation. Range is typically [0, 1]. vgain (float): Maximum variation for value. Range is typically [0, 1]. Methods: apply_image: Apply random HSV augmentation to an image. Examples: >>> import numpy as np >>> from ultralytics.data.augment import RandomHSV >>> augmenter = RandomHSV(hgain=0.5, sgain=0.5, vgain=0.5) >>> image = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8) >>> labels = {"img": image} >>> labels = augmenter(labels) >>> augmented_image = labels["img"] rhgainrsgainvgainrCrOc0||_||_||_dS)aInitialize the RandomHSV object for random HSV (Hue, Saturation, Value) augmentation. This class applies random adjustments to the HSV channels of an image within specified limits. Args: hgain (float): Maximum variation for hue. Should be in the range [0, 1]. sgain (float): Maximum variation for saturation. Should be in the range [0, 1]. vgain (float): Maximum variation for value. Should be in the range [0, 1]. Nrrr)r rrrs r#r7zRandomHSV.__init__s   r%Nr"rc|d}|jddkr|S|js|js|jr|j}t jddd|j|j|jgz}t jdd|j}||ddzzdz |}t j ||ddzzdd  |}t j ||d dzzdd  |} d|d<tj tj |tj\} } } tjtj| |tj| |tj| | f} tj | tj| |S) aApply random HSV augmentation to an image within predefined limits. This method modifies the input image by randomly adjusting its Hue, Saturation, and Value (HSV) channels. The adjustments are made within the limits set by hgain, sgain, and vgain during initialization. Args: labels (dict[str, Any]): A dictionary containing image data and metadata. Must include an 'img' key with the image as a numpy array. params (dict[str, Any] | None): Unused parameters for API compatibility. Returns: (dict[str, Any]): The labels dictionary with the HSV-augmented image. Examples: >>> hsv_augmenter = RandomHSV(hgain=0.5, sgain=0.5, vgain=0.5) >>> labels = {"img": np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8)} >>> labels = hsv_augmenter.apply_image(labels) >>> augmented_img = labels["img"] rrrrjrrrLrr)dst)rrrrrrrlrmaranger rrNsplitcvtColor COLOR_BGR2HSVmergeLUT COLOR_HSV2BGR)r r!r"rrrr|lut_huelut_satlut_valhuesatvalim_hsvs r#rzRandomHSV.apply_images(Um 9R=A  M : = =tz =IE !!"a++tz4:tz.RRA !S000AAaD3J#-55e<>> transform = RandomFlip(p=0.5, direction="horizontal") >>> result = transform({"img": image, "instances": instances}) >>> flipped_image = result["img"] >>> flipped_instances = result["instances"] r horizontalNrgr directionstrflip_idxlist[int] | NonerCrOc|dvs Jd|d|cxkrdksnJd|d||_||_||_dS)aInitialize the RandomFlip class with probability and direction. This class applies a random horizontal or vertical flip to an image with a given probability. It also updates any instances (bounding boxes, keypoints, etc.) accordingly. Args: p (float): The probability of applying the flip. Must be between 0 and 1. direction (str): The direction to apply the flip. Must be 'horizontal' or 'vertical'. flip_idx (list[int] | None): Index mapping for flipping keypoints, if any. Raises: AssertionError: If direction is not 'horizontal' or 'vertical', or if p is not between 0 and 1. >verticalrz2Support direction `horizontal` or `vertical`, got rrrrQN)rgrr)r rgrrs r#r7zRandomFlip.__init__so66668xmv8x8x666A}}}}}}}}}XTUXXX}}}"  r%r!rhc|d}|d}|jdd\}}|jrdn|}|jrdn|}tj|jk|||j|jdS)aCompute random flip parameters. Args: labels (dict[str, Any]): Input labels dictionary containing 'img' and 'instances'. Returns: (dict): Parameters including 'flip' (bool), 'h', 'w', 'direction', and 'flip_idx'. rrNrrj)fliprrrr)rrgrlrgrr)r r!rrrrs r#rzRandomFlip.get_paramss{Um;' y!}1% ,AA1% ,AA1MOOdf,    r%r"c|d}|drA|ddkrtj|}n |ddkrtj|}tj||d<|S)aApply flip to the image. Args: labels (dict[str, Any]): Dictionary containing 'img'. params (dict): Parameters from get_params. Returns: (dict): Updated labels with flipped (or unchanged) image. rrrrr)rflipudfliplrascontiguousarrayr r!r"rs r#rzRandomFlip.apply_imagesnUm &> %k"j00inn $ 44inn,S11u  r%c|d}|d|dr|ddkr||dn'|ddkr||d |d 8|j1t j|jd d |d d d f|_||d<|S) aApply flip to object instances. Args: labels (dict[str, Any]): Dictionary containing 'instances'. params (dict): Parameters from get_params. Returns: (dict): Updated labels with flipped (or unchanged) instances. rxywhrrrrrrrrN)rnrrrrorr)r r!r"rs r#rzRandomFlip.apply_instancessJJ{++ f--- &> jk"j00  ---- $ 44  ---j!-)2E2Q&(&:9;NqqqRXYcRdfgfgfgOg;h&i&i #'{ r%c d|vs|d|S|drw|ddkr0tjtj|d|d<n;|ddkr/tjtj|d|d<|S)a$Apply flip to semantic segmentation mask. Args: labels (dict[str, Any]): Dictionary containing 'semantic_mask'. params (dict): Parameters from get_params. Returns: (dict): Updated labels with flipped (or unchanged) semantic mask. rNrrrr)rrrrrs r#rzRandomFlip.apply_semantic.s & ( (F?,C,KM &> ck"j00*,*>ryP_I`?a?a*b*b'' $ 44*,*>ryP_I`?a?a*b*b' r%)rrN)rgrrrrrrCrOrr!rhr"rhrCrh) r-r.r/r0r7rrrrr'r%r#rrs(!!!!!*    ,&,r%rcxeZdZdZdddddddejfd(dZd)d*dZd+dZd,dZ d,dZ d,d Z e d-d'Z dS). LetterBoxaResize image and padding for detection, instance segmentation, pose. This class resizes and pads images to a specified shape while preserving aspect ratio. It also updates corresponding labels and bounding boxes. Attributes: new_shape (tuple): Target shape (height, width) for resizing. auto (bool): Whether to use minimum rectangle. scale_fill (bool): Whether to stretch the image to new_shape. scaleup (bool): Whether to allow scaling up. If False, only scale down. stride (int): Stride for rounding padding. center (bool): Whether to center the image or align to top-left. Methods: __call__: Resize and pad image, update labels and bounding boxes. Examples: >>> transform = LetterBox(new_shape=(640, 640)) >>> result = transform(labels) >>> resized_img = result["img"] >>> updated_instances = result["instances"] rrFT r new_shaperEautobool scale_fillscaleuprKstriderK padding_value interpolationc v||_||_||_||_||_||_||_||_dS)aInitialize LetterBox object for resizing and padding images. This class is designed to resize and pad images for object detection, instance segmentation, and pose estimation tasks. It supports various resizing modes including auto-sizing, scale-fill, and letterboxing. Args: new_shape (tuple[int, int]): Target size (height, width) for the resized image. auto (bool): If True, use minimum rectangle to resize. If False, use new_shape directly. scale_fill (bool): If True, stretch the image to new_shape without padding. scaleup (bool): If True, allow scaling up. If False, only scale down. center (bool): If True, center the placed image. If False, place image in top-left corner. stride (int): Stride of the model (e.g., 32 for YOLOv5). padding_value (int): Value for padding the image. Default is 114. interpolation (int): Interpolation method for resizing. Default is cv2.INTER_LINEAR. N)rrrrrrKrr) r rrrrrKrrrs r#r7zLetterBox.__init__ZsD4# $   **r%Nr!rimagerDrCdict[str, Any] | np.ndarrayc|i}t|dk}|||d<||}|||}|s|||}|||}|r|dS|S)aResize and pad an image for object detection, instance segmentation, or pose estimation tasks. This method applies letterboxing to the input image, which involves resizing the image while maintaining its aspect ratio and adding padding to fit the new shape. It also updates any associated labels accordingly. Args: labels (dict[str, Any] | None): A dictionary containing image data and associated labels, or empty dict if None. image (np.ndarray | None): The input image as a numpy array. If None, the image is taken from 'labels'. Returns: (dict[str, Any] | np.ndarray): If 'labels' is provided, returns an updated dictionary with the resized and padded image, updated labels, and additional metadata. If 'labels' is empty, returns the resized and padded image only. Examples: >>> letterbox = LetterBox(new_shape=(640, 640)) >>> result = letterbox(labels={"img": np.zeros((480, 640, 3)), "instances": Instances(...)}) >>> resized_img = result["img"] >>> updated_instances = result["instances"] Nrr)rSrrrr)r r!rreturn_image_onlyr"s r#r$zLetterBox.__call__}s, >FKK1,  !F5M((!!&&11  :))&&99F$$VV44  !%=  r%rhc |d}|jdd}|d|j}t|tr||f}t |d|dz |d|dz }|jst |d}||f}t|d|zt|d|zf}|d|dz |d|dz } }|jr5tj ||j tj | |j } }n>|j r7d\}} |d|df}|d|dz |d|dz f}|j r |dz}| dz} |j rt| d z ndt| d z} } |j rt|d z ndt|d z} } ||||| | | | d S) aCompute letterboxing parameters. Args: labels (dict[str, Any]): Input labels dictionary containing 'img'. Returns: (dict): Parameters including 'orig_shape', 'new_shape', 'ratio', padding, and resize info. rNrrrrjr)rrr&)r\rratio new_unpadtopbottomleftright)rrnrr4rKrrroundrrmodrrrK)r r!rrrrrrdwdhrrrrs r#rzLetterBox.get_paramssUm "1" JJ|T^<< i % % /"I.I  ! uQx'1a)@ A A| As A1%(Q,''uQx!|)<)<< 1 ! ,ilYq\.IB 9 EVB ,,bfR.E.EBB _ EFB"1y|4IaL58+Yq\E!H-DDE ;  !GB !GB)-;eBHooo!U28__V)-;eBHooo!U28__e ""   r%r"c &|d}|jdd}|d}|ddd|kr/tj|||j}|jdkr|d}|j\}}}|d|d } } |d |d } } |d kr/tj|| | | | tj|jfd z }nCtj || z| z|| z| z|f|j|j } || | | |z| | |zf<| }||d<|d|d<|S)zResize and pad the image. Args: labels (dict[str, Any]): Dictionary containing 'img'. params (dict): Parameters from get_params. Returns: (dict): Updated labels with resized and padded image. rNrrrrr`rrrrrrN) fill_valuerrr) rrNresizerrdcopyMakeBorderBORDER_CONSTANTrrrr)r r!r"rrrrrrrrrrpad_imgs r#rzLetterBox.apply_imagesRUm "1" ;' 2;) # #*S)4;MNNNCx1}})n)1aUmVH%5VVnfWoe 66$S&$s/B4K]J_bcJcCCgq3w/TE1A1ERVRdloluvvvG69GC#'M4$(?2 3Cu "("5 r%c Fd|vs|d|S|d}|d}|d}|ddd|kr!tj||tj}|d|d}}|d |d } }tj||||| tjd }||d<|S) a(Apply letterboxing to semantic segmentation mask. Args: labels (dict[str, Any]): Dictionary containing 'semantic_mask'. params (dict): Parameters from get_params. Returns: (dict): Updated labels with resized and padded semantic mask. rNr\rrrrrrrrr)rNrrrr) r r!r"rrrrrrrs r#rzLetterBox.apply_semantics & ( (F?,C,KMo&|$;' 2;) # #:dIS=NOOODUmVH%5VVnfWoe!$VT5#BU]`aaa"& r%cd|vr1|||d|d|d|d}|dr|d|d|dff|d<|S)aUpdate instance coordinates after letterboxing. Args: labels (dict[str, Any]): Dictionary containing 'instances'. params (dict): Parameters from get_params. Returns: (dict): Updated labels with transformed instances. rrrrr\ ratio_pad)rrrs r#rzLetterBox.apply_instances s| & ((&.RXY^R_aghtauvvF ::k " " Y#)+#6PU8W"XF;  r%rtuple[float, float]rrrr\c|dd|dj|ddd|dj||d|||S)aUpdate labels after applying letterboxing to an image. This method modifies the bounding box coordinates of instances in the labels to account for resizing and padding applied during letterboxing. Args: labels (dict[str, Any]): A dictionary containing image labels and instances. ratio (tuple[float, float]): Scaling ratios (width, height) applied to the image. padw (float): Padding width added to the image. padh (float): Padding height added to the image. orig_shape (tuple[int, int]): Original image shape (height, width) before resizing. Returns: (dict[str, Any]): Updated labels dictionary with modified instance coordinates. Examples: >>> letterbox = LetterBox(new_shape=(640, 640)) >>> labels = {"instances": Instances(...)} >>> ratio = (0.5, 0.5) >>> padw, padh = 10, 20 >>> updated_labels = letterbox._update_labels(labels, ratio, padw, padh, (480, 640)) rrrNr)rrr=r)r!rrrr\s r#rzLetterBox._update_labelssu4 {(((777'{'DDbD)9::!{!5)){''d333 r%)rrErrrrrrrKrrrKrrKrrKr)r!rrrDrCrrr) r!rhrrrrrrr\rErCrh)r-r.r/r0rN INTER_LINEARr7r$rrrrrrr'r%r#rrBs2&0   -!+!+!+!+!+F"""""H/ / / / b!!!!F. \r%rc\eZdZdZddfd Zdfd Zdfd ZdddZdddZdddZ xZ S) CopyPasteaUCopyPaste class for applying Copy-Paste augmentation to image datasets. This class implements the Copy-Paste augmentation technique as described in the paper "Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation" (https://arxiv.org/abs/2012.07177). It combines objects from different images to create new training samples. Attributes: dataset (Any): The dataset to which Copy-Paste augmentation will be applied. pre_transform (Callable | None): Optional transform to apply before Copy-Paste. p (float): Probability of applying Copy-Paste augmentation. Methods: get_params: Compute CopyPaste parameters including selected instances and mask. apply_image: Draw contours and paste pixels for CopyPaste. apply_instances: Concatenate selected instances for CopyPaste. Examples: >>> from ultralytics.data.augment import CopyPaste >>> dataset = YourDataset(...) # Your image dataset >>> copypaste = CopyPaste(dataset, p=0.5) >>> augmented_labels = copypaste(original_labels) NrrrgrmoderrCrOct||||dvsJd|d||_dS)z_Initialize CopyPaste object with dataset, pre_transform, and probability of applying CopyPaste.rd>rmixupz1Expected `mode` to be `flip` or `mixup`, but got rQN)rr7r)r rerfrgrr^s r#r7zCopyPaste.__init__UsT  KKK((((*e^b*e*e*e((( r%r!rhcdt|djdks |jdkr|S|jdkrY||}|||}|||}|||}|St |S)z9Apply Copy-Paste augmentation to an image and its labels.rrr) rSr/rgrrrrrrr$r s r#r$zCopyPaste.__call__[s vk"+ , , 1 1TVq[[M 9  __V,,F%%ff55F))&&99F((88FMww'''r%ci}|jdkr?t|}|digd}ni}|djdd\}}t |d}|d ||||r"t |dnd}|$t |}||t|j |j }tj |d k d d} t| } tj|d | } | | } | dt#|j| z} tj||ftj} ||d<||d <| |d <| |d<|d|d<|d|d<|S)zCompute CopyPaste parameters. Args: labels (dict[str, Any]): Input labels dictionary. Returns: (dict[str, Any]): Parameters including 'instances2', 'selected', and 'im_new'. rrkrrNrrrrg333333?rjr7selectedim_newr labels2_cls labels2_img)rrrrrrrrrrr+rr,rrSargsortrrrgzerosr)r r!r"r rrrr7ioarur sorted_idxrrr^s r#rzCopyPaste.get_paramsgs 9  WW''//Fjjt44Q7GGGe}"2A2&1VK011 f---a###;BLXgkk+66777  !),,J   a z()*:;;*cDj--a0011!4 LLZ 7 344 *%.U46A:.../1a&"(++'{)|%z!x ' E 2 2} ' E 2 2} r%r"rc|d}|d}|d}|d}|D]M}tj||j|gt jddtjN|d}|tj |d}|j d kr|d }|t} || || <||d<|S) zApply CopyPaste to the image. Args: labels (dict[str, Any]): Dictionary containing 'img'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels with pasted objects. rr7rrrrjrNrr`) rrN drawContoursr/r rr5FILLEDrrrdr) r r!r"imr7rrjresultrIs r#rzCopyPaste.apply_imagesE]   ! !L) *%! c cA  VZ%8!%=%D%DRX%N%NPRTUWZWa b b b bM** >Xb!__F ;!  I&F MM$  q 1u  r%c|d}|d}|d}|d}|d}|D]D}tj|||n||gfd}tj|||gfd}E||d<||d<|S) aApply CopyPaste to instances. Args: labels (dict[str, Any]): Dictionary containing 'instances' and 'cls'. params (dict | None): Parameters from get_params. Returns: (dict): Updated labels with concatenated instances. rr7rrrNrr)rrrr) r r!r"rr7rrrrs r#rzCopyPaste.apply_instancess;' L) *%Umjj//  T TA.#{7N TWZ[Y\']!^efgggC!-y*aS/.JQRSSSIIu '{ r%ch|d}||S|jdkr0|digddntj|d}||S|dt }|}||||<||d<|S)z/Apply CopyPaste to semantic segmentation masks.rNrrkrrjr)rrrNrr rr)r r!r"rsourcepasteds r#rzCopyPaste.apply_semanticszz/** <MKO9X_K_K_L2$//266GGGehemnrtuevev >M!((..yy{{f~V "& r%)NNrr)rgrrrrCrOrr,r) r-r.r/r0r7r$rrrrrrs@r#rr=s. ( ( ( ( ( ())))))V<0         r%rc$eZdZdZddd Zdd ZdS)Albumentationsa<Albumentations transformations for image augmentation. This class applies various image transformations using the Albumentations library. It includes operations such as Blur, Median Blur, conversion to grayscale, Contrast Limited Adaptive Histogram Equalization (CLAHE), random changes in brightness and contrast, RandomGamma, and image quality reduction through compression. Attributes: p (float): Probability of applying the transformations. transform (albumentations.Compose): Composed Albumentations transforms. contains_spatial (bool): Indicates if the transforms include spatial operations. Methods: __call__: Apply the Albumentations transformations to the input labels. Examples: >>> transform = Albumentations(p=0.5) >>> augmented_labels = transform(labels) Notes: - Requires Albumentations version 1.0.3 or higher. - Spatial transforms are handled differently to ensure bbox compatibility. - Some transforms are applied with very low probability (0.01) by default. rNrgrr6 list | NonerCrOc ||_d|_td} ddl}d|jd<ddl}t |jddhd ||d | d | d | d | d | d |d d gn|}tfd|D|_|jr-|||ddgn|||_t'|jdr+|jt+jt/j|dd|DzdS#t4$rYdSt6$r#}t/j||Yd}~dSd}~wwxYw)arInitialize the Albumentations transform object for YOLO bbox formatted parameters. This class applies various image augmentations using the Albumentations library, including Blur, Median Blur, conversion to grayscale, Contrast Limited Adaptive Histogram Equalization, random changes of brightness and contrast, RandomGamma, and image quality reduction through compression. Args: p (float): Probability of applying the augmentations. Must be between 0 and 1. transforms (list | None): List of custom Albumentations transforms. If None, uses default transforms. Nzalbumentations: r1NO_ALBUMENTATIONS_UPDATEz1.0.3T)hard>(D4CropFlipNoOprAffineLambdaResizeRotate Transpose XYMasking CenterCrop CropAndPad RandomCrop SafeRotate GridDropout MaskDropout PadIfNeeded Perspective RandomScale PixelDropout VerticalFlip CoarseDropout MorphologicalGridDistortionHorizontalFlipLongestMaxSizeRandomRotate90PiecewiseAffineRandomSizedCropSmallestMaxSizeElasticTransformShiftScaleRotateOpticalDistortionRandomGridShuffleRandomResizedCropBBoxSafeRandomCropRandomCropFromBordersRandomSizedBBoxSafeCropCropNonEmptyMaskIfExistsr%rgr)Kr) quality_rangergc34K|]}|jjvVdSr,)r^r-)rHr>spatial_transformss r#r~z*Albumentations.__init__..Ds0'n'n_h (;(DHZ(Z'n'n'n'n'n'nr%yolo class_labels)r label_fields) bbox_paramsset_random_seedr[c3RK|]"}|j |ddV#dS)zalways_apply=False, N)rgreplacers r#r~z*Albumentations.__init__..Ms>*h*hZ[dedg*ha6>>:PRT+U+U*h*h*h*h*h*hr%)rgr>r osenvironalbumentationsr __version__Blur MedianBlurToGrayCLAHERandomBrightnessContrast RandomGammaImageCompressionracontains_spatialr2 BboxParamshasattrr9torch initial_seedr infor_ ImportError Exception) r rgr6prefixr=ArXer4s @r#r7zAlbumentations.__init__sN,--Q ( III58BJ1 2 & & & & !-t < < < <)")")" l%FFTFNNLL4L((HHtH$$GGdGOO...55MMCM((&&Y#&FF  %('n'n'n'nlm'n'n'n$n$nD !(" !VSaRb)c)c dddYYq\\ N t~'899 E..u/A/C/CDDD K*h*h_`*h*h*h!h!hh i i i i i    DD ( ( ( K61 ' ' ' ' ' ' ' ' ' (sF)G H H!G??Hr!rhc |jtj|jkr|S|d}|jddkr|S|jr|d}t |r|dd|dj|jddddd|dj}|||| }t |d d krb|d |d<tj |d  dd |d<tj |dtj }|d |n%||dd |d<|S)a~Apply Albumentations transformations to input labels. This method applies a series of image augmentations using the Albumentations library. It can perform both spatial and non-spatial transformations on the input image and its corresponding labels. Args: labels (dict[str, Any]): A dictionary containing image data and annotations. Expected keys are: - 'img': np.ndarray representing the image - 'cls': np.ndarray of class labels - 'instances': object containing bounding boxes and other instance information Returns: (dict[str, Any]): The input dictionary with augmented image and updated annotations. Examples: >>> transform = Albumentations(p=0.5) >>> labels = { ... "img": np.random.rand(640, 640, 3), ... "cls": np.array([0, 1]), ... "instances": Instances(bboxes=np.array([[0, 0, 1, 1], [0.5, 0.5, 0.8, 0.8]])), ... } >>> augmented = transform(labels) >>> assert augmented["img"].shape == (640, 640, 3) Notes: - The method applies transformations with probability self.p. - Spatial transforms update bounding boxes, while non-spatial transforms only modify the image. - Requires the Albumentations library to be installed. Nrrrrrrr)rr+r6r6rrrjr+r)r+)r)r>rlrgrrHrSr normalizer+rarrayrvr*r)r r!rrr+news r#r$zAlbumentations.__call__Ssu< > !V]__tv%=%=M E] 8A;!  M   I-C3xx :{#00888-{#-rx|DDbD/ABB ,3nn2f3nOOs>*++a//$'LF5M$&HS-@$A$A$I$I"a$P$PF5MXc(m2:FFFF{#**&*999 NNN??HF5M r%)rN)rgrr6rrCrOr)r-r.r/r0r7r$r'r%r#rrsQ0`(`(`(`(`(D555555r%rcZeZdZdZ d)d*dZd+dZd,d-dZd,d-dZd.d!Zd/d(Z dS)0FormatazA class for formatting image annotations for object detection, instance segmentation, and pose estimation tasks. This class standardizes image and instance annotations to be used by the `collate_fn` in PyTorch DataLoader. Attributes: bbox_format (str): Format for bounding boxes. Options are 'xywh' or 'xyxy'. normalize (bool): Whether to normalize bounding boxes. return_mask (bool): Whether to return instance masks for segmentation. return_keypoint (bool): Whether to return keypoints for pose estimation. return_obb (bool): Whether to return oriented bounding boxes. mask_ratio (int): Downsample ratio for masks. mask_overlap (bool): Whether to overlap masks. batch_idx (bool): Whether to keep batch indexes. bgr (float): The probability to return BGR images. Methods: __call__: Format labels dictionary with image, classes, bounding boxes, and optionally masks and keypoints. _format_img: Convert image from Numpy array to PyTorch tensor. _format_segments: Convert polygon points to bitmap masks. Examples: >>> formatter = Format(bbox_format="xywh", normalize=True, return_mask=True) >>> formatted_labels = formatter(labels) >>> img = formatted_labels["img"] >>> bboxes = formatted_labels["bboxes"] >>> masks = formatted_labels["masks"] rTFrrrfrrTr return_maskreturn_keypoint return_obb mask_ratiorK mask_overlap batch_idxbgrrc ||_||_||_||_||_||_||_||_| |_dS)aInitialize the Format class with given parameters for image and instance annotation formatting. This class standardizes image and instance annotations for object detection, instance segmentation, and pose estimation tasks, preparing them for use in PyTorch DataLoader's `collate_fn`. Args: bbox_format (str): Format for bounding boxes. Options are 'xywh', 'xyxy', etc. normalize (bool): Whether to normalize bounding boxes to [0,1]. return_mask (bool): If True, returns instance masks for segmentation tasks. return_keypoint (bool): If True, returns keypoints for pose estimation tasks. return_obb (bool): If True, returns oriented bounding boxes. mask_ratio (int): Downsample ratio for masks. mask_overlap (bool): If True, allows mask overlap. batch_idx (bool): If True, keeps batch indexes. bgr (float): Probability of returning BGR images instead of RGB. N) rfrTrYrZr[r\r]r^r_) r rfrTrYrZr[r\r]r^r_s r#r7zFormat.__init__sK8'"&.$$("r%r!rhrCcl|d}||jddnd\}}|dtjg}|dd}|1||j||||||||rt|ndd S) aCompute formatting parameters shared across image and instance formatting. Extracts image dimensions and pops instance annotations from labels, converting bounding box format and denormalizing coordinates for downstream tensor creation. Args: labels (dict[str, Any]): Input labels dictionary containing 'img', 'cls', and 'instances'. Returns: (dict[str, Any]): Parameters including 'h', 'w', 'cls', 'instances', and 'nl'. rNrrIrrrr)rrrrnl) rrrnrrUrrfrrS)r r!rrrrrs r#rzFormat.get_paramssjj #sy!}}V1jj --JJ{D11   " "$*: " ; ; ;  ! !!Q ' ' 'Qs\eJl#i...klmmmr%Nr"rcf|dd}||||d<|S)aOFormat image from Numpy array to PyTorch tensor. Args: labels (dict[str, Any]): Dictionary containing 'img' as a numpy array. params (dict[str, Any] | None): Unused parameters for API compatibility. Returns: (dict[str, Any]): Updated labels with 'img' as a PyTorch tensor. rN)rn _format_imgrs r#rzFormat.apply_images8jj%% ? ,,S11F5M r%c>|dtjg}|d}| Jd|dd}|dd}|dd}|jr|r|||||\}}}t j|}t j|d } |jdr| s't j ||j z||j z} nB|j r%| |d d z } n|| ddddfzdj} |d d k} | rk|d } || ddddfz} | d z| |dk<| d }| || | | <nTt j |j rd n|||j z||j z}t j ||j z||j z} ||d <| |d<|rt j|nt j |d |d<|rt j|jnt j |df|d<|jrk|jt jddnt j|j|d<|jr,|ddxx|zcc<|ddxx|zcc<|jrQt5|jr&t9t j|jnt j d|d<|jr8|dddddgfxx|zcc<|dddd dgfxx|zcc<|jrt j ||d<|S)aFormat instance annotations into PyTorch tensors. Converts class labels, bounding boxes, masks, and keypoints into tensors suitable for collation in PyTorch DataLoader. Args: labels (dict[str, Any]): Dictionary to populate with formatted tensors. params (dict[str, Any]): Parameters from get_params containing 'h', 'w', 'cls', 'instances', 'nl'. Returns: (dict[str, Any]): Updated labels with formatted instance tensors. rrNz1instances are required for Format.apply_instancesrrrrbrj)dimrHrmasks sem_masksrr+rror|r})rrrr^)rrrUrY_format_segmentsrK from_numpyrrnumelrr\r]longrvaluesr-raargminrr+rZroemptyrTr[rSr/rr^)r r!r"rrrrrbrg cls_tensorrhoverlapweightsweighted_masks smallest_idxs r#rzFormat.apply_instancess>jj --JJ{++ $$&Y$$$ JJsA   JJsA   ZZa    4 T(,(=(=iaQR(S(S%y#(//"-ckk!nn== {1~ OZ-=-=-?-? O % A,@!tBV W WII& O *58==??Q+> ?II"'AAAtTM)B!B G G J J QI#iiAi..2G{{}}O"')))"8"8).D$1G)G5<[[]]Q5Fuz2'5'<'<'<'C'C -7 W8M-N '* ):$BAAADXZ[_c_nZnoo!KT_(RSS #F7O"+//"3"3F; 13K(---R9K9Ku AC]5+I,<===VXZ[U\I]I]x   1%.%8%@ Aq!!!eFVW`WjFkFk ; ~ 1{#F+++q0+++{#F+++q0+++ ? HKIL^H_H_xu/ 0BCCDDDejepqwexex 8  > - 8 QQQAY ' ' '1 , ' ' ' 8 QQQAY ' ' '1 , ' ' ' > 2"'+b//F;  r%rrD torch.Tensorc8t|jdkr|d}|ddd}tjt jdd|jkr|jddkr |dddn|}tj |}|S)aFormat an image for YOLO from a Numpy array to a PyTorch tensor. This function performs the following operations: 1. Ensures the image has 3 dimensions (adds a channel dimension if needed). 2. Transposes the image from HWC to CHW format. 3. Optionally reverses the color channels (e.g., BGR to RGB) based on the bgr probability. 4. Converts the image to a contiguous array. 5. Converts the Numpy array to a PyTorch tensor. Args: img (np.ndarray): Input image as a Numpy array with shape (H, W, C) or (H, W). Returns: (torch.Tensor): Formatted image as a PyTorch tensor with shape (C, H, W). Examples: >>> import numpy as np >>> img = np.random.rand(100, 100, 3) >>> formatted_img = self._format_img(img) >>> print(formatted_img.shape) torch.Size([3, 100, 100]) rr`rrrjNr) rSr transposerrrlrmr_rKrj)r rs r#rdzFormat._format_img4 s. sy>>A  i.CmmAq!$$"q!0D0Dtx0O0OTWT]^_T`deTeTe3ttt99knoos## r%rrrrr(tuple[np.ndarray, Instances, np.ndarray]c|j}|jr5t||f||j\}}|d}||}||}nt ||f|d|j}|||fS)aMConvert polygon segments to bitmap masks. Args: instances (Instances): Object containing segment information. cls (np.ndarray): Class labels for each instance. w (int): Width of the image. h (int): Height of the image. Returns: masks (np.ndarray): Bitmap masks with shape (N, H, W) or (1, H, W) if mask_overlap is True. instances (Instances): Updated instances object with sorted segments if mask_overlap is True. cls (np.ndarray): Updated class labels, sorted if mask_overlap is True. Notes: - If self.mask_overlap is True, masks are overlapped and sorted by area. - If self.mask_overlap is False, each mask is represented separately. - Masks are downsampled according to self.mask_ratio. )downsample_ratioNrj)colorrz)r/r]r r\r)r rrrrr/rgrs r#rizFormat._format_segmentsR s*%   ` 61vxZ^Zi j j j E:$KE!*-Ij/CC"Aq681t___Ei$$r%) rTFFFrTTr)rfrrTrrYrrZrr[rr\rKr]rr^rr_rrr,r)rrDrCru) rrrrDrrKrrKrCrx) r-r.r/r0r7rrrrdrir'r%r#rXrXs<"! % !$$$$$Lnnnn*     @@@@@D<%%%%%%r%rXc&eZdZdZd d dZd d d ZdS) SemanticFormatzFormat transform for semantic segmentation that converts images and masks to tensors. This transform handles the letterboxed semantic mask by resizing it to match the image dimensions and converts both to the appropriate tensor formats. Nr!rhr"rrCc |dd}||||d<|d}|Ftj|tj|d<|S)afFormat image and semantic mask for semantic segmentation. Args: labels (dict[str, Any]): Dictionary containing 'img' and 'semantic_mask'. params (dict[str, Any] | None): Unused parameters for API compatibility. Returns: (dict[str, Any]): Updated labels with 'img' and 'semantic_mask' as tensors. rNr)rnrdrrKrjrtor5)r r!r"rrs r#rzSemanticFormat.apply_imagez s|jj%% ? ,,S11F5Mzz/**  &+&6tyy{{&C&C&F&Fu{&S&SF? # r%c<dD]}||d|S)aCRemove instance-level keys not needed for semantic segmentation. Args: labels (dict[str, Any]): Dictionary to clean up. params (dict[str, Any] | None): Unused parameters for API compatibility. Returns: (dict[str, Any]): Updated labels with unused keys removed. )rrrrrN)rn)r r!r"rs r#rzSemanticFormat.apply_instances s0Q  A JJq$     r%r,r)r-r.r/r0rrr'r%r#r}r}s sP $       r%r}cReZdZdZdddZedd ZddZd dZ d!d"dZ dS)#LoadVisualPromptzCCreate visual prompts from bounding boxes or masks for model input.? scale_factorrrCrOc||_dS)zInitialize the LoadVisualPrompt with a scale factor. Args: scale_factor (float): Factor to scale the input image dimensions. N)r)r rs r#r7zLoadVisualPrompt.__init__ s )r%boxesrurrKrctj|dddddfdd\}}}}tj|ddddf}tj|ddddf}||k||kz||kz||kzS)a2Create binary masks from bounding boxes. Args: boxes (torch.Tensor): Bounding boxes in xyxy format, shape: (N, 4). h (int): Height of the mask. w (int): Width of the mask. Returns: (torch.Tensor): Binary masks with shape (N, h, w). Nrrj)rKchunkr) rrrrrrrrrs r# make_maskzLoadVisualPrompt.make_mask sU111aaa:%61==BB LOOD$M * LOOD!!!TM *RAF#qBw/1r6::r%r!rhc>|djdd}d\}}d|vr5|d}t|tj|gdz}n d|vr|d}|dd tj}||||d S) zCompute visual prompt parameters. Args: labels (dict[str, Any]): Input labels dictionary. Returns: (dict): Parameters including 'imgsz', 'bboxes', 'masks', and 'cls'. rrjNrr+)rjrrjrrgrr)rr+rgr)rrrKtensorrrrK)r r!rr+rgrs r#rzLoadVisualPrompt.get_params su #ABB'"  v  H%Fv&&e)<)<\\\)JJFF   7OEUm##B''**5955&5MMMr%r"cr||d|d|d|d}||d<|S)a#Create visual prompts and add them to labels. Args: labels (dict[str, Any]): Dictionary containing image data and annotations. params (dict): Parameters from get_params. Returns: (dict): Updated labels with visual prompts added. rrr+rg)r+rgvisuals) get_visuals)r r!r"rs r#rzLoadVisualPrompt.apply_image sD""6%=&/&QYJZbhipbq"rr#y r%Ncategoryint | np.ndarray | torch.TensorrrEr+np.ndarray | torch.Tensorrgct|d|jzt|d|jzf}|Yt|tjrt j|}||jz}|j|g|R}n|~t|tjrt j|}tj | d|d d}ntdt|t js t j|t j}t j|dd \}}t j|jdg|R}t'||D]#\} } t j|| | || <$|S) aiGenerate visual masks based on bounding boxes or masks. Args: category (int | np.ndarray | torch.Tensor): The category labels for the objects. shape (tuple[int, int]): The shape of the image (height, width). bboxes (np.ndarray | torch.Tensor, optional): Bounding boxes for the objects, xyxy format. masks (np.ndarray | torch.Tensor, optional): Masks for the objects. Returns: (torch.Tensor): A tensor containing the visual masks for each category. Raises: ValueError: If neither bboxes nor masks are provided. rrjNnearest)rz7LoadVisualPrompt must have bboxes or masks in the labelrT)sortedreturn_inverse)rKrr4rndarrayrKrjrrF interpolate unsqueezer ValueErrorTensorruniquerrrR logical_or) r rrr+rgmasksz cls_uniqueinverse_indicesrr2rs r#rzLoadVisualPrompt.get_visuals s*eAh!2233SqDDU9U5V5VW  &"*-- 2)&11 d' 'F"DN63F33399;;EE  %,, 0(//M%//!"4"4f9MMMUUVWXX^^``EEVWW W(EL11 ?|HEI>>>H&+l8DY]&^&^&^# O +j.q1;F;;;_e44 @ @IC +GCL$??GCLLr%)r)rrrCrO)rrurrKrrKrCrurrr) rrrrEr+rrgrrCru) r-r.r/r0r7rrrrrr'r%r#rr sMM)))));;;\;"NNNN(    $-1+/ ,,,,,,,r%rc8eZdZdZdddddgfddZddZddZdS)RandomLoadTextaRandomly sample positive and negative texts and update class indices accordingly. This class is responsible for sampling texts from a given set of class texts, including both positive (present in the image) and negative (not present in the image) samples. It updates the class indices to reflect the sampled texts and can optionally pad the text list to a fixed length. Attributes: prompt_format (str): Format string for text prompts. neg_samples (tuple[int, int]): Range for randomly sampling negative texts. max_samples (int): Maximum number of different text samples in one image. padding (bool): Whether to pad texts to max_samples. padding_value (list[str]): The text used for padding when padding is True. Methods: __call__: Process the input labels and return updated classes and texts. Examples: >>> loader = RandomLoadText(prompt_format="Object: {}", neg_samples=(5, 10), max_samples=20) >>> labels = {"cls": [0, 1, 2], "texts": [["cat"], ["dog"], ["bird"]], "instances": [...]} >>> updated_labels = loader(labels) >>> print(updated_labels["texts"]) ['Object: cat', 'Object: dog', 'Object: bird', 'Object: elephant', 'Object: car'] z{})PrrFr; prompt_formatr neg_samplesrE max_samplesrKpaddingrr list[str]rCrOcL||_||_||_||_||_dS)aInitialize the RandomLoadText class for randomly sampling positive and negative texts. This class is designed to randomly sample positive texts and negative texts, and update the class indices accordingly to the number of samples. It can be used for text-based object detection tasks. Args: prompt_format (str): Format string for the prompt. The format string should contain a single pair of curly braces {} where the text will be inserted. neg_samples (tuple[int, int]): A range to randomly sample negative texts. The first integer specifies the minimum number of negative samples, and the second integer specifies the maximum. max_samples (int): The maximum number of different text samples in one image. padding (bool): Whether to pad texts to max_samples. If True, the number of texts will always be equal to max_samples. padding_value (list[str]): The padding text to use when padding is True. N)rrrrr)r rrrrrs r#r7zRandomLoadText.__init__" s1.+&& *r%r!rhc d|vs Jd|d}t|}tj|dt}tj|t|jkrtj |jtt||jtz tj |j }fdt|D}tj ||}|z}dt|D}tjt|dt } g} t|d D]+\} } | |vr d | | <| || g,g} |D]s} || }t|d ksJ|j|tjt|}| |t|jrMtt|z}|j|z }|d kr| tj|j|z } t| |jksJ| tj| | d S) aCompute text sampling parameters. Args: labels (dict[str, Any]): Input labels dictionary containing 'texts', 'cls', and 'instances'. Returns: (dict): Parameters including 'valid_idx', 'new_cls', and 'texts'. rzzNo texts found in labels.rrrcg|]}|v| Sr'r')rHrI pos_labelss r#rJz-RandomLoadText.get_params..R s#KKKAq 7J7Ja7J7J7Jr%ci|]\}}|| Sr'r')rHrIrs r#rz-RandomLoadText.get_params..Y sHHH(!UUAHHHr%rrTr) valid_idxnew_clsrz)rSrr)rnrKrrXrrlsamplerrxrrrsrrrr=rr randrangerrrrU)r r! class_texts num_classesrr neg_labelssampled_labels label2idsrrrIrrzpromptsprompt valid_labels num_paddingrs @r#rzRandomLoadText.get_params? s&   "=   Wo +&& jE**#666Ys^^**,, z??T- - -zT5EFFFJ#k4+;<>> from ultralytics.data.dataset import YOLODataset >>> from ultralytics.utils import IterableSimpleNamespace >>> dataset = YOLODataset(img_path="path/to/images", imgsz=640) >>> hyp = IterableSimpleNamespace(mosaic=1.0, copy_paste=0.5, degrees=10.0, translate=0.2, scale=0.9) >>> transforms = v8_transforms(dataset, imgsz=640, hyp=hyp) >>> augmented_data = transforms(dataset[0]) >>> # With custom albumentations >>> import albumentations as A >>> augmentations = [A.Blur(p=0.01), A.CLAHE(p=0.01)] >>> hyp.augmentations = augmentations >>> transforms = v8_transforms(dataset, imgsz=640, hyp=hyp) )rrgNrCrrj)rgr)rfrgrr use_keypointsF kpt_shaperrzXNo 'flip_idx' array defined in data.yaml, disabling 'fliplr' and 'flipud' augmentations.zdata.yaml flip_idx=z& length must be equal to kpt_shape[0]=)rfrgr augmentations)rgr6rr)rrgrr)!rmosaicr:r;r<r=r?r@r2copy_paste_moder@r copy_paster=r:rgetattrrSrrr warningrrrrcutmixrrhsv_hhsv_shsv_vr) rerrrraffinerfrrs r# v8_transformsr sq<G5CJ 7 7 7F  -iiO#* 4eU^^ FVV,--M f$$Q 'S^#J] ^ ^ ^____ %vgUcj'Q'Q'QSY&Z[[.(       | B//Hw//sL$$[$77 x==A  3:#3#3szC7G7G&) )CJ Nu v v v v  s3x==IaL88q8qqclmncoqqrr r   '#) D D D 7-3: F F F SWS/4-P-P Q Q Q CISYci H H H szH M M M h O O O    r%BILINEARrAtuple[int, int] | intmeantuple[float, float, float]stdrr crop_fraction float | Nonec Dddlm}t|ttfrt |dkr|n||f}|rt d|d|dkr2||dt|j |g}n||g}|| || | tj|tj|gz }||S)aCreate a composition of image transforms for classification tasks. This function generates a sequence of torchvision transforms suitable for preprocessing images for classification models during evaluation or inference. The transforms include resizing, center cropping, conversion to tensor, and normalization. Args: size (tuple[int, int] | int): The target size for the transformed image. If an int, it defines the shortest edge. If a tuple, it defines (height, width). mean (tuple[float, float, float]): Mean values for each RGB channel used in normalization. std (tuple[float, float, float]): Standard deviation values for each RGB channel used in normalization. interpolation (str): Interpolation method of either 'NEAREST', 'BILINEAR' or 'BICUBIC'. crop_fraction (float | None): Deprecated, will be removed in a future version. Returns: (torchvision.transforms.Compose): A composition of torchvision transforms. Examples: >>> transforms = classify_transforms(size=224) >>> img = Image.open("path/to/image.jpg") >>> transformed_img = transforms(img) rNrz^'crop_fraction' arg of classify_transforms is deprecated, will be removed in a future version.rjrrr)torchvision.transformsr6r4rr5rSDeprecationWarningrrInterpolationModerToTensor NormalizerKrr2)rArrrrrX scale_sizetfls r#classify_transformsr s:'&&&&&#D5$-88]SYY!^^RVX\Q]J  l   !} 1 %%xx 1 WQ=PR_5`5`xaabxx ##$ALL   akku|D?Q?QW\WcdgWhWhk.i.i jjC 99S>>r%rrgQ?g?r=tuple[float, float] | Nonerhfliprvflip auto_augment str | Nonerrrforce_color_jittererasingcxddlm}t|tst d|dt |pd}t |pd}t |j| } ||||| g}|dkr)| | | |dkr)| | | g}d }|r)t|tsJd t|| }|d krFtr*| || nt!jdn|dkrFt$r*| || ntt!jdn_|dkrFt(r*| || n(t!jdnt-d|d|s,| || | | |||t5j|t5j||| dg}|||z|zS)aCreate a composition of image augmentation transforms for classification tasks. This function generates a set of image transformations suitable for training classification models. It includes options for resizing, flipping, color jittering, auto augmentation, and random erasing. Args: size (int): Target size for the image after transformations. mean (tuple[float, float, float]): Mean values for each RGB channel used in normalization. std (tuple[float, float, float]): Standard deviation values for each RGB channel used in normalization. scale (tuple[float, float] | None): Range of the proportion of the original image area to crop. ratio (tuple[float, float] | None): Range of aspect ratio for the cropped area. hflip (float): Probability of horizontal flip. vflip (float): Probability of vertical flip. auto_augment (str | None): Auto augmentation policy. Can be 'randaugment', 'augmix', 'autoaugment' or None. hsv_h (float): Image HSV-Hue augmentation factor. hsv_s (float): Image HSV-Saturation augmentation factor. hsv_v (float): Image HSV-Value augmentation factor. force_color_jitter (bool): Whether to apply color jitter even if auto augment is enabled. erasing (float): Probability of random erasing. interpolation (str): Interpolation method of either 'NEAREST', 'BILINEAR' or 'BICUBIC'. Returns: (torchvision.transforms.Compose): A composition of image augmentation transforms. Examples: >>> transforms = classify_augmentations(size=224, auto_augment="randaugment") >>> augmented_image = transforms(original_image) rNzclassify_augmentations() size z# must be integer, not (list, tuple))g{Gz?r)g?gUUUUUU?)r=rrrr0Fz1Provided argument should be string, but got type randaugmentrzH"auto_augment=randaugment" requires torchvision >= 0.11.0. Disabling it.augmixzC"auto_augment=augmix" requires torchvision >= 0.13.0. Disabling it. autoaugmentzH"auto_augment=autoaugment" requires torchvision >= 0.10.0. Disabling it.zInvalid auto_augment policy: zA. Should be one of "randaugment", "augmix", "autoaugment" or None) brightnesscontrast saturationrrT)rginplace)rr6r4rK TypeErrorrrrr+r=RandomHorizontalFlipRandomVerticalFliprrLr RandAugmentr rrAugMixr AutoAugmentr ColorJitterrrrKr RandomErasingr2)rArrr=rrrrrrrrrrrX primary_tfl secondary_tfldisable_color_jitter final_tfls r#classify_augmentationsr sZ'&&&&& dC dbbbbccc %&; ' 'E %11 2 2EA/??M&&t5Ub&ccdK s{{111E1::;;; s{{1//%/88999M ,,,vv.vbfgsbtbt.v.vvv,$65 = ( ( k$$Q]]]%O%OPPPPijjjj X % % f$$QXXMX%J%JKKKKdeeee ] * * k$$Q]]]%O%OPPPPijjjj3 333  kQ]]eeX]ch]iijjj  d++c1B1B CC '400I 99[=09< = ==r%c.eZdZdZddfd ZddZxZS)ClassifyLetterBoxawA class for resizing and padding images for classification tasks. This class is designed to be part of a transformation pipeline, e.g., T.Compose([LetterBox(size), ToTensor()]). It resizes and pads images to a specified size while maintaining the original aspect ratio. Attributes: h (int): Target height of the image. w (int): Target width of the image. auto (bool): If True, automatically calculates the short side using stride. stride (int): The stride value, used when 'auto' is True. Methods: __call__: Apply the letterbox transformation to an input image. Examples: >>> transform = ClassifyLetterBox(size=(640, 640), auto=False, stride=32) >>> img = np.random.randint(0, 255, (480, 640, 3), dtype=np.uint8) >>> result = transform(img) >>> print(result.shape) (640, 640, 3) rFrrAint | tuple[int, int]rrrrKctt|tr||fn|\|_|_||_||_dS)aInitialize the ClassifyLetterBox object for image preprocessing. This class is designed to be part of a transformation pipeline for image classification tasks. It resizes and pads images to a specified size while maintaining the original aspect ratio. Args: size (int | tuple[int, int]): Target size for the letterboxed image. If an int, a square image of (size, size) is created. If a tuple, it should be (height, width). auto (bool): If True, automatically calculates the short side based on stride. stride (int): The stride value, used when 'auto' is True. N)rr7r4rKrrrr)r rArrr^s r#r7zClassifyLetterBox.__init__ sQ )3D#)>)>H$D  r%rrDrCc|jdd\}}tj|z j|z }t ||zt ||z}}jrfd||fDn jjf\}}t ||z dz dz t ||z dz dz } } t j||dfd|j} tj |||ftj | | | |z| | |zf<| S) a'Resize and pad an image using the letterbox method. This method resizes the input image to fit within the specified dimensions while maintaining its aspect ratio, then pads the resized image to match the target size. Args: im (np.ndarray): Input image as a numpy array with shape (H, W, C). Returns: (np.ndarray): Resized and padded image as a numpy array with shape (hs, ws, 3), where hs and ws are the target height and width respectively. Examples: >>> letterbox = ClassifyLetterBox(size=(640, 640)) >>> image = np.random.randint(0, 255, (720, 1280, 3), dtype=np.uint8) >>> resized_image = letterbox(image) >>> print(resized_image.shape) (640, 640, 3) Nrc3`K|](}tj|jz jzV)dSr,)rPceilr)rHr|r s r#r~z-ClassifyLetterBox.__call__.. s:KKq$)A O,,t{:KKKKKKr%r&rrrr) rrrrrrrrrrNrr) r rimhimwrrrhswsrrim_outs ` r#r$zClassifyLetterBox.__call__ s(8BQB<S  dfsl + +S1W~~uS1W~~1PTynKKKKQFKKKK_c_egkgm^nB26Q,,--ub1f\C5G/H/HT"b!c:::14BAVYVf1g1g1gsS1W}dTAXo-. r%)rFr)rArrrrrK)rrDrCrDr-r.r/r0r7r$rrs@r#rrh s`,"r%rc.eZdZdZd d fd Zd d ZxZS)raApply center cropping to images for classification tasks. This class performs center cropping on input images, resizing them to a specified size while maintaining the aspect ratio. It is designed to be part of a transformation pipeline, e.g., T.Compose([CenterCrop(size), ToTensor()]). Attributes: h (int): Target height of the cropped image. w (int): Target width of the cropped image. Methods: __call__: Apply the center crop transformation to an input image. Examples: >>> transform = CenterCrop(640) >>> image = np.random.randint(0, 255, (1080, 1920, 3), dtype=np.uint8) >>> cropped_image = transform(image) >>> print(cropped_image.shape) (640, 640, 3) rrArctt|tr||fn|\|_|_dS)aInitialize the CenterCrop object for image preprocessing. This class is designed to be part of a transformation pipeline, e.g., T.Compose([CenterCrop(size), ToTensor()]). It performs a center crop on input images to a specified size. Args: size (int | tuple[int, int]): The desired output size of the crop. If size is an int, a square crop (size, size) is made. If size is a sequence like (h, w), it is used as the output size. N)rr7r4rKrr)r rAr^s r#r7zCenterCrop.__init__ sC )3D#)>)>H$Dr%rImage.Image | np.ndarrayrCrDc@t|tjrtj|}|jdd\}}t ||}||z dz||z dz}}t j||||z|||zf|j|j ft j S)aApply center cropping to an input image. This method crops the largest centered square from the image and resizes it to the specified dimensions. Args: im (np.ndarray | PIL.Image.Image): The input image as a numpy array of shape (H, W, C) or a PIL Image object. Returns: (np.ndarray): The center-cropped and resized image as a numpy array of shape (self.h, self.w, C). Examples: >>> transform = CenterCrop(size=224) >>> image = np.random.randint(0, 255, (640, 480, 3), dtype=np.uint8) >>> cropped_image = transform(image) >>> assert cropped_image.shape == (224, 224, 3) Nrr) r4rrr)rrrNrrrr)r rrrrrrs r#r$zCenterCrop.__call__ s$ b%+ & & BB8BQB<S SMM1WNS1WNTz"S37]D4!8O;N^a^noooor%)r)rAr)rr rCrDrrs@r#rr so( I I I I I I Ippppppppr%rc.eZdZdZd d fd Zd d ZxZS)ra*Convert an image from a numpy array to a PyTorch tensor. This class is designed to be part of a transformation pipeline, e.g., T.Compose([LetterBox(size), ToTensor()]). Attributes: half (bool): If True, converts the image to half precision (float16). Methods: __call__: Apply the tensor conversion to an input image. Examples: >>> transform = ToTensor(half=True) >>> img = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8) >>> tensor_img = transform(img) >>> print(tensor_img.shape, tensor_img.dtype) torch.Size([3, 640, 640]) torch.float16 Notes: The input image is expected to be in BGR format with shape (H, W, C). The output tensor will be in BGR format with shape (C, H, W), normalized to [0, 1]. FhalfrcVt||_dS)aInitialize the ToTensor object for converting images to PyTorch tensors. This class is designed to be used as part of a transformation pipeline for image preprocessing in the Ultralytics YOLO framework. It converts numpy arrays or PIL Images to PyTorch tensors, with an option for half-precision (float16) conversion. Args: half (bool): If True, converts the tensor to half precision (float16). N)rr7r )r r r^s r#r7zToTensor.__init__ s&  r%rrDrCructj|d}tj|}|jr|n|}|dz}|S)a_Transform an image from a numpy array to a PyTorch tensor. This method converts the input image from a numpy array to a PyTorch tensor, applying optional half-precision conversion and normalization. The image is transposed from HWC to CHW format. Args: im (np.ndarray): Input image as a numpy array with shape (H, W, C) in BGR order. Returns: (torch.Tensor): The transformed image as a PyTorch tensor in float32 or float16, normalized to [0, 1] with shape (C, H, W) in BGR order. Examples: >>> transform = ToTensor(half=True) >>> img = np.random.randint(0, 255, (640, 640, 3), dtype=np.uint8) >>> tensor_img = transform(img) >>> print(tensor_img.shape, tensor_img.dtype) torch.Size([3, 640, 640]) torch.float16 )rrrjgo@)rrrwrKrjr r)r rs r#r$zToTensor.__call__ s^( !",,y"9"9 : :  b ! !) 3RWWYYY e  r%F)r r)rrDrCrurrs@r#rr s`,       r%rr)rrKrr rr) rArrrrrrrrr)rArKrrrrr=rrrrrrrrrrrrrrrrrrrrr)> __future__rrPrlrrtypingrrNnumpyrrKPILrtorch.nnrrultralytics.data.utilsrr ultralytics.utilsr r r ultralytics.utils.checksr ultralytics.utils.instancerultralytics.utils.metricsrultralytics.utils.opsrrrultralytics.utils.torch_utilsrrr DEFAULT_MEAN DEFAULT_STDrr2rbrrrr:rrrrrrXr}rrrrrrrrr'r%r#rs#"""""   $$$$$$IIIIIIIIGGGGGGGGGG222222000000......HHHHHHHHHH^^^^^^^^^^  OOOOOOOOd[\[\[\[\[\[\[\[\|WWWWW}WWWtQQQQQ QQQh bbbbb bbbJjjjjj jjjZififififif ifififX JJJJJ JJJZzzzzzzzzzxxxxx xxxvXXXXX XXXvppppp]pppfe%e%e%e%e%]e%e%e%P%%%%%V%%%Pkkkkk}kkk\xxxxx]xxxvGGGGGX#&'3&1#"& .....f'3&1(,(,#$#c>c>c>c>c>NGGGGGGGGV9p9p9p9p9p9p9p9pz<<<<<<<<<<r%