hLSrSSKJr SSKrSSKJr SSKJrJrJ r J r SSK r SSK r SSKJrJr SSKJr SSKJr SS KJrJrJrJr SS KJr SS KJrJr SS K J!r!J"r" SS K#J$r$J%r% SS/r&"SS\"5r'"SS\"5r(g)aeTransforms that combine multiple images and their associated annotations. This module contains transformations that take multiple input sources (e.g., a primary image and additional images provided via metadata) and combine them into a single output. Examples include overlaying elements (`OverlayElements`) or creating complex compositions like `Mosaic`. ) annotationsN)deepcopy) AnnotatedAnyLiteralcast)AfterValidatormodel_validator)Self) functional) BboxProcessor check_bboxesdenormalize_bboxes filter_bboxes)KeypointsProcessor)check_range_bounds nondecreasing)BaseTransformInitSchema DualTransform)LENGTH_RAW_BBOXTargetsMosaicOverlayElementsc^\rSrSrSr\R \R4r"SS\ 5r S S U4Sjjjr \ SSj5r \SSj5rSSjrSS jrSS jrS rU=r$)ra;Apply overlay elements such as images and masks onto an input image. This transformation can be used to add various objects (e.g., stickers, logos) to images with optional masks and bounding boxes for better placement control. Args: metadata_key (str): Additional target key for metadata. Default `overlay_metadata`. p (float): Probability of applying the transformation. Default: 0.5. Possible Metadata Fields: - image (np.ndarray): The overlay image to be applied. This is a required field. - bbox (list[int]): The bounding box specifying the region where the overlay should be applied. It should contain four floats: [y_min, x_min, y_max, x_max]. If `label_id` is provided, it should be appended as the fifth element in the bbox. BBox should be in Albumentations format, that is the same as normalized Pascal VOC format [x_min / width, y_min / height, x_max / width, y_max / height] - mask (np.ndarray): An optional mask that defines the non-rectangular region of the overlay image. If not provided, the entire overlay image is used. - mask_id (int): An optional identifier for the mask. If provided, the regions specified by the mask will be labeled with this identifier in the output mask. Targets: image, mask Image types: uint8, float32 References: doc-augmentation: https://github.com/danaaubakirova/doc-augmentation Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Prepare primary data (base image and mask) >>> image = np.zeros((300, 300, 3), dtype=np.uint8) >>> mask = np.zeros((300, 300), dtype=np.uint8) >>> >>> # 1. Create a simple overlay image (a red square) >>> overlay_image1 = np.zeros((50, 50, 3), dtype=np.uint8) >>> overlay_image1[:, :, 0] = 255 # Red color >>> >>> # 2. Create another overlay with a mask (a blue circle with transparency) >>> overlay_image2 = np.zeros((80, 80, 3), dtype=np.uint8) >>> overlay_image2[:, :, 2] = 255 # Blue color >>> overlay_mask2 = np.zeros((80, 80), dtype=np.uint8) >>> # Create a circular mask >>> center = (40, 40) >>> radius = 30 >>> for i in range(80): ... for j in range(80): ... if (i - center[0])**2 + (j - center[1])**2 < radius**2: ... overlay_mask2[i, j] = 255 >>> >>> # 3. Create an overlay with both bbox and mask_id >>> overlay_image3 = np.zeros((60, 120, 3), dtype=np.uint8) >>> overlay_image3[:, :, 1] = 255 # Green color >>> # Create a rectangular mask with rounded corners >>> overlay_mask3 = np.zeros((60, 120), dtype=np.uint8) >>> cv2.rectangle(overlay_mask3, (10, 10), (110, 50), 255, -1) >>> >>> # Create the metadata list - each item is a dictionary with overlay information >>> overlay_metadata = [ ... { ... 'image': overlay_image1, ... # No bbox provided - will be placed randomly ... }, ... { ... 'image': overlay_image2, ... 'bbox': [0.6, 0.1, 0.9, 0.4], # Normalized coordinates [x_min, y_min, x_max, y_max] ... 'mask': overlay_mask2, ... 'mask_id': 1 # This overlay will update the mask with id 1 ... }, ... { ... 'image': overlay_image3, ... 'bbox': [0.1, 0.7, 0.5, 0.9], # Bottom left placement ... 'mask': overlay_mask3, ... 'mask_id': 2 # This overlay will update the mask with id 2 ... } ... ] >>> >>> # Create the transform >>> transform = A.Compose([ ... A.OverlayElements(p=1.0), ... ]) >>> >>> # Apply the transform >>> result = transform( ... image=image, ... mask=mask, ... overlay_metadata=overlay_metadata # Pass metadata using the default key ... ) >>> >>> # Get results with overlays applied >>> result_image = result['image'] # Image with the three overlays applied >>> result_mask = result['mask'] # Mask with regions labeled using the mask_id values >>> >>> # Let's verify the mask contains the specified mask_id values >>> has_mask_id_1 = np.any(result_mask == 1) # Should be True >>> has_mask_id_2 = np.any(result_mask == 2) # Should be True c \rSrSr%S\S'Srg)OverlayElements.InitSchemastr metadata_keyN)__name__ __module__ __qualname____firstlineno____annotations____static_attributes__r!h/var/www/fran/franai/venv/lib/python3.13/site-packages/albumentations/augmentations/mixing/transforms.py InitSchemarsr(r*c,>[TU]US9 XlgN)p)super__init__r )selfr r- __class__s r)r/OverlayElements.__init__s 1(r(cUR/$zGet list of targets that should be passed as parameters to transforms. Returns: list[str]: List containing the metadata key name r r0s r)targets_as_params!OverlayElements.targets_as_params!!""r(cUSnURSSupEUSSupgSU;GaUSn[R"U/5n [U 5 [ XSS5Sn SU SS5uppSU;a0USn[ R "XU - X- 4[ RS 9nO)[R"X- X- 4[RS 9n[ R "X=U - X- 4[ RS 9nX4n[U5[:XaS U;a XXUS /nOXX/USSQ7nOXd:dXu:a6[ R "X7U4[ RS 9nURSSupESU;aUSO"[R"U[RS 9nXu- nXd- nURSU5nURSU5nUU4nUUUU-UU-/nS U;a /UQUS PnUUUUS .nS U;aUS US 'U$)aProcess overlay metadata to prepare for application. Args: metadata (dict[str, Any]): Dictionary containing overlay data such as image, mask, bbox img_shape (tuple[int, int]): Shape of the target image as (height, width) random_state (random.Random): Random state object for reproducible randomness Returns: dict[str, Any]: Processed overlay data including resized overlay image, mask, offset coordinates, and bounding box information imageNbboxrc38# UHn[U5v M g7fN)int).0xs r) 6OverlayElements.preprocess_metadata..s)P:OQ#a&&:Osmask) interpolationdtypebbox_id) overlay_image overlay_maskoffsetr=mask_id)shapenparrayrrcv2resize INTER_NEARESTonesuint8 INTER_AREAlenr ones_likerandint)metadata img_shape random_staterKoverlay_height overlay_width image_height image_widthr=bbox_npdenormalized_bboxx_miny_minx_maxy_maxrFrM max_x_offset max_y_offsetoffset_xoffset_yresults r)preprocess_metadata#OverlayElements.preprocess_metadatasJ$!) (5(;(;BQ(?%$-bqM! X F#Dhhv&G  ! 27bqM J1 M )P:KBQ:O)P &E%!'zz$ (FVYVgVghww u}=RXXNJJ}u}em6TdgdrdrsM^F4yO+ X0EeHY4GHe>T!"X>, 0K # = :Ueheses t 0=0C0CBQ0G-'-'98F#r||Macaiai?jD&6L'8L#++A|) DH$33x 23+     ( 3F9  r(cX RnUSn[U[5(a/UVs/sHoPRXTUR5PM nnSU0$URX4UR5/nSU0$s snf)a;Generate parameters for overlay transform based on input data. Args: params (dict[str, Any]): Dictionary of existing parameters data (dict[str, Any]): Dictionary containing input data with image and metadata Returns: dict[str, Any]: Dictionary containing processed overlay data ready for application rO overlay_data)r isinstancelistrm py_random)r0paramsdatar[r\mdrps r)get_params_dependent_on_data,OverlayElements.get_params_dependent_on_datas))*7O h % %^fg^fXZ44RDNNS^fLg L  !44X$..YZL L  hs%A9c `UH'nUSnUSnUSn[R"XXgS9nM) U$)aApply overlay elements to the input image. Args: img (np.ndarray): Input image overlay_data (list[dict[str, Any]]): List of dictionaries containing overlay information **params (Any): Additional parameters Returns: np.ndarray: Image with overlays applied rKrLrM)rM)fmixingcopy_and_paste_blend)r0imgrprtrurKrLrMs r)applyOverlayElements.applysD"!D 1M/L(^F..s<_C !  r(c UHXnSU;dM UScMUSnUSnUSnUupXRS-n XRS-n XU 2X24n X|US:'MZ U$)a5Apply overlay masks to the input mask. Args: mask (np.ndarray): Input mask overlay_data (list[dict[str, Any]]): List of dictionaries containing overlay information **params (Any): Additional parameters Returns: np.ndarray: Mask with overlay masks applied using the specified mask_id values rNrLrMr)rO) r0rFrprtrurLrMrNrerdrgrf mask_sections r) apply_to_maskOverlayElements.apply_to_masks"!DD T)_%@#N3 hy/%  2 21 55 2 21 55#%K$<= 18\A-.! r(r5)overlay_metadata?)r rr-floatreturnz list[str])r[dict[str, Any]r\tuple[int, int]r]z random.Randomrrrtrrurrr)r| np.ndarrayrplist[dict[str, Any]]rtrrr)rFrrprrtrrr)r"r#r$r%__doc__rIMAGEMASK_targetsrr*r/propertyr7 staticmethodrmrwr}rr' __classcell__r1s@r)rrseN w||,H, /)) ))##M M"M$M  MM^ . +   0+   r(c ^\rSrSrSr\R \R\R\R4r "SS\ 5r SSSSS\ R\ RS S S S 4 SU4S jjjr\SS j5rSSjrSSjrSSjrSSjrS Sjr\S!Sj5rS"SjrS#SjrS$SjrS%SjrS&SjrSrU=r $)'ri=aCombine multiple images and their annotations into a single image using a mosaic grid layout. This transform takes a primary input image (and its annotations) and combines it with additional images/annotations provided via metadata. It calculates the geometry for a mosaic grid, selects additional items, preprocesses annotations consistently (handling label encoding updates), applies geometric transformations, and assembles the final output. Args: grid_yx (tuple[int, int]): The number of rows (y) and columns (x) in the mosaic grid. Determines the maximum number of images involved (grid_yx[0] * grid_yx[1]). Default: (2, 2). target_size (tuple[int, int]): The desired output (height, width) for the final mosaic image. after cropping the mosaic grid. cell_shape (tuple[int, int]): cell shape of each cell in the mosaic grid. metadata_key (str): Key in the input dictionary specifying the list of additional data dictionaries for the mosaic. Each dictionary in the list should represent one potential additional item. Expected keys: 'image' (required, np.ndarray), and optionally 'mask' (np.ndarray), 'bboxes' (np.ndarray), 'keypoints' (np.ndarray), and any relevant label fields (e.g., 'class_labels') corresponding to those specified in `Compose`'s `bbox_params` or `keypoint_params`. Default: "mosaic_metadata". center_range (tuple[float, float]): Range [0.0-1.0] to sample the center point of the mosaic view relative to the valid central region of the conceptual large grid. This affects which parts of the assembled grid are visible in the final crop. Default: (0.3, 0.7). interpolation (int): OpenCV interpolation flag used for resizing images during geometric processing. Default: cv2.INTER_LINEAR. mask_interpolation (int): OpenCV interpolation flag used for resizing masks during geometric processing. Default: cv2.INTER_NEAREST. fill (tuple[float, ...] | float): Value used for padding images if needed during geometric processing. Default: 0. fill_mask (tuple[float, ...] | float): Value used for padding masks if needed during geometric processing. Default: 0. p (float): Probability of applying the transform. Default: 0.5. Workflow (`get_params_dependent_on_data`): 1. Calculate Geometry & Visible Cells: Determine which grid cells are visible in the final `target_size` crop and their placement coordinates on the output canvas. 2. Validate Raw Additional Metadata: Filter the list provided via `metadata_key`, keeping only valid items (dicts with an 'image' key). 3. Select Subset of Raw Additional Metadata: Choose a subset of the valid raw items based on the number of visible cells requiring additional data. 4. Preprocess Selected Raw Additional Items: Preprocess bboxes/keypoints for the *selected* additional items *only*. This uses shared processors from `Compose`, updating their internal state (e.g., `LabelEncoder`) based on labels in these selected items. 5. Prepare Primary Data: Extract preprocessed primary data fields from the input `data` dictionary into a `primary` dictionary. 6. Determine & Perform Replication: If fewer additional items were selected than needed, replicate the preprocessed primary data as required. 7. Combine Final Items: Create the list of all preprocessed items (primary, selected additional, replicated primary) that will be used. 8. Assign Items to VISIBLE Grid Cells 9. Process Geometry & Shift Coordinates: For each assigned item: a. Apply geometric transforms (Crop, Resize, Pad) to image/mask. b. Apply geometric shift to the *preprocessed* bboxes/keypoints based on cell placement. 10. Return Parameters: Return the processed cell data (image, mask, shifted bboxes, shifted kps) keyed by placement coordinates. Label Handling: - The transform relies on `bbox_processor` and `keypoint_processor` provided by `Compose`. - `Compose.preprocess` initially fits the processors' `LabelEncoder` on the primary data. - This transform (`Mosaic`) preprocesses the *selected* additional raw items using the same processors. If new labels are found, the shared `LabelEncoder` state is updated via its `update` method. - `Compose.postprocess` uses the final updated encoder state to decode all labels present in the mosaic output for the current `Compose` call. - The encoder state is transient per `Compose` call. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Reference: YOLOv4: Optimal Speed and Accuracy of Object Detection: https://arxiv.org/pdf/2004.10934 Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Prepare primary data >>> primary_image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> primary_mask = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> primary_bboxes = np.array([[10, 10, 40, 40], [50, 50, 90, 90]], dtype=np.float32) >>> primary_labels = [1, 2] >>> >>> # Prepare additional images for mosaic >>> additional_image1 = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> additional_mask1 = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> additional_bboxes1 = np.array([[20, 20, 60, 60]], dtype=np.float32) >>> additional_labels1 = [3] >>> >>> additional_image2 = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> additional_mask2 = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> additional_bboxes2 = np.array([[30, 30, 70, 70]], dtype=np.float32) >>> additional_labels2 = [4] >>> >>> additional_image3 = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> additional_mask3 = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> additional_bboxes3 = np.array([[5, 5, 45, 45]], dtype=np.float32) >>> additional_labels3 = [5] >>> >>> # Create metadata for additional images - structured as a list of dicts >>> mosaic_metadata = [ ... { ... 'image': additional_image1, ... 'mask': additional_mask1, ... 'bboxes': additional_bboxes1, ... 'labels': additional_labels1 ... }, ... { ... 'image': additional_image2, ... 'mask': additional_mask2, ... 'bboxes': additional_bboxes2, ... 'labels': additional_labels2 ... }, ... { ... 'image': additional_image3, ... 'mask': additional_mask3, ... 'bboxes': additional_bboxes3, ... 'labels': additional_labels3 ... } ... ] >>> >>> # Create the transform with Mosaic >>> transform = A.Compose([ ... A.Mosaic( ... grid_yx=(2, 2), ... target_size=(200, 200), ... cell_shape=(120, 120), ... center_range=(0.4, 0.6), ... fit_mode="cover", ... p=1.0 ... ), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['labels'])) >>> >>> # Apply the transform >>> transformed = transform( ... image=primary_image, ... mask=primary_mask, ... bboxes=primary_bboxes, ... labels=primary_labels, ... mosaic_metadata=mosaic_metadata # Pass the metadata using the default key ... ) >>> >>> # Access the transformed data >>> mosaic_image = transformed['image'] # Combined mosaic image >>> mosaic_mask = transformed['mask'] # Combined mosaic mask >>> mosaic_bboxes = transformed['bboxes'] # Combined and repositioned bboxes >>> mosaic_labels = transformed['labels'] # Combined labels from all images c\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S \S 'S\S'S\S'S\S'\"SS9SSj5rSrg)Mosaic.InitSchemairgrid_yxzGAnnotated[tuple[int, int], AfterValidator(check_range_bounds(1, None))] target_size cell_shaperr zgAnnotated[tuple[float, float], AfterValidator(check_range_bounds(0, 1)), AfterValidator(nondecreasing)] center_rangeLiteral[cv2.INTER_NEAREST, cv2.INTER_NEAREST_EXACT, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4, cv2.INTER_LINEAR_EXACT]rGmask_interpolationtuple[float, ...] | floatfill fill_maskLiteral['cover', 'contain']fit_modeafter)modecURSURS-URS:d0URSURS-URS:a [S5eU$)Nrrz;Target size should be smaller than cell cell_size * grid_yx)rrr ValueErrorr6s r)_check_cell_shape#Mosaic.InitSchema._check_cell_shapesg"T\\!_4t7G7G7JJ??1% Q7$:J:J1:MM !^__Kr(r!N)rr )r"r#r$r%r&r rr'r!r(r)r*rsm            (',,-- g &  ' r(r*)r<r<)r)g333333?gffffff?coverrmosaic_metadatarc >[T U]U S9 XlX lXlX@lX`lXplXlXl XPl X0l gr,) r.r/rrr rrGrrrrr) r0rrrrrrGrrrr r-r1s r)r/Mosaic.__init__ sL< 1 &((*"4 " $r(cUR/$r4r5r6s r)r7Mosaic.targets_as_params4r9r(c[R"URURURUR UR S9n[R"URURURUS9$)N)rrrrrs)rrr center_xy)rzcalculate_mosaic_center_pointrrrrrscalculate_cell_placements)r0rurs r)_calculate_geometryMosaic._calculate_geometry>sh99LL((**nn  00LL((   r(c[R"URUR5URU5n[ U5U:aUR R X25$U$r?)rzfilter_valid_metadatagetr rXrssample)r0runum_additional_needed valid_itemss r)_select_additional_itemsMosaic._select_additional_itemsOsV33DHHT=N=N4OQUQbQbdhi { 3 3>>((L Lr(cSU;dSU;aM[SURS55n[SURS55n[R"XU5$[S[ U55$)Nbboxes keypointsr r!list[fmixing.ProcessedMosaicItem])r get_processorrz preprocess_selected_mosaic_itemsrr)r0additional_itemsrubbox_processorkeypoint_processors r)_preprocess_additional_items#Mosaic._preprocess_additional_itemsUsl t {d2!/43E3Eh3OPN!%&:DN9OPPr(c[SU[U5- 5n[U5Vs/sHn[U5PM nnU/UQUQ$s snf)Nr)maxrXranger)r0primaryr num_needednum_replications_ replicateds r)_prepare_final_itemsMosaic._prepare_final_items`sW q*s3C/D"DE167G1HI1HAhw'1H I8*8Z88JsAc URU5n[U5n[SUS- 5nURX%5nUR Xb5nUR U5nUR XU5n [R"[U 5UURS9n [R"URURU U URURb URO URURUR UR"S9 n SU;dSU;a[R$"XRS9n XR'USR(5S .n S U;a!UR'US R(5U S 'U $) zPOrchestrates the steps to calculate mosaic parameters by calling helper methods.rr) num_itemscell_placementsrs) canvas_shaperplacement_to_item_indexfinal_items_for_gridrrrrGrrr)rr;)processed_cells target_shaperFtarget_mask_shape)rrXrrrget_primary_datarrzassign_items_to_grid_cellsrsprocess_all_mosaic_geometriesrrrrrrGrshift_all_coordinates_get_target_shaperO) r0rtrur num_cellsrrpreprocessed_additionalr final_itemsrrrls r)rw#Mosaic.get_params_dependent_on_datajsg2248( #Ay1} 588U"&"C"CDT"[''-//Rgh ")"D"D+&+nn#  "??))$;!,(,(Bdnn ]],,#66   t {d2%;;OZjZjkO%4F\F\]abi]j]p]pFqr T>*.*@*@fASAS*TF& ' r(cURS5nUbUR5nURS5nUbUR5nURS5nUbUR5nUSUUUS.$)zGet a copy of the primary data (data passed in `data` parameter) to avoid modifying the original data. Args: data (dict[str, Any]): Dictionary containing the primary data. Returns: fmixing.ProcessedMosaicItem: A copy of the primary data. rFrrr;)r;rFrr)rcopy)rurFrrs r)rMosaic.get_primary_datas|xx  99;D(#  [[]FHH[)  !(I']"   r(cd[U5nURSUS'URSUS'U$)Nrr)rrr)r0np_shapers r)rMosaic._get_target_shapes9H~ **1- Q**1- Qr(c Z[R"UUURSURS9$)a_Apply mosaic transformation to the input image. Args: img (np.ndarray): Input image processed_cells (dict[tuple[int, int, int, int], dict[str, Any]]): Dictionary of processed cell data target_shape (tuple[int, int]): Shape of the target image. **params (Any): Additional parameters Returns: np.ndarray: Mosaic transformed image r;rrrIdata_keyr)rz$assemble_mosaic_from_processed_cellsrIr)r0r|rrrts r)r} Mosaic.applys.&;;+%))   r(c Z[R"UUURSURS9$)akApply mosaic transformation to the input mask. Args: mask (np.ndarray): Input mask. processed_cells (dict): Dictionary of processed cell data containing cropped/padded mask segments. target_mask_shape (tuple[int, int]): Shape of the target mask. **params (Any): Additional parameters (unused). Returns: np.ndarray: Mosaic transformed mask. rFr)rzrrIr)r0rFrrrts r)rMosaic.apply_to_masks.&;;+***   r(c r/nUR5H+nUSnURS:dMURU5 M- U(d.[R"SUR S4UR S9$[R"USS9n[SURS55nURSURSS.n [UU URRURRURRURR URR"S9$) aApplies mosaic transformation to bounding boxes. Args: bboxes (np.ndarray): Original bounding boxes (ignored). processed_cells (dict): Dictionary mapping placement coords to processed cell data (containing shifted bboxes in absolute pixel coords). **params (Any): Additional parameters (unused). Returns: np.ndarray: Final combined, filtered, bounding boxes. rrrrHaxisr )heightwidth)min_areamin_visibility min_width min_heightmax_accept_ratio)valuessizeappendrPemptyrOrI concatenaterrrrrtrrrrr) r0rrrtall_shifted_bboxes cell_datashifted_bboxescombined_bboxesr shape_dicts r)apply_to_bboxesMosaic.apply_to_bboxess$ (//1I&x0N""Q&")).92 "88Q Q0 E E..);!Dot/A/A(/KL&&q)%%a(F   #**33)00??$++55%,,77+22CC  r(c /nUR5H+nUSnURS:dMURU5 M- U(d.[R"SUR S4UR S9$[R"USS9nURupUSS2S4S:USS2S4U :-USS2S4S:-USS2S4U:-n Xz$)asApplies mosaic transformation to keypoints. Args: keypoints (np.ndarray): Original keypoints (ignored). processed_cells (dict): Dictionary mapping placement coords to processed cell data (containing shifted keypoints). **params (Any): Additional parameters (unused). Returns: np.ndarray: Final combined, filtered keypoints. rrrrHrN) rrrrPrrOrIrr) r0rrrtall_shifted_keypointsrshifted_keypointscombined_keypointstarget_htarget_w valid_indicess r)apply_to_keypointsMosaic.apply_to_keypointss$!#(//1I )+ 6  %%)%,,->?2 %88Q  239??K K^^,AJ"-- 1 % *!!Q$'(2 4!!Q$'1, ."!Q$'(2 4 "00r() rrrrrrrGrr r)rrrrrrrztuple[float, float]rrrGrrrrrrrr rr-rrNoner)rurrzlist[tuple[int, int, int, int]])rurrr@rr)rrrurrr)rfmixing.ProcessedMosaicItemrrrr@rrr)rurrr)rztuple[int, ...]rz list[int]) r|rr/dict[tuple[int, int, int, int], dict[str, Any]]rrrtrrr) rFrrrrrrtrrr)rrrrrtrrr)rrrrrtrrr)!r"r#r$r%rrrrBBOXES KEYPOINTSrrr*rR INTER_LINEARrTr/rr7rrrrrwrrrr}rrrr'rrs@r)rr=sEXt w||W^^W=N=NOH-,-b$*'1&0,607      *+/0-9)% )%%)%$ )% * )% . )% )%  !)%2(3)%4-5)%67)%8 9)%: ;)%)%V## " Q. Q Q + Q9,9<9 9 + 9&P  4   I &      6  I +      6. . I.  .  . `'1'1I'1 '1  '1'1r())r __future__rrandomrrtypingrrrrrRnumpyrPpydanticr r typing_extensionsr #albumentations.augmentations.mixingr rzalbumentations.core.bbox_utilsr rrr#albumentations.core.keypoints_utilsralbumentations.core.pydanticrr(albumentations.core.transforms_interfacerr$albumentations.core.type_definitionsrr__all__rrr!r(r)r%sd# 00 4"EiiBJ[I & '\m\~C1]C1r(