h^)SrSSKJr SSKrSSKJrJrJrJr SSK J r SSK r SSK r SSKJrJrJr SSKJrJrJrJrJr SSKJr SS KJr SS KJrJrJr SS K J!r!J"r"J#r#J$r$ SS K%J&r&J'r' SS K(J)r) SSK*J+r+ SSK,J-r. /SQr/Sr0Sr1"SS\'5r2"SS\'5r3"SS\35r4"SS\'5r5"SS\'5r6"SS\'5r7g) aGeometric transformation classes for image augmentation. This module provides a collection of transforms that modify the geometric properties of images and associated data (masks, bounding boxes, keypoints). Includes implementations for flipping, transposing, affine transformations, distortions, padding, and more complex transformations like grid shuffling and thin plate splines. ) annotationsN) AnnotatedAnyLiteralcast)warn)batch_transformis_grayscale_image is_rgb_image)AfterValidatorFieldValidationInfofield_validatormodel_validator)Self) check_range) BboxProcessordenormalize_bboxesnormalize_bboxes)NonNegativeFloatRangeTypeOnePlusIntRangeTypeSymmetricRangeTypecheck_range_bounds)BaseTransformInitSchema DualTransform) ALL_TARGETSto_tuple) functional)AffineGridElasticDeform Morphological PerspectiveRandomGridShuffleShiftScaleRotatec ^\rSrSrSr\r"SS\5rSSS\ R\ R\ RSSS 4 SU4S jjjr SS jr\"S SSS 9SSj5r\"S SSS 9SSj5r\"S SSS 9SSj5r\"S SSS 9SSj5rSSjrSSjrSSjrS SjrSrU=r$)!r$=aApply random four point perspective transformation to the input. Args: scale (float or tuple of float): Standard deviation of the normal distributions. These are used to sample the random distances of the subimage's corners from the full image's corners. If scale is a single float value, the range will be (0, scale). Default: (0.05, 0.1). keep_size (bool): Whether to resize image back to its original size after applying the perspective transform. If set to False, the resulting images may end up having different shapes. Default: True. border_mode (OpenCV flag): OpenCV border mode used for padding. Default: cv2.BORDER_CONSTANT. fill (tuple[float, ...] | float): Padding value if border_mode is cv2.BORDER_CONSTANT. Default: 0. fill_mask (tuple[float, ...] | float): Padding value for mask if border_mode is cv2.BORDER_CONSTANT. Default: 0. fit_output (bool): If True, the image plane size and position will be adjusted to still capture the whole image after perspective transformation. This is followed by image resizing if keep_size is set to True. If False, parts of the transformed image may be outside of the image plane. This setting should not be set to True when using large scale values as it could lead to very large images. Default: False. interpolation (int): Interpolation method to be used for image transformation. Should be one of the OpenCV interpolation types. Default: cv2.INTER_LINEAR mask_interpolation (int): Flag that is used to specify the interpolation algorithm for mask. Should be one of: cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4. Default: cv2.INTER_NEAREST. p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, keypoints, bboxes, volume, mask3d Image types: uint8, float32 Note: This transformation creates a perspective effect by randomly moving the four corners of the image. The amount of movement is controlled by the 'scale' parameter. When 'keep_size' is True, the output image will have the same size as the input image, which may cause some parts of the transformed image to be cut off or padded. When 'fit_output' is True, the transformation ensures that the entire transformed image is visible, which may result in a larger output image if keep_size is False. Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Prepare sample data >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> mask = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> bboxes = np.array([[10, 10, 50, 50], [40, 40, 80, 80]], dtype=np.float32) >>> bbox_labels = [1, 2] >>> keypoints = np.array([[20, 30], [60, 70]], dtype=np.float32) >>> keypoint_labels = [0, 1] >>> >>> # Define transform with parameters as tuples when possible >>> transform = A.Compose([ ... A.Perspective( ... scale=(0.05, 0.1), ... keep_size=True, ... fit_output=False, ... border_mode=cv2.BORDER_CONSTANT, ... p=1.0 ... ), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['bbox_labels']), ... keypoint_params=A.KeypointParams(format='xy', label_fields=['keypoint_labels'])) >>> >>> # Apply the transform >>> transformed = transform( ... image=image, ... mask=mask, ... bboxes=bboxes, ... bbox_labels=bbox_labels, ... keypoints=keypoints, ... keypoint_labels=keypoint_labels ... ) >>> >>> # Get the transformed data >>> transformed_image = transformed['image'] # Perspective-transformed image >>> transformed_mask = transformed['mask'] # Perspective-transformed mask >>> transformed_bboxes = transformed['bboxes'] # Perspective-transformed bounding boxes >>> transformed_bbox_labels = transformed['bbox_labels'] # Labels for transformed bboxes >>> transformed_keypoints = transformed['keypoints'] # Perspective-transformed keypoints >>> transformed_keypoint_labels = transformed['keypoint_labels'] # Labels for transformed keypoints cf\rSrSr%S\S'S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'Srg)Perspective.InitSchemarscalebool keep_size fit_outputaLiteral[cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4] interpolationmask_interpolationtuple[float, ...] | floatfill fill_maskoLiteral[cv2.BORDER_CONSTANT, cv2.BORDER_REPLICATE, cv2.BORDER_REFLECT, cv2.BORDER_WRAP, cv2.BORDER_REFLECT_101] border_modeN__name__ __module__ __qualname____firstlineno____annotations____static_attributes__r:k/var/www/fran/franai/venv/lib/python3.13/site-packages/albumentations/augmentations/geometric/transforms.py InitSchemar,s?((    (',,  rBrD)g?皙?TFr?c >[T U]U 5 [SU5UlX lX`lXplXlX0lX@l XPl g)Ntuple[float, float]) super__init__rr.r0r9r6r7r1r3r4) selfr.r0r1r3r4r9r6r7p __class__s rCrJPerspective.__init__sG< /7 "& "$*"4rBc [R"UUUUURURURUR 5$)aLApply the perspective transform to an image. Args: img (np.ndarray): Image to be distorted. matrix (np.ndarray): Transformation matrix. max_height (int): Maximum height of the image. max_width (int): Maximum width of the image. **params (Any): Additional parameters. Returns: np.ndarray: Distorted image. ) fgeometric perspectiver6r9r0r3)rKimgmatrix max_height max_widthparamss rCapplyPerspective.applysC*%%     II    NN     rBspatial has_batch_dim has_depth_dimc (UR"U40UD6$)zApply the perspective transform to a batch of images. Args: images (np.ndarray): Batch of images to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Batch of distorted images. rWrKimagesrVs rCapply_to_imagesPerspective.apply_to_imageszz&+F++rBc (UR"U40UD6$)zApply the perspective transform to a volume. Args: volume (np.ndarray): Volume to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted volume. r^rKvolumerVs rCapply_to_volumePerspective.apply_to_volume rcrBc (UR"U40UD6$)zApply the perspective transform to a batch of volumes. Args: volumes (np.ndarray): Batch of volumes to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Batch of distorted volumes. r^rKvolumesrVs rCapply_to_volumesPerspective.apply_to_volumeszz',V,,rBc (UR"U40UD6$)zApply the perspective transform to a 3D mask. Args: mask3d (np.ndarray): 3D mask to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted 3D mask.  apply_to_maskrKmask3drVs rCapply_to_mask3dPerspective.apply_to_mask3d'!!&3F33rBc [R"UUUUURURURUR 5$)aGApply the perspective transform to a mask. Args: mask (np.ndarray): Mask to be distorted. matrix (np.ndarray): Transformation matrix. max_height (int): Maximum height of the mask. max_width (int): Maximum width of the mask. **params (Any): Additional parameters. Returns: np.ndarray: Distorted mask. )rPrQr7r9r0r4)rKmaskrSrTrUrVs rCrqPerspective.apply_to_mask5sC*%%     NN    NN  # #  rBc R[R"UUSUUUUR5$)aApply the perspective transform to a batch of bounding boxes. Args: bboxes (np.ndarray): Batch of bounding boxes to be distorted. matrix_bbox (np.ndarray): Transformation matrix. max_height (int): Maximum height of the bounding boxes. max_width (int): Maximum width of the bounding boxes. **params (Any): Additional parameters. Returns: np.ndarray: Batch of distorted bounding boxes. shape)rPperspective_bboxesr0)rKbboxes matrix_bboxrTrUrVs rCapply_to_bboxesPerspective.apply_to_bboxesUs1*,,  7O    NN   rBc R[R"UUSUUUUR5$)aApply the perspective transform to a batch of keypoints. Args: keypoints (np.ndarray): Batch of keypoints to be distorted. matrix (np.ndarray): Transformation matrix. max_height (int): Maximum height of the keypoints. max_width (int): Maximum width of the keypoints. **params (Any): Additional parameters. Returns: np.ndarray: Batch of distorted keypoints. r{)rPperspective_keypointsr0)rK keypointsrSrTrUrVs rCapply_to_keypointsPerspective.apply_to_keypointsss1*//  7O    NN   rBc`USSSnURR"UR6n[R"UUUR 5n[R "U5n[R"UU5upgnUR(a[R"UU5upgnUUUUS.$)Get the parameters dependent on the data. Args: params (dict[str, Any]): Parameters. data (dict[str, Any]): Data. Returns: dict[str, Any]: Parameters. r{Nr')rSrTrUr~) py_randomuniformr.rPgenerate_perspective_pointsrandom_generator order_pointscompute_perspective_paramsr1expand_transform) rKrVdata image_shaper.pointsrSrUrTs rCget_params_dependent_on_data(Perspective.get_params_dependent_on_datasWobq) && 377    ! !  ((0(2(M(M  ) %: ??,6,G,G- )Fz $"!   rB)r9r6r7r1r3r0r4r.)r.tuple[float, float] | floatr0r/r1r/r3r2r4r2r9r8r6r5r7r5rLfloat) rR np.ndarrayrSrrTintrUrrVrreturnrr`rrVrrrrfrrVrrrrkrrVrrrrsrrVrrr) rxrrSrrTrrUrrVrrr) r}rr~rrTrrUrrVrrr) rrrSrrTrrUrrVrrrrVdict[str, Any]rrrr)r<r=r>r?__doc__r_targetsrrDcv2 INTER_LINEAR INTER_NEARESTBORDER_CONSTANTrJrWr rargrlrtrqrrrrA __classcell__rMs@rCr$r$=sRWrH , <.9          *+/09&5*&5&5 &5  &5 &5& '&54(5&56-7&58 9&5&5P           @Yd%H ,I ,Ye4H ,I ,Yd$G -H -Yd%H 4I 4           @            <           <) ) )   ) ) rBr$c,^\rSrSrSr\r"SS\5rSSSSS\ R\ RS S S S \ RS S S 4SU4S jjjr SSjrS SjrS!SjrS"Sjr\"SSS S9S#Sj5r\"SS SS9S$Sj5r\"SSSS9S%Sj5r\"SSS S9S&Sj5r\S'Sj5rS(SjrS)SjrS*SjrSrU=r$)+r!ia(Augmentation to apply affine transformations to images. Affine transformations involve: - Translation ("move" image on the x-/y-axis) - Rotation - Scaling ("zoom" in/out) - Shear (move one side of the image, turning a square into a trapezoid) All such transformations can create "new" pixels in the image without a defined content, e.g. if the image is translated to the left, pixels are created on the right. A method has to be defined to deal with these pixel values. The parameters `fill` and `fill_mask` of this class deal with this. Some transformations involve interpolations between several pixels of the input image to generate output pixel values. The parameters `interpolation` and `mask_interpolation` deals with the method of interpolation used for this. Args: scale (number, tuple of number or dict): Scaling factor to use, where ``1.0`` denotes "no change" and ``0.5`` is zoomed out to ``50`` percent of the original size. * If a single number, then that value will be used for all images. * If a tuple ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. That the same range will be used for both x- and y-axis. To keep the aspect ratio, set ``keep_ratio=True``, then the same value will be used for both x- and y-axis. * If a dictionary, then it is expected to have the keys ``x`` and/or ``y``. Each of these keys can have the same values as described above. Using a dictionary allows to set different values for the two axis and sampling will then happen *independently* per axis, resulting in samples that differ between the axes. Note that when the ``keep_ratio=True``, the x- and y-axis ranges should be the same. translate_percent (None, number, tuple of number or dict): Translation as a fraction of the image height/width (x-translation, y-translation), where ``0`` denotes "no change" and ``0.5`` denotes "half of the axis size". * If ``None`` then equivalent to ``0.0`` unless `translate_px` has a value other than ``None``. * If a single number, then that value will be used for all images. * If a tuple ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]``. That sampled fraction value will be used identically for both x- and y-axis. * If a dictionary, then it is expected to have the keys ``x`` and/or ``y``. Each of these keys can have the same values as described above. Using a dictionary allows to set different values for the two axis and sampling will then happen *independently* per axis, resulting in samples that differ between the axes. translate_px (None, int, tuple of int or dict): Translation in pixels. * If ``None`` then equivalent to ``0`` unless `translate_percent` has a value other than ``None``. * If a single int, then that value will be used for all images. * If a tuple ``(a, b)``, then a value will be uniformly sampled per image from the discrete interval ``[a..b]``. That number will be used identically for both x- and y-axis. * If a dictionary, then it is expected to have the keys ``x`` and/or ``y``. Each of these keys can have the same values as described above. Using a dictionary allows to set different values for the two axis and sampling will then happen *independently* per axis, resulting in samples that differ between the axes. rotate (number or tuple of number): Rotation in degrees (**NOT** radians), i.e. expected value range is around ``[-360, 360]``. Rotation happens around the *center* of the image, not the top left corner as in some other frameworks. * If a number, then that value will be used for all images. * If a tuple ``(a, b)``, then a value will be uniformly sampled per image from the interval ``[a, b]`` and used as the rotation value. shear (number, tuple of number or dict): Shear in degrees (**NOT** radians), i.e. expected value range is around ``[-360, 360]``, with reasonable values being in the range of ``[-45, 45]``. * If a number, then that value will be used for all images as the shear on the x-axis (no shear on the y-axis will be done). * If a tuple ``(a, b)``, then two value will be uniformly sampled per image from the interval ``[a, b]`` and be used as the x- and y-shear value. * If a dictionary, then it is expected to have the keys ``x`` and/or ``y``. Each of these keys can have the same values as described above. Using a dictionary allows to set different values for the two axis and sampling will then happen *independently* per axis, resulting in samples that differ between the axes. interpolation (int): OpenCV interpolation flag. mask_interpolation (int): OpenCV interpolation flag. fill (tuple[float, ...] | float): The constant value to use when filling in newly created pixels. (E.g. translating by 1px to the right will create a new 1px-wide column of pixels on the left of the image). The value is only used when `mode=constant`. The expected value range is ``[0, 255]`` for ``uint8`` images. fill_mask (tuple[float, ...] | float): Same as fill but only for masks. border_mode (int): OpenCV border flag. fit_output (bool): If True, the image plane size and position will be adjusted to tightly capture the whole image after affine transformation (`translate_percent` and `translate_px` are ignored). Otherwise (``False``), parts of the transformed image may end up outside the image plane. Fitting the output shape can be useful to avoid corners of the image being outside the image plane after applying rotations. Default: False keep_ratio (bool): When True, the original aspect ratio will be kept when the random scale is applied. Default: False. rotate_method (Literal["largest_box", "ellipse"]): rotation method used for the bounding boxes. Should be one of "largest_box" or "ellipse"[1]. Default: "largest_box" balanced_scale (bool): When True, scaling factors are chosen to be either entirely below or above 1, ensuring balanced scaling. Default: False. This is important because without it, scaling tends to lean towards upscaling. For example, if we want the image to zoom in and out by 2x, we may pick an interval [0.5, 2]. Since the interval [0.5, 1] is three times smaller than [1, 2], values above 1 are picked three times more often if sampled directly from [0.5, 2]. With `balanced_scale`, the function ensures that half the time, the scaling factor is picked from below 1 (zooming out), and the other half from above 1 (zooming in). This makes the zooming in and out process more balanced. p (float): probability of applying the transform. Default: 0.5. Targets: image, mask, keypoints, bboxes, volume, mask3d Image types: uint8, float32 References: Towards Rotation Invariance in Object Detection: https://arxiv.org/abs/2109.13488 Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Prepare sample data >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> mask = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> bboxes = np.array([[10, 10, 50, 50], [40, 40, 80, 80]], dtype=np.float32) >>> bbox_labels = [1, 2] >>> keypoints = np.array([[20, 30], [60, 70]], dtype=np.float32) >>> keypoint_labels = [0, 1] >>> >>> # Define transform with different parameter types >>> transform = A.Compose([ ... A.Affine( ... # Tuple for scale (will be used for both x and y) ... scale=(0.8, 1.2), ... # Dictionary with tuples for different x/y translations ... translate_percent={"x": (-0.2, 0.2), "y": (-0.1, 0.1)}, ... # Tuple for rotation range ... rotate=(-30, 30), ... # Dictionary with tuples for different x/y shearing ... shear={"x": (-10, 10), "y": (-5, 5)}, ... # Interpolation methods ... interpolation=cv2.INTER_LINEAR, ... mask_interpolation=cv2.INTER_NEAREST, ... # Other parameters ... fit_output=False, ... keep_ratio=True, ... rotate_method="largest_box", ... balanced_scale=True, ... border_mode=cv2.BORDER_CONSTANT, ... fill=0, ... fill_mask=0, ... p=1.0 ... ), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['bbox_labels']), ... keypoint_params=A.KeypointParams(format='xy', label_fields=['keypoint_labels'])) >>> >>> # Apply the transform >>> transformed = transform( ... image=image, ... mask=mask, ... bboxes=bboxes, ... bbox_labels=bbox_labels, ... keypoints=keypoints, ... keypoint_labels=keypoint_labels ... ) >>> >>> # Get the transformed data >>> transformed_image = transformed['image'] # Image with affine transforms applied >>> transformed_mask = transformed['mask'] # Mask with affine transforms applied >>> transformed_bboxes = transformed['bboxes'] # Bounding boxes with affine transforms applied >>> transformed_bbox_labels = transformed['bbox_labels'] # Labels for transformed bboxes >>> transformed_keypoints = transformed['keypoints'] # Keypoints with affine transforms applied >>> transformed_keypoint_labels = transformed['keypoint_labels'] # Labels for transformed keypoints >>> >>> # Simpler example with only essential parameters >>> simple_transform = A.Compose([ ... A.Affine( ... scale=1.1, # Single scalar value for scale ... rotate=15, # Single scalar value for rotation (degrees) ... translate_px=30, # Single scalar value for translation (pixels) ... p=1.0 ... ), ... ]) >>> simple_result = simple_transform(image=image) >>> simple_transformed = simple_result['image'] cP\rSrSr%S\S'S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S \S'S\S'S\S'S\S'S\S'S\S'\"S S5\S Sj55r\"S5\S!Sj55r\ "SS9S"Sj5r \ S#S$Sjj5r Sr g)%Affine.InitSchemaioDtuple[float, float] | float | dict[str, float | tuple[float, float]]r.Ktuple[float, float] | float | dict[str, float | tuple[float, float]] | Nonetranslate_percent translate_pxrrotateshearr2r3r4r5r6r7r8r9r/r1 keep_ratio!Literal['largest_box', 'ellipse'] rotate_methodbalanced_scalec8URXR5$N)_handle_dict_arg field_name)clsvalueinfos rC_process_shear Affine.InitSchema._process_shears''? ?rBc[X5$rr)rrs rC_process_rotate!Affine.InitSchema._process_rotates E) )rBaftermodecJURcURcSUlURbURb Sn[U5eURb URURSSS9UlURb URURSSS9UlU$)NrzYExpected either translate_percent or translate_px to be provided, but both were provided.r)defaultr)rr ValueErrorr)rKmsgs rC_handle_translate#Affine.InitSchema._handle_translates%%-$2C2C2K$%!%%1d6G6G6Sq o%%%1)-)>)>**'*?*&   ,$($9$9%%"%:%! KrBc>[U[5(aX4X4S.$[U[5(aVSU;aSU;a[SUS35eUR SU5nUR SU5n[ X35[ XD5S.$[ X5[ X5S.$)Nxyrrz Expected zJ dictionary to contain at least key "x" or key "y". Found neither of them.) isinstancerdictrgetr)valnamerrrs rCr"Affine.InitSchema._handle_dict_args#u%%!Zsj99#t$$c>cn$#D6)stGGC)GGC)%a^(1.AA!#+(32DE ErB)rrN)rrrrrdict[str, tuple[float, float]])rrrrHrr)?)rzytuple[float, float] | dict[str, float | tuple[float, float]] | float | tuple[int, int] | dict[str, int | tuple[int, int]]rz str | Nonerrrr)r<r=r>r?r@r classmethodrrrr staticmethodrrAr:rBrCrDros;SSffaa++SS    (',,  88 ' *  @W @! @,  @  + @  "  *. *! *  # * g &  ' 0 ! F/ F   F F, F  FrBrD)rrNr)rrF largest_boxrrFc>[TU]US9 X`lXplXlXlXl[SU5Ul[SU5Ul [SU5Ul [SU5Ul Xl [SU5Ul XlXlXlUR(a9URSURS:wa[#SUR35egg)NrLrzdict[str, tuple[int, int]]rHrrzJWhen keep_ratio is True, the x and y scale range should be identical. got )rIrJr3r4r6r7r9rr.rrrr1rrrrr)rKr.rrrrr3r4r1rrrr9r6r7rLrMs rCrJAffine.__init__sH 1*"4 "&:EB !%&FHY!Z !=|L0&9 $:EB $*, ??tzz#$**S/A\]a]g]g\hi  B?rBc p[R"UUURURURUS9$)aApply the affine transform to an image. Args: img (np.ndarray): Image to be distorted. matrix (np.ndarray): Transformation matrix. output_shape (tuple[int, int]): Output shape. **params (Any): Additional parameters. Returns: np.ndarray: Distorted image. r3r6r9 output_shape)rP warp_affiner3r6r9)rKrRrSrrVs rCrW Affine.apply s9&%%  ,,((%   rBc p[R"UUURURURUS9$)aApply the affine transform to a mask. Args: mask (np.ndarray): Mask to be distorted. matrix (np.ndarray): Transformation matrix. output_shape (tuple[int, int]): Output shape. **params (Any): Additional parameters. Returns: np.ndarray: Distorted mask. r)rPrr4r7r9)rKrxrSrrVs rCrqAffine.apply_to_mask)s9&%%  11((%   rBc l[R"UUURUSSSURU5$)a5Apply the affine transform to bounding boxes. Args: bboxes (np.ndarray): Bounding boxes to be distorted. bbox_matrix (np.ndarray): Transformation matrix. output_shape (tuple[int, int]): Output shape. **params (Any): Additional parameters. Returns: np.ndarray: Distorted bounding boxes. r{Nr')rP bboxes_affinerr9)rKr} bbox_matrixrrVs rCrAffine.apply_to_bboxesEs@&''      7OBQ        rBc P[R"UUUSUUR5$)aApply the affine transform to keypoints. Args: keypoints (np.ndarray): Keypoints to be distorted. matrix (np.ndarray): Transformation matrix. scale (dict[str, float]): Scale. **params (Any): Additional parameters. Returns: np.ndarray: Distorted keypoints. r{)rPkeypoints_affiner9)rKrrSr.rVs rCrAffine.apply_to_keypointsas0&**   7O       rBrYTrZc (UR"U40UD6$)zApply the affine transform to a batch of images. Args: images (np.ndarray): Images to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted images. r^r_s rCraAffine.apply_to_images|rcrBc (UR"U40UD6$)zApply the affine transform to a volume. Args: volume (np.ndarray): Volume to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted volume. r^res rCrgAffine.apply_to_volumercrBc (UR"U40UD6$)zApply the affine transform to a batch of volumes. Args: volumes (np.ndarray): Volumes to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted volumes. r^rjs rCrlAffine.apply_to_volumesrnrBc (UR"U40UD6$)zApply the affine transform to a 3D mask. Args: mask3d (np.ndarray): 3D mask to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted 3D mask. rprrs rCrtAffine.apply_to_mask3drvrBc0nUR5HupV[U[[45(a[U5XE'M/[U[5(a|U(abUSS:aUSS4OSnUSS:aSUS4OSnUbUbUR Xx/5n OUbUn O UbUn OSXE'MUR "U 6XE'MUR "U6XE'M[SUSUS35e U(aUSUS'U$) NrrrzInvalid scale value for key z: z,. Expected a float or a tuple of two floats.rr)itemsrrrtuplechoicer TypeError) r.rr random_state result_scalekeyrlower_intervalupper_intervalselected_intervals rC _get_scaleAffine._get_scales" ++-JC%#u..$)%L !E5))!8=a1 eAh_$N8=a1 c58_$N%1n6P,8,?,?+<-)(3,:)'3,:),/ ) (4(<(<>O(PL%(4(<(r?rrrrrDrrrrrJrWrqrrr rargrlrtrrrrrrArrs@rCr!r!sm^HbF,bFLWaimX\.1V`        ;H$   *+/0E8S8g8V 8 , 8 T 8 8 8*+8,-8.9/80182 38@(A8B-C8D E88t   &      8   &      8    &      8         6Yd%H ,I ,Ye4H ,I ,Yd$G -H -Yd%H 4I 4&-&&&$ &  &&P? ? ?   ? B 8  rBr!c ^\rSrSrSr\r"SS\5rSSS\ R\ RSSS \ RS S S 4 SU4S jjjr SS jrSrU=r$)r&i4a"Randomly apply affine transforms: translate, scale and rotate the input. Args: shift_limit ((float, float) or float): shift factor range for both height and width. If shift_limit is a single float value, the range will be (-shift_limit, shift_limit). Absolute values for lower and upper bounds should lie in range [-1, 1]. Default: (-0.0625, 0.0625). scale_limit ((float, float) or float): scaling factor range. If scale_limit is a single float value, the range will be (-scale_limit, scale_limit). Note that the scale_limit will be biased by 1. If scale_limit is a tuple, like (low, high), sampling will be done from the range (1 + low, 1 + high). Default: (-0.1, 0.1). rotate_limit ((int, int) or int): rotation range. If rotate_limit is a single int value, the range will be (-rotate_limit, rotate_limit). Default: (-45, 45). interpolation (OpenCV flag): flag that is used to specify the interpolation algorithm. Should be one of: cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4. Default: cv2.INTER_LINEAR. border_mode (OpenCV flag): flag that is used to specify the pixel extrapolation method. Should be one of: cv2.BORDER_CONSTANT, cv2.BORDER_REPLICATE, cv2.BORDER_REFLECT, cv2.BORDER_WRAP, cv2.BORDER_REFLECT_101. Default: cv2.BORDER_CONSTANT fill (tuple[float, ...] | float): padding value if border_mode is cv2.BORDER_CONSTANT. fill_mask (tuple[float, ...] | float): padding value if border_mode is cv2.BORDER_CONSTANT applied for masks. shift_limit_x ((float, float) or float): shift factor range for width. If it is set then this value instead of shift_limit will be used for shifting width. If shift_limit_x is a single float value, the range will be (-shift_limit_x, shift_limit_x). Absolute values for lower and upper bounds should lie in the range [-1, 1]. Default: None. shift_limit_y ((float, float) or float): shift factor range for height. If it is set then this value instead of shift_limit will be used for shifting height. If shift_limit_y is a single float value, the range will be (-shift_limit_y, shift_limit_y). Absolute values for lower and upper bounds should lie in the range [-, 1]. Default: None. rotate_method (str): rotation method used for the bounding boxes. Should be one of "largest_box" or "ellipse". Default: "largest_box" mask_interpolation (OpenCV flag): Flag that is used to specify the interpolation algorithm for mask. Should be one of: cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4. Default: cv2.INTER_NEAREST. p (float): probability of applying the transform. Default: 0.5. Targets: image, mask, keypoints, bboxes, volume, mask3d Image types: uint8, float32 Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Prepare sample data >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> mask = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> bboxes = np.array([[10, 10, 50, 50], [40, 40, 80, 80]], dtype=np.float32) >>> bbox_labels = [1, 2] >>> keypoints = np.array([[20, 30], [60, 70]], dtype=np.float32) >>> keypoint_labels = [0, 1] >>> >>> # Define transform with parameters as tuples when possible >>> transform = A.Compose([ ... A.ShiftScaleRotate( ... shift_limit=(-0.0625, 0.0625), ... scale_limit=(-0.1, 0.1), ... rotate_limit=(-45, 45), ... interpolation=cv2.INTER_LINEAR, ... border_mode=cv2.BORDER_CONSTANT, ... rotate_method="largest_box", ... p=1.0 ... ), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['bbox_labels']), ... keypoint_params=A.KeypointParams(format='xy', label_fields=['keypoint_labels'])) >>> >>> # Apply the transform >>> transformed = transform( ... image=image, ... mask=mask, ... bboxes=bboxes, ... bbox_labels=bbox_labels, ... keypoints=keypoints, ... keypoint_labels=keypoint_labels ... ) >>> >>> # Get the transformed data >>> transformed_image = transformed['image'] # Shifted, scaled and rotated image >>> transformed_mask = transformed['mask'] # Shifted, scaled and rotated mask >>> transformed_bboxes = transformed['bboxes'] # Shifted, scaled and rotated bounding boxes >>> transformed_bbox_labels = transformed['bbox_labels'] # Labels for transformed bboxes >>> transformed_keypoints = transformed['keypoints'] # Shifted, scaled and rotated keypoints >>> transformed_keypoint_labels = transformed['keypoint_labels'] # Labels for transformed keypoints c\rSrSr%S\S'S\S'S\S'S\S'S\S 'S \S 'S \S 'S \S'S \S'S\S'S\S'\"SS9SSj5r\"S5\SSj55r Sr g)ShiftScaleRotate.InitSchemair shift_limit scale_limit rotate_limitr2r3r8r9r5r6r7"tuple[float, float] | float | None shift_limit_x shift_limit_yrrr4rrc6Sn[URb URO UR5Ul[UR/UQSP76 [URb URO UR5Ul[UR/UQSP76 U$)N)rrr )rrrrr )rKboundss rC_check_shift_limit.ShiftScaleRotate.InitSchema._check_shift_limitsF!)&*&8&8&D""$JZJZ"D  ** EV E_ E!)&*&8&8&D""$JZJZ"D  ** EV E_ EKrBcvS[S54n[USS9n[U/UQ[UR5P76 U$)Nrinfrbias)rrrstrr)rrrr#results rC_check_scale_limit.ShiftScaleRotate.InitSchema._check_scale_limits=e _Fe#.F  > >T__)= >MrB)rr Nr)rrrrrrH) r<r=r>r?r@rr$rrr,rAr:rBrCrDrs''''((    (',,999988   g &  '   '  . ! !    ( rBrD)gg?)grE)i-NrrrFc  >[SU5n[SU5n[T U] UXgS.USUU U U USSUU S9 [S[SS9 X`lXpl[SU5Ul[S U5UlXPl Xl Xl g) NrHr)rrF) r.rrrr3r4r6r7r9r1rrrLz\ShiftScaleRotate is a special case of Affine transform. Please use Affine transform instead.r') stacklevelr) rrIrJr UserWarningrr rrr9r6r7)rKrrrr3r9rr rr4r6r7rLrMs rCrJShiftScaleRotate.__init__s62MB 2MB  $1F'1#'   j  +* 5{C !2LA& "rBc URUR[URSS9URUR UR URURURURS. $)zoGet the transform initialization arguments. Returns: dict[str, Any]: Transform initialization arguments. gr() rr rrr3r9r6r7rr4) rr rrrr3r9r6r7rr4rs rCget_transform_init_args(ShiftScaleRotate.get_transform_init_argssk"//!//#D$4$44@ --!//++II!//"&"9"9  rB)r9r6r7rrrr )rrrrrrr3r2r9rrrr rrrr4r2r6r5r7r5rLr)rr)r<r=r>r?rrrrrDrrrrrJr4rArrs@rCr&r&4sVpH:,:|4E3>4=   ..<@<@;H   *+/038#08#18#2 8#  8#8#:8#:8#98#  !8#.(/8#0-18#2 38#8#t  rBr&c ^\rSrSrSr\r"SS\5r\ R\ RS4SU4Sjjjr \ SSj5rSSjrSS jrSS jrSS jrSS jrS rU=r$)r"iaM Apply elastic deformations to images, masks, bounding boxes, and keypoints using a grid-based approach. This transformation overlays a grid on the input and applies random displacements to the grid points, resulting in local elastic distortions. The granularity and intensity of the distortions can be controlled using the dimensions of the overlaying distortion grid and the magnitude parameter. Args: num_grid_xy (tuple[int, int]): Number of grid cells along the width and height. Specified as (grid_width, grid_height). Each value must be greater than 1. magnitude (int): Maximum pixel-wise displacement for distortion. Must be greater than 0. interpolation (int): Interpolation method to be used for the image transformation. Default: cv2.INTER_LINEAR mask_interpolation (int): Interpolation method to be used for mask transformation. Default: cv2.INTER_NEAREST p (float): Probability of applying the transform. Default: 1.0. Targets: image, mask, bboxes, keypoints, volume, mask3d Image types: uint8, float32 Number of channels: 1, 3 Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Prepare sample data >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> mask = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> bboxes = np.array([[10, 10, 50, 50], [40, 40, 80, 80]], dtype=np.float32) >>> bbox_labels = [1, 2] >>> keypoints = np.array([[20, 30], [60, 70]], dtype=np.float32) >>> keypoint_labels = [0, 1] >>> >>> # Define transform with parameters as tuples when possible >>> transform = A.Compose([ ... A.GridElasticDeform( ... num_grid_xy=(4, 4), ... magnitude=10, ... interpolation=cv2.INTER_LINEAR, ... mask_interpolation=cv2.INTER_NEAREST, ... p=1.0 ... ), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['bbox_labels']), ... keypoint_params=A.KeypointParams(format='xy', label_fields=['keypoint_labels'])) >>> >>> # Apply the transform >>> transformed = transform( ... image=image, ... mask=mask, ... bboxes=bboxes, ... bbox_labels=bbox_labels, ... keypoints=keypoints, ... keypoint_labels=keypoint_labels ... ) >>> >>> # Get the transformed data >>> transformed_image = transformed['image'] # Elastically deformed image >>> transformed_mask = transformed['mask'] # Elastically deformed mask >>> transformed_bboxes = transformed['bboxes'] # Elastically deformed bounding boxes >>> transformed_bbox_labels = transformed['bbox_labels'] # Labels for transformed bboxes >>> transformed_keypoints = transformed['keypoints'] # Elastically deformed keypoints >>> transformed_keypoint_labels = transformed['keypoint_labels'] # Labels for transformed keypoints Note: This transformation is particularly useful for data augmentation in medical imaging and other domains where elastic deformations can simulate realistic variations. cJ\rSrSr%S\S'\"SS9rS\S'S\S 'S\S 'S rg ) GridElasticDeform.InitSchemaihGAnnotated[tuple[int, int], AfterValidator(check_range_bounds(1, None))] num_grid_xyr)gtr magnituder2r3r4r:N)r<r=r>r?r@r r<rAr:rBrCrDr8hs*\\! 3$    rBrDrcP>[TU]US9 XlX lX0lX@lgNr)rIrJr:r<r3r4)rKr:r<r3r4rLrMs rCrJGridElasticDeform.__init__zs,( 1&"*"4rBcR[R"URSS5U45$)Nr"r()nphstackreshape)polygons dimensionss rC_generate_mesh GridElasticDeform._generate_meshs#yy*,,R3X>??rBc USSSn[R"UURUR5n[R "UVs/sHnUSUSUSUS/PM sn5R URSSS2S-5n[R"UURUR5nURXv5nS U0$s snf) rr{Nr'rrr")r(generated_mesh) rPsplit_uniform_gridr:rrAarrayrC generate_distorted_grid_polygonsr<rF) rKrVrrtilestilerErDrJs rCr.GridElasticDeform.get_params_dependent_on_datasWobq) --      ! ! XX" "D GGGG  "    '   TrT "T )  >>  NN  ! !  ,,XB .11+ s Cc [U5(d[U5(d [S5e[R"XUR 5$)zApply the GridElasticDeform transform to an image. Args: img (np.ndarray): Image to be transformed. generated_mesh (np.ndarray): Generated mesh. **params (Any): Additional parameters. zKGridElasticDeform transform is only supported for RGB and grayscale images.)r r rrP distort_imager3)rKrRrJrVs rCrWGridElasticDeform.applys?C  );C)@)@jk k''T=O=OPPrBc D[R"XUR5$)zApply the GridElasticDeform transform to a mask. Args: mask (np.ndarray): Mask to be transformed. generated_mesh (np.ndarray): Generated mesh. **params (Any): Additional parameters. )rPrRr4)rKrxrJrVs rCrqGridElasticDeform.apply_to_masks''d>U>UVVrBc [XSSS5n[[R"UUUSSS5USSS5$)zApply the GridElasticDeform transform to bounding boxes. Args: bboxes (np.ndarray): Bounding boxes to be transformed. generated_mesh (np.ndarray): Generated mesh. **params (Any): Additional parameters. r{Nr')rrrPbbox_distort_image)rKr}rJrV bboxes_denorms rCr!GridElasticDeform.apply_to_bboxessX+6'?2A3FG   ) )w#  7OBQ    rBc >[R"UUUSSS5$)zApply the GridElasticDeform transform to keypoints. Args: keypoints (np.ndarray): Keypoints to be transformed. generated_mesh (np.ndarray): Generated mesh. **params (Any): Additional parameters. r{Nr')rPdistort_image_keypoints)rKrrJrVs rCr$GridElasticDeform.apply_to_keypointss+11   7OBQ   rB)r3r<r4r:) r:rr<rr3r2r4r2rLr)rDrrErrrr)rRrrJrrVrrr)rxrrJrrVrrr)r}rrJrrVrrr)rrrJrrVrrr)r<r=r>r?rrrrrDrrrrJrrFrrWrqrrrArrs@rCr"r"sdIVH , 8      %5$55 5 5$ %554@@/2/2/2  /2bQ Q#Q Q  Q$WW#W W  W   #     0  #      rBr"cH^\rSrSrSr"SS\5r\rSSU4Sjjjr SSjr SSjr SSjr \ "S S S S 9SS j5r\ "S S S S 9SSj5r\ "S S S S 9SSj5r\ "S S S S 9SSj5rSSjrSrU=r$)r%ia Randomly shuffles the grid's cells on an image, mask, or keypoints, effectively rearranging patches within the image. This transformation divides the image into a grid and then permutes these grid cells based on a random mapping. Args: grid (tuple[int, int]): Size of the grid for splitting the image into cells. Each cell is shuffled randomly. For example, (3, 3) will divide the image into a 3x3 grid, resulting in 9 cells to be shuffled. Default: (3, 3) p (float): Probability that the transform will be applied. Should be in the range [0, 1]. Default: 0.5 Targets: image, mask, keypoints, bboxes, volume, mask3d Image types: uint8, float32 Note: - This transform maintains consistency across all targets. If applied to an image and its corresponding mask or keypoints, the same shuffling will be applied to all. - The number of cells in the grid should be at least 2 (i.e., grid should be at least (1, 2), (2, 1), or (2, 2)) for the transform to have any effect. - Keypoints are moved along with their corresponding grid cell. - This transform could be useful when only micro features are important for the model, and memorizing the global structure could be harmful. For example: - Identifying the type of cell phone used to take a picture based on micro artifacts generated by phone post-processing algorithms, rather than the semantic features of the photo. See more at https://ieeexplore.ieee.org/abstract/document/8622031 - Identifying stress, glucose, hydration levels based on skin images. Mathematical Formulation: 1. The image is divided into a grid of size (m, n) as specified by the 'grid' parameter. 2. A random permutation P of integers from 0 to (m*n - 1) is generated. 3. Each cell in the grid is assigned a number from 0 to (m*n - 1) in row-major order. 4. The cells are then rearranged according to the permutation P. Examples: >>> import numpy as np >>> import albumentations as A >>> # Prepare sample data >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> mask = np.random.randint(0, 2, (100, 100), dtype=np.uint8) >>> bboxes = np.array([[10, 10, 50, 50], [40, 40, 80, 80]], dtype=np.float32) >>> bbox_labels = [1, 2] >>> keypoints = np.array([[20, 30], [60, 70]], dtype=np.float32) >>> keypoint_labels = [0, 1] >>> >>> # Define transform with grid as a tuple >>> transform = A.Compose([ ... A.RandomGridShuffle(grid=(3, 3), p=1.0), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['bbox_labels']), ... keypoint_params=A.KeypointParams(format='xy', label_fields=['keypoint_labels'])) >>> >>> # Apply the transform >>> transformed = transform( ... image=image, ... mask=mask, ... bboxes=bboxes, ... bbox_labels=bbox_labels, ... keypoints=keypoints, ... keypoint_labels=keypoint_labels ... ) >>> >>> # Get the transformed data >>> transformed_image = transformed['image'] # Grid-shuffled image >>> transformed_mask = transformed['mask'] # Grid-shuffled mask >>> transformed_bboxes = transformed['bboxes'] # Grid-shuffled bounding boxes >>> transformed_keypoints = transformed['keypoints'] # Grid-shuffled keypoints >>> >>> # Visualization example with a simpler grid >>> simple_image = np.array([ ... [1, 1, 1, 2, 2, 2], ... [1, 1, 1, 2, 2, 2], ... [1, 1, 1, 2, 2, 2], ... [3, 3, 3, 4, 4, 4], ... [3, 3, 3, 4, 4, 4], ... [3, 3, 3, 4, 4, 4] ... ]) >>> simple_transform = A.RandomGridShuffle(grid=(2, 2), p=1.0) >>> simple_result = simple_transform(image=simple_image) >>> simple_transformed = simple_result['image'] >>> # The result could look like: >>> # array([[4, 4, 4, 2, 2, 2], >>> # [4, 4, 4, 2, 2, 2], >>> # [4, 4, 4, 2, 2, 2], >>> # [3, 3, 3, 1, 1, 1], >>> # [3, 3, 3, 1, 1, 1], >>> # [3, 3, 3, 1, 1, 1]]) c \rSrSr%S\S'Srg)RandomGridShuffle.InitSchemaitr9gridr:Nr;r:rBrCrDr_tsUUrBrDc,>[TU]US9 Xlgr>)rIrJr`)rKr`rLrMs rCrJRandomGridShuffle.__init__ys 1 rBc 0[R"XU5$)zApply the RandomGridShuffle transform to an image. Args: img (np.ndarray): Image to be transformed. tiles (np.ndarray): Tiles to be transformed. mapping (list[int]): Mapping of the tiles. **params (Any): Additional parameters. )rPswap_tiles_on_image)rKrRrNmappingrVs rCrWRandomGridShuffle.applys --c'BBrBc USSSn[X5n[SURS55nUcU$[R"UUUUUR R UR RS9n[X5$)aApply the RandomGridShuffle transform to bounding boxes. Args: bboxes (np.ndarray): Bounding boxes to be transformed. tiles (np.ndarray): Tiles to be transformed. mapping (np.ndarray): Mapping of the tiles. **params (Any): Additional parameters. r{Nr'rr})min_areamin_visibility) rr get_processorrPbboxes_grid_shufflerVrhrir) rKr}rNrerVrrX processorbboxes_returneds rCr!RandomGridShuffle.apply_to_bboxess Wobq) *6? $*<*>   ! !  (<r?rrrDrrrJrWrrr rargrlrtrrArrs@rCr%r%sYvV,VH!' C CC C  C  C$>>> >  >  >>MMM M  M  M$Yd%H,I,Ye4H,I,Yd$G-H-Yd%H,I,===  ==rBr%c^\rSrSrSr\r"SS\5rS S U4Sjjjr S Sjr SSjr SSjr SS jr S rU=r$)r#ia? Apply a morphological operation (dilation or erosion) to an image, with particular value for enhancing document scans. Morphological operations modify the structure of the image. Dilation expands the white (foreground) regions in a binary or grayscale image, while erosion shrinks them. These operations are beneficial in document processing, for example: - Dilation helps in closing up gaps within text or making thin lines thicker, enhancing legibility for OCR (Optical Character Recognition). - Erosion can remove small white noise and detach connected objects, making the structure of larger objects more pronounced. Args: scale (int or tuple/list of int): Specifies the size of the structuring element (kernel) used for the operation. - If an integer is provided, a square kernel of that size will be used. - If a tuple or list is provided, it should contain two integers representing the minimum and maximum sizes for the dilation kernel. operation (Literal["erosion", "dilation"]): The morphological operation to apply. Default is 'dilation'. p (float, optional): The probability of applying this transformation. Default is 0.5. Targets: image, mask, keypoints, bboxes, volume, mask3d Image types: uint8, float32 References: Nougat: https://github.com/facebookresearch/nougat Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Create a document-like binary image with text >>> image = np.ones((200, 500), dtype=np.uint8) * 255 # White background >>> # Add some "text" (black pixels) >>> cv2.putText(image, "Document Text", (50, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, 0, 2) >>> # Add some "noise" (small black dots) >>> for _ in range(50): ... x, y = np.random.randint(0, image.shape[1]), np.random.randint(0, image.shape[0]) ... cv2.circle(image, (x, y), 1, 0, -1) >>> >>> # Create a mask representing text regions >>> mask = np.zeros_like(image) >>> mask[image < 128] = 1 # Binary mask where text exists >>> >>> # Example 1: Apply dilation to thicken text and fill gaps >>> dilation_transform = A.Morphological( ... scale=3, # Size of the structuring element ... operation="dilation", # Expand white regions (or black if inverted) ... p=1.0 # Always apply ... ) >>> result = dilation_transform(image=image, mask=mask) >>> dilated_image = result['image'] # Text is thicker, gaps are filled >>> dilated_mask = result['mask'] # Mask is expanded around text regions >>> >>> # Example 2: Apply erosion to thin text or remove noise >>> erosion_transform = A.Morphological( ... scale=(2, 3), # Random kernel size between 2 and 3 ... operation="erosion", # Shrink white regions (or expand black if inverted) ... p=1.0 # Always apply ... ) >>> result = erosion_transform(image=image, mask=mask) >>> eroded_image = result['image'] # Text is thinner, small noise may be removed >>> eroded_mask = result['mask'] # Mask is contracted around text regions >>> >>> # Note: For document processing, dilation often helps enhance readability for OCR >>> # while erosion can help remove noise or separate connected components c*\rSrSr%S\S'S\S'Srg)Morphological.InitSchemaiZrr.Literal['erosion', 'dilation'] operationr:Nr;r:rBrCrDrZs""11rBrDcN>[TU]US9 [SU5UlX lg)Nrr)rIrJrr.r)rKr.rrLrMs rCrJMorphological.__init__^s) 1+U3 "rBc D[R"XUR5$)a!Apply the Morphological transform to the input image. Args: img (np.ndarray): The input image to apply the Morphological transform to. kernel (tuple[int, int]): The structuring element (kernel) used for the operation. **params (Any): Additional parameters for the transform. )rP morphologyr)rKrRkernelrVs rCrWMorphological.applyhs$$S$..AArBc ~USn[X5n[R"UUURU5n[ Xd5$)a6Apply the Morphological transform to the input bounding boxes. Args: bboxes (np.ndarray): The input bounding boxes to apply the Morphological transform to. kernel (tuple[int, int]): The structuring element (kernel) used for the operation. **params (Any): Additional parameters for the transform. r{)rrPbboxes_morphologyrr)rKr}rrVrdenormalized_boxesr+s rCrMorphological.apply_to_bboxesxsEWo /D--   NN    44rBc U$)zApply the Morphological transform to the input keypoints. Args: keypoints (np.ndarray): The input keypoints to apply the Morphological transform to. **params (Any): Additional parameters for the transform. r:)rKrrVs rCr Morphological.apply_to_keypointss rBcdS[R"[RUR50$)zwGenerate parameters for the Morphological transform. Returns: dict[str, float]: The parameters of the transform. r)rgetStructuringElement MORPH_ELLIPSEr.rs rC get_paramsMorphological.get_paramss* c//0A0A4::N  rB)rr.))r'rIdilationrF)r.ztuple[int, int] | intrrrLr)rRrrrrVrrr)r}rrrrVrrr)rrrVrrrr)r<r=r>r?rrrrrDrJrWrrrrArrs@rCr#r#sFPH2,2 (.4> #$#2#  ##B B B B  B 55 5 5  56        rBr#)8r __future__rrandomtypingrrrrwarningsrrnumpyrAalbucorer r r pydanticr r rrrtyping_extensionsr"albumentations.augmentations.utilsralbumentations.core.bbox_utilsrrralbumentations.core.pydanticrrrr(albumentations.core.transforms_interfacerr$albumentations.core.type_definitionsralbumentations.core.utilsrr rP__all__ NUM_PADS_XYNUM_PADS_ALL_SIDESr$r!r&r"r%r#r:rBrCrs# 00 FF#:  =.&  } -} @ t  ]t  nc vc L{ { |t= t=n[ M[ rB