U h#R@s8ddlmZddlZddlmZmZmZmZddlm Z ddl Z ddl Z ddl ZddlmZmZddlmZmZmZmZmZddlmZmZddlmZdd lmZdd lm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)m*Z*dd l+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6ddl7m8Z9ddddddddddddddgZ:Gdd d e*Z;Gd!dde;ZGd$dde>Z?Gd%dde*Z@Gd&dde*ZAGd'dde*ZBGd(dde*ZCGd)dde*ZDGd*dde*ZEGd+dde;ZFGd,dde;ZGGd-dde*ZHGd.dde*ZIdS)/) annotationsN)AnyLiteralTuplecast)warn)hflipvflip)AfterValidatorFieldValidationInfofield_validatormodel_validator) AnnotatedSelf) random_utils) check_range)denormalize_bboxesnormalize_bboxes)BorderModeTypeInterpolationTypeNonNegativeFloatRangeTypeSymmetricRangeType check_1plus)BaseTransformInitSchema DualTransform) BIG_INTEGER ColorTypeD4Type PositionType ScalarTypeScaleFloatType ScaleIntTypeTargetsd4_group_elements)to_tuple) functionalShiftScaleRotateElasticTransform PerspectiveAffinePiecewiseAffine VerticalFlipHorizontalFlipFlip TransposeOpticalDistortionGridDistortion PadIfNeededD4GridElasticDeformcseZdZdZejejejejfZ Gddde Z e j e jddddfdddddd d fd d Zd d d dd dddZd d d dd dddZd d d dd dddZd d d dd dddZddddZZS)BaseDistortionaBase class for distortion-based transformations. This class provides a foundation for implementing various types of image distortions, such as optical distortions, grid distortions, and elastic transformations. It handles the common operations of applying distortions to images, masks, bounding boxes, and keypoints. Args: interpolation (int): Interpolation method to be used for image transformation. Should be one of the OpenCV interpolation types (e.g., cv2.INTER_LINEAR, cv2.INTER_CUBIC). Default: cv2.INTER_LINEAR border_mode (int): Border mode to be used for handling pixels outside the image boundaries. Should be one of the OpenCV border types (e.g., cv2.BORDER_REFLECT_101, cv2.BORDER_CONSTANT). Default: cv2.BORDER_REFLECT_101 value (int, float, list of int, list of float, optional): Padding value if border_mode is cv2.BORDER_CONSTANT. Default: None mask_value (ColorType | None): Padding value for mask if border_mode is cv2.BORDER_CONSTANT. Default: None p (float): Probability of applying the transform. Default: 0.5 Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - This is an abstract base class and should not be used directly. - Subclasses should implement the `get_params_dependent_on_data` method to generate the distortion maps (map_x and map_y). - The distortion is applied consistently across all targets (image, mask, bboxes, keypoints) to maintain coherence in the augmented data. Example of a subclass: class CustomDistortion(BaseDistortion): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Add custom parameters here def get_params_dependent_on_data(self, params, data): # Generate and return map_x and map_y based on the distortion logic return {"map_x": map_x, "map_y": map_y} def get_transform_init_args_names(self): return super().get_transform_init_args_names() + ("custom_param1", "custom_param2") c@s.eZdZUded<ded<ded<ded<dS) zBaseDistortion.InitSchemar interpolationr border_modeColorType | Nonevalue mask_valueN__name__ __module__ __qualname____annotations__rArAU/tmp/pip-unpacked-wheel-e8onvpoz/albumentations/augmentations/geometric/transforms.py InitSchemaks rCN?intr9 bool | Nonefloatr7r8r:r; always_applypcs,tj||d||_||_||_||_dSNrJrI)super__init__r7r8r:r;)selfr7r8r:r;rIrJ __class__rArBrNqs zBaseDistortion.__init__ np.ndarrayr)imgmap_xmap_yparamsreturncKst||||j|j|jSN) fgeometric distortionr7r8r:)rOrSrTrUrVrArArBapplyszBaseDistortion.apply)maskrTrUrVrWcKst|||tj|j|jSrX)rYrZcv2 INTER_NEARESTr8r;)rOr\rTrUrVrArArB apply_to_maskszBaseDistortion.apply_to_mask)bboxesrTrUrVrWcKs8|ddd}t||}t|||||j}t||SNshape)rrYZdistortion_bboxesr8r)rOr`rTrUrV image_shape bboxes_denormZbboxes_returnedrArArBapply_to_bboxess zBaseDistortion.apply_to_bboxes) keypointsrTrUrVrWcKst||||dSNrb)rYZdistortion_keypoints)rOrgrTrUrVrArArBapply_to_keypointssz!BaseDistortion.apply_to_keypointstuple[str, ...]rWcCsdS)N)r7r8r:r;rArOrArArBget_transform_init_args_namessz,BaseDistortion.get_transform_init_args_names)r=r>r?__doc__r#IMAGEMASKBBOXES KEYPOINTS_targetsrrCr] INTER_LINEARBORDER_REFLECT_101rNr[r_rfrirm __classcell__rArArPrBr6:s. r6c seZdZdZGdddejZddejejddddddf d d d d d d d d d d d fdd Z ddddddZ ddfdd Z Z S)r)a Apply elastic deformation to images, masks, bounding boxes, and keypoints. This transformation introduces random elastic distortions to the input data. It's particularly useful for data augmentation in training deep learning models, especially for tasks like image segmentation or object detection where you want to maintain the relative positions of features while introducing realistic deformations. The transform works by generating random displacement fields and applying them to the input. These fields are smoothed using a Gaussian filter to create more natural-looking distortions. Args: alpha (float): Scaling factor for the random displacement fields. Higher values result in more pronounced distortions. Default: 1.0 sigma (float): Standard deviation of the Gaussian filter used to smooth the displacement fields. Higher values result in smoother, more global distortions. Default: 50.0 interpolation (int): Interpolation method to be used for image transformation. Should be one of the OpenCV interpolation types. Default: cv2.INTER_LINEAR border_mode (int): Border mode to be used for handling pixels outside the image boundaries. Should be one of the OpenCV border types. Default: cv2.BORDER_REFLECT_101 value (int, float, list of int, list of float, optional): Padding value if border_mode is cv2.BORDER_CONSTANT. Default: None mask_value (int, float, list of int, list of float, optional): Padding value for mask if border_mode is cv2.BORDER_CONSTANT. Default: None approximate (bool): Whether to use an approximate version of the elastic transform. If True, uses a fixed kernel size for Gaussian smoothing, which can be faster but potentially less accurate for large sigma values. Default: False same_dxdy (bool): Whether to use the same random displacement field for both x and y directions. Can speed up the transform at the cost of less diverse distortions. Default: False p (float): Probability of applying the transform. Default: 0.5 Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - The transform will maintain consistency across all targets (image, mask, bboxes, keypoints) by using the same displacement fields for all. - The 'approximate' parameter determines whether to use a precise or approximate method for generating displacement fields. The approximate method can be faster but may be less accurate for large sigma values. - Bounding boxes that end up outside the image after transformation will be removed. - Keypoints that end up outside the image after transformation will be removed. Example: >>> import albumentations as A >>> transform = A.Compose([ ... A.ElasticTransform(alpha=1, sigma=50, p=0.5), ... ]) >>> transformed = transform(image=image, mask=mask, bboxes=bboxes, keypoints=keypoints) >>> transformed_image = transformed['image'] >>> transformed_mask = transformed['mask'] >>> transformed_bboxes = transformed['bboxes'] >>> transformed_keypoints = transformed['keypoints'] c@s.eZdZUded<ded<ded<ded<dS) zElasticTransform.InitSchemazAnnotated[float, Field(ge=0)]alphazAnnotated[float, Field(ge=1)]sigmabool approximate same_dxdyNr<rArArArBrCs rCr&2NFrDrGrEz$ScalarType | list[ScalarType] | NonerFry) rwrxr7r8r:r;rIrzr{rJc s4tj|||||| d||_||_||_| |_dSNrH)rMrNrwrxrzr{) rOrwrxr7r8r:r;rIrzr{rJrPrArBrNs zElasticTransform.__init__dict[str, Any]rVdatarWc Cs|ddd\}}|jrdnd}tj||f|j|j|j|td\}}t t |t |\}} t ||} t | |} | | dS)Nrbrcrr)r)r{ kernel_size random_staterTrU) rzrYZgenerate_displacement_fieldsrwrxr{rget_random_statenpmeshgridZarangefloat32) rOrVrheightwidthrdxdyxyrTrUrArArBget_params_dependent_on_datas z-ElasticTransform.get_params_dependent_on_datarjrkcstdS)Nrwrxrzr{)rwrxrzr{rMrmrlrPrArBrmsz.ElasticTransform.get_transform_init_args_names r=r>r?rnr6rCr]rtrurNrrmrvrArArPrBr)s9&c seZdZdZejejejejfZ Gddde Z dde j ddde jdd f d d d d d d d ddd fdd Zddd d dddddZddd d dddddZddd d dddddZddd d ddddd Zd!d!d!d"d#d$Zd%d&d'd(ZZS))r*a) Apply 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. pad_mode (OpenCV flag): OpenCV border mode used for padding. Default: cv2.BORDER_CONSTANT. pad_val (int, float, list of int, list of float): Padding value if border_mode is cv2.BORDER_CONSTANT. Default: 0. mask_pad_val (int, float, list of int, list of 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. p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, keypoints, bboxes 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. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.Compose([ ... A.Perspective(scale=(0.05, 0.1), keep_size=True, always_apply=False, p=0.5), ... ]) >>> result = transform(image=image) >>> transformed_image = result['image'] c@sFeZdZUded<ded<ded<ded<ded <ded <d ed <d S)zPerspective.InitSchemarscalery keep_sizerpad_moder9pad_val mask_pad_val fit_outputrr7Nr<rArArArBrC@s rC)皙?皙?TrFNrDr!ryrErrFrG) rrrrrrr7rIrJc sLtj| |dttttf||_||_||_||_||_ ||_ ||_ dS)N)rI) rMrNrrrGrrrrrrr7) rOrrrrrrr7rIrJrPrArBrNIs zPerspective.__init__rRr)rSmatrix max_height max_widthrVrWc Ks t|||||j|j|j|jSrX)rY perspectiverrrr7)rOrSrrrrVrArArBr[^szPerspective.apply)r\rrrrVrWc Ks t|||||j|j|jtjSrX)rYrrrrr]r^)rOr\rrrrVrArArBr_qszPerspective.apply_to_mask)r`rrrrVrWcKst||d||||jSrh)rYZperspective_bboxesr)rOr`rrrrVrArArBrfszPerspective.apply_to_bboxes)rgrrrrVrWcKst||d||||jSrh)rYZperspective_keypointsr)rOrgrrrrVrArArBriszPerspective.apply_to_keypointsr~rc Csp|ddd}tj|j}t}t|||}t|}t|\}}} |j rdt ||\}}} || |dS)Nrbrc)rrr) randomuniformrrrrYZgenerate_perspective_pointsZ order_pointsZcompute_perspective_paramsrZexpand_transform) rOrVrrdrrZpointsrrrrArArBrs  z(Perspective.get_params_dependent_on_datarjrkcCsdS)N)rrrrrrr7rArlrArArBrmsz)Perspective.get_transform_init_args_names)r=r>r?rnr#rorprrrqrsrrCr]BORDER_CONSTANTrtrNr[r_rfrirrmrvrArArPrBr* s&2 $csneZdZdZejejejejfZ Gddde Z ddddde j e jdde jddddddfd d d d d d d d d d dddddddfdd ZddddZedCdddddddZed d d d!d"d#Zd$d%d&d d$d'd(d)Zd$d%d&d d$d*d+d,Zd$d-d&d d$d.d/d0Zd$d-dd d$d1d2d3Zed4ddd5d6d7d8Zdddd9d:d;Zd&dd?Zd@ddAdBZZS)Dr+a 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 `cval` and `mode` 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. cval (number or sequence of number): 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. cval_mask (number or tuple of number): Same as cval but only for masks. 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 Image types: uint8, float32 Reference: [1] https://arxiv.org/abs/2109.13488 c@seZdZUedddZded<edddZded<edddZd ed <edd dZd ed <edddZ ded<e j Z ded<e j Zded<edddZded<edddZded<e jZded<ded<ded<dZd ed!<d"ed#<dS)$zAffine.InitSchemaNz:Scaling factor or dictionary for independent axis scaling.)default description&ScaleFloatType | dict[str, Any] | Nonerz1Translation as a fraction of the image dimension.translate_percentzTranslation in pixels.$ScaleIntType | dict[str, Any] | None translate_pxzRotation angle in degrees.ScaleFloatType | NonerotatezShear angle in degrees.shearrr7mask_interpolationrz Value used for constant padding.rcvalz%Value used for mask constant padding. cval_maskrmodezZAnnotated[bool, Field(default=False, description='Adjust output to capture whole image.')]rzXAnnotated[bool, Field(default=False, description='Maintain aspect ratio when scaling.')] keep_ratio largest_box#Literal[('largest_box', 'ellipse')] rotate_methodzJAnnotated[bool, Field(default=False, description='Use balanced scaling.')]balanced_scale)r=r>r?r rr@rrrrr]rtr7r^rrrrrrrArArArBrC&s4  rCNrFrrDrrrrErryrrFrG)rrrrrr7rrrrrrrrrIrJcs(tj||d|||||g}tdd|DrTddd}ddd}d}ddd}n0|dk r`|nd }|dk rp|nd }|dk r|nd }||_||_||_| |_| |_||d |_ | ||\|_ |_ t |||_| |_||d |_| |_| |_||_|jr$|j d |j dkr$td|j dS)NrLcss|]}|dkVqdSrXrA).0rJrArArB Ysz"Affine.__init__..)g?g?rrgr)i)i ?rrrrzJWhen keep_ratio is True, the x and y scale range should be identical. got )rMrNallr7rrrr_handle_dict_argr_handle_translate_argrrr%rrrrrr ValueError)rOrrrrrr7rrrrrrrrrIrJrVrPrArBrNCs2    zAffine.__init__rjrkcCsdS)N)r7rrrrrrrrrrrrrrArlrArArBrmtsz$Affine.get_transform_init_args_namesrz,float | tuple[float, float] | dict[str, Any]strr~)valnamerrWcCsnt|trXd|kr*d|kr*td|d|d|}|d|}t||t||dSt||t||dS)Nrrz Expected zJ dictionary to contain at least key "x" or key "y". Found neither of them.r) isinstancedictrgetr%)rrrrrrArArBrs    zAffine._handle_dict_argr)rrrWcCsp|dkr|dkrd}|dk r0|dk r0d}t||dk rL|j|ddd|fS|dkr`d}t||||dfS)NrzYExpected either translate_percent or translate_px to be provided, but both were provided.rrrztranslate_px is None.r)rr)clsrrmsgrArArBrszAffine._handle_translate_argrRz%skimage.transform.ProjectiveTransformtuple[int, int])rSr output_shaperVrWcKstj|||j|j|j|dSN)r7rrr)rY warp_affiner7rr)rOrSrrrVrArArBr[sz Affine.apply)r\rrrVrWcKstj|||j|j|j|dSr)rYrrrr)rOr\rrrVrArArBr_szAffine.apply_to_maskz!skimage.transform.AffineTransform)r` bbox_matrixrrVrWcKs$t|||j|ddd|j|Sra)rYZ bboxes_affinerr)rOr`rrrVrArArBrfszAffine.apply_to_bboxes)rgrrrVrWcKst|||d||jSrh)rYZkeypoints_affiner)rOrgrrrVrArArBriszAffine.apply_to_keypointszdict[str, tuple[float, float]]zfgeometric.ScaleDict)rrrrWc Csi}|r|D]\}}|ddkr0|ddfnd}|ddkrLd|dfnd}|dk rp|dk rpt||g}n*|dk r~|}n|dk r|}ntd|tj|||<qndd|D}|r|d|d<ttj|S) Nrr&rz9Both lower_interval and upper_interval are None for key: cSsi|]\}}|tj|qSrArrrkeyr:rArArB sz$Affine.get_scale..rr)itemsrchoicerrrrYZ ScaleDict) rrrZ result_scalerr:Zlower_intervalZupper_intervalZselected_intervalrArArB get_scales" zAffine.get_scalercCs|ddd}||}|}||j|j|j}tj|j }t |}t |} t |||||} t ||||| } |j rt | |\} } t | |\} } n|} ||| | | dS)Nrbrc)rrrrr)_get_translate_params_get_shear_paramsrrrrrrrrYcenterZ center_bboxZ#create_affine_transformation_matrixrZ compute_affine_warp_output_shape)rOrVrrd translaterrrZ image_shiftZ bbox_shiftrrr_rArArBrs&   z#Affine.get_params_dependent_on_datazfgeometric.TranslateDict)rdrWcCs|dd\}}|jdk r6ttjdd|jDS|jdk rvdd|jD}ttj|d||d|dSttjdddS) NrccSsi|]\}}|tj|qSrArrandintrrArArBr%sz0Affine._get_translate_params..cSsi|]\}}|tj|qSrArrrArArBr(srrrr)rrrYZ TranslateDictrr)rOrdrrrrArArBr s  "zAffine._get_translate_paramszfgeometric.ShearDictcCsttjdd|jDS)NcSsi|]\}}|tj| qSrArrrArArBr-sz,Affine._get_shear_params..)rrYZ ShearDictrrrlrArArBr,szAffine._get_shear_params)r)r=r>r?rnr#rorprqrrrsrrCr]rtr^rrNrm staticmethodr classmethodrr[r_rfrirrrrrvrArArPrBr+sFi21  cseZdZdZejejejejfZ Gddde Z ddde j e jddddd dd f d d d d d d d dddddd fdd ZddddZZS)r(a 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_REFLECT_101 value (int, float, list of int, list of float): padding value if border_mode is cv2.BORDER_CONSTANT. mask_value (int, float, list of int, list of 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" p (float): probability of applying the transform. Default: 0.5. Targets: image, mask, keypoints, bboxes Image types: uint8, float32 c@seZdZUdZded<dZded<dZded<ejZ ded <ej Z d ed <d Z d ed<d Z d ed<eddZded<eddZded<dZded<eddddddZededddd d!d"ZdS)#zShiftScaleRotate.InitSchemagg?r shift_limitr scale_limiti- rotate_limitrr7rr8rrr:r;Nrr shift_limit_x shift_limit_yrrrafterrrrkcCsdd}t|jdk r|jn|j|_t|jf|dt|jdk rD|jn|j|_t|jf|d|S)Nr&rr)r)r)r%rrrr)rOboundsrArArBcheck_shift_limitis z-ShiftScaleRotate.InitSchema.check_shift_limitr!r r:inforWcCs4dtdf}t|dd}t|f|t|jf|S)NrinfrZbias)rGr%rr field_namerr:rrresultrArArBcheck_scale_limitrs  z-ShiftScaleRotate.InitSchema.check_scale_limit)r=r>r?rr@rrr]rtr7rur8r:r;r rrrrrr rrrArArArBrC]s       rCrrrrNrrDr!rErrrrFrG) rrrr7r8r:r;rrrrIrJc stj||| d|d|tj|||dd| | | dtdtddttttf||_ ttttf| |_ ttttf||_ ttt t f||_ ||_||_||_dS)NrrF)rrrrr7rrrrrrrrIrJzDShiftScaleRotate is deprecated. Please use Affine transform instead.rc stacklevel)rMrNr]r^rDeprecationWarningrrrGrrrrErr8r:r;) rOrrrr7r8r:r;rrrrIrJrPrArBrNzs8zShiftScaleRotate.__init__r~rkc Cs2|j|jt|jdd|j|j|j|j|j|j d S)Ngr) rrrrr7r8r:r;r) rrr%rrr7r8r:r;rrlrArArBget_transform_init_argss z(ShiftScaleRotate.get_transform_init_args)r=r>r?rnr#rorprrrqrsrrCr]rtrurNrrvrArArPrBr(0s"**,cseZdZdZejejejejfZ Gddde Z ddde j e jddddd d d f d d d dddddddddd fdd ZddddZddddddZddd dd!d"d#Zddd dd$d%d&Zddd dd'd(d)Zddd dd*d+d,ZZS)-r,a%Apply piecewise affine transformations to the input image. This augmentation places a regular grid of points on an image and randomly moves the neighborhood of these points around via affine transformations. This leads to local distortions in the image. Args: scale (tuple[float, float] | 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). Recommended values are in the range (0.01, 0.05) for small distortions, and (0.05, 0.1) for larger distortions. Default: (0.03, 0.05). nb_rows (tuple[int, int] | int): Number of rows of points that the regular grid should have. Must be at least 2. For large images, you might want to pick a higher value than 4. If a single int, then that value will always be used as the number of rows. If a tuple (a, b), then a value from the discrete interval [a..b] will be uniformly sampled per image. Default: 4. nb_cols (tuple[int, int] | int): Number of columns of points that the regular grid should have. Must be at least 2. For large images, you might want to pick a higher value than 4. If a single int, then that value will always be used as the number of columns. If a tuple (a, b), then a value from the discrete interval [a..b] will be uniformly sampled per image. Default: 4. interpolation (int): The order of interpolation. The order has to be in the range 0-5: - 0: Nearest-neighbor - 1: Bi-linear (default) - 2: Bi-quadratic - 3: Bi-cubic - 4: Bi-quartic - 5: Bi-quintic mask_interpolation (int): The order of interpolation for masks. Similar to 'interpolation' but for masks. Default: 0 (Nearest-neighbor). cval (number): The constant value to use when filling in newly created pixels. Default: 0. cval_mask (number): The constant value to use when filling in newly created pixels in masks. Default: 0. mode (str): {'constant', 'edge', 'symmetric', 'reflect', 'wrap'}, optional Points outside the boundaries of the input are filled according to the given mode. Default: 'constant'. absolute_scale (bool): If set to True, the value of the scale parameter will be treated as an absolute pixel value. If set to False, it will be treated as a fraction of the image height and width. Default: False. keypoints_threshold (float): Used as threshold in conversion from distance maps to keypoints. The search for keypoints works by searching for the argmin (non-inverted) or argmax (inverted) in each channel. This parameter contains the maximum (non-inverted) or minimum (inverted) value to accept in order to view a hit as a keypoint. Use None to use no min/max. Default: 0.01. p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, keypoints, bboxes Image types: uint8, float32 Note: - This augmentation is very slow. Consider using `ElasticTransform` instead, which is at least 10x faster. - The augmentation may not always produce visible effects, especially with small scale values. - For keypoints and bounding boxes, the transformation might move them outside the image boundaries. In such cases, the keypoints will be set to (-1, -1) and the bounding boxes will be removed. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.Compose([ ... A.PiecewiseAffine(scale=(0.03, 0.05), nb_rows=4, nb_cols=4, p=0.5), ... ]) >>> transformed = transform(image=image) >>> transformed_image = transformed["image"] c@s~eZdZUded<ded<ded<ded<ded<d ed <d ed <d ed <ded<ded<eddeddddddZdS)zPiecewiseAffine.InitSchemarrr"nb_rowsnb_colsrr7rrErr=Literal[('constant', 'edge', 'symmetric', 'reflect', 'wrap')]rryabsolute_scalerGkeypoints_thresholdr!r tuple[float, float]rcCs*dtf}t||}t|f||jf|S)Nrc)rr%rrrrArArB process_ranges z(PiecewiseAffine.InitSchema.process_rangeN)r=r>r?r@r rrrArArArBrCs rC)gQ?r)rrZconstantFNg{Gz?rDr!r"rErryrFrG) rrrr7rrrrrrIrrJc stj| | dtdddttttf||_ttttf||_ttttf||_ ||_ ||_ ||_ ||_ ||_| |_| |_dS)NrLzhThis augmenter is very slow. Try to use ``ElasticTransformation`` instead, which is at least 10x faster.rcr)rMrNrrrrGrrErrr7rrrrrr) rOrrrr7rrrrrrIrrJrPrArBrNszPiecewiseAffine.__init__rjrkcCsdS)N) rrrr7rrrrrrrArlrArArBrm1sz-PiecewiseAffine.get_transform_init_args_namesr~rcCs|ddd\}}ttj|jdd}ttj|jdd}||}tj|j}t d||df} t | dkst dD](} t d||df} t | dkr|qq|t | dksddiSt d||} t d||} t | | \} }t|j| jgd}|jrb|dkr$| dddf|nd| dddf<|dkrR| dddf|nd| dddf<| dddf|| dddf<| dddf|| dddf<t|}|dddf| dddf|dddf<|dddf| dddf|dddf<t|dddfd|d|dddf<t|dddfd|d|dddf<tj}||dddddf|dddddfd|iS) Nrbrcrrrrr&r)rZcliprrrrrrrnormalanyrangeZlinspacerZdstackZflatrcopyskimageZ transformZPiecewiseAffineTransformZestimate)rOrVrrrrrZnb_cellsrjitterrrrZxx_srcZyy_srcZ points_srcZ points_destrrArArBr?s@  ..   ,,** 0z,PiecewiseAffine.get_params_dependent_on_datarRz*skimage.transform.PiecewiseAffineTransformr)rSrrVrWcKst|||j|j|jSrX)rYpiecewise_affiner7rr)rOrSrrVrArArBr[rszPiecewiseAffine.apply)r\rrVrWcKst|||j|j|jSrX)rYrrrr)rOr\rrVrArArBr_zszPiecewiseAffine.apply_to_mask)r`rrVrWcKst|||d|jSrh)rYZbboxes_piecewise_affiner)rOr`rrVrArArBrfszPiecewiseAffine.apply_to_bboxes)rgrrVrWcKst|||d|jSrh)rYZkeypoints_piecewise_affiner)rOrgrrVrArArBrisz"PiecewiseAffine.apply_to_keypoints)r=r>r?rnr#rorprqrrrsrrCr]rtr^rNrmrr[r_rfrirvrArArPrBr,s,E*!3c seZdZdZejejejejfZ Gddde Z ddddde j ddddf ddddd d d d d d d fdd Zddddfdd Zdd d d d dddddZdd d d d dddddZdd d d d dddddZdd d d d ddd d!d"Zd#d$d%d&Zd d d d d'd(d)d*ZZS)+r3a Pads the sides of an image if the image dimensions are less than the specified minimum dimensions. If the `pad_height_divisor` or `pad_width_divisor` is specified, the function additionally ensures that the image dimensions are divisible by these values. Args: min_height (int | None): Minimum desired height of the image. Ensures image height is at least this value. If not specified, pad_height_divisor must be provided. min_width (int | None): Minimum desired width of the image. Ensures image width is at least this value. If not specified, pad_width_divisor must be provided. pad_height_divisor (int | None): If set, pads the image height to make it divisible by this value. If not specified, min_height must be provided. pad_width_divisor (int | None): If set, pads the image width to make it divisible by this value. If not specified, min_width must be provided. position (Literal["center", "top_left", "top_right", "bottom_left", "bottom_right", "random"]): Position where the image is to be placed after padding. Default is 'center'. border_mode (int): Specifies the border mode to use if padding is required. The default is `cv2.BORDER_REFLECT_101`. value (int, float, list[int], list[float] | None): Value to fill the border pixels if the border mode is `cv2.BORDER_CONSTANT`. Default is None. mask_value (int, float, list[int], list[float] | None): Similar to `value` but used for padding masks. Default is None. p (float): Probability of applying the transform. Default is 1.0. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - Either `min_height` or `pad_height_divisor` must be set, but not both. - Either `min_width` or `pad_width_divisor` must be set, but not both. - If `border_mode` is set to `cv2.BORDER_CONSTANT`, `value` must be provided. - The transform will maintain consistency across all targets (image, mask, bboxes, keypoints). - For bounding boxes, the coordinates will be adjusted to account for the padding. - For keypoints, their positions will be shifted according to the padding. Example: >>> import albumentations as A >>> transform = A.Compose([ ... A.PadIfNeeded(min_height=1024, min_width=1024, border_mode=cv2.BORDER_CONSTANT, value=0), ... ]) >>> transformed = transform(image=image, mask=mask, bboxes=bboxes, keypoints=keypoints) >>> padded_image = transformed['image'] >>> padded_mask = transformed['mask'] >>> adjusted_bboxes = transformed['bboxes'] >>> adjusted_keypoints = transformed['keypoints'] c@seZdZUeddZded<eddZded<eddZded<eddZded<ded <d ed <d ed <d ed<e ddddddZ dS)zPadIfNeeded.InitSchemar&)ge int | None min_height min_widthpad_height_divisorpad_width_divisorrpositionrr8r9r:r;rrrrkcCsf|jdk|jdkkr d}t||jdk|jdkkr@d}t||jtjkrb|jdkrbd}t||S)NzHOnly one of 'min_height' and 'pad_height_divisor' parameters must be setzFOnly one of 'min_width' and 'pad_width_divisor' parameters must be setzGIf 'border_mode' is set to 'BORDER_CONSTANT', 'value' must be provided.) r r rr r r8r]rr:)rOrrArArBvalidate_divisibilitysz,PadIfNeeded.InitSchema.validate_divisibilityN) r=r>r?r r r@r r r rrrArArArBrCs rCiNrrrrrEr9rFrG) r r r r r r8r:r;rIrJc sDtj| | d||_||_||_||_||_||_||_||_ dSrK) rMrNr r r r r r8r:r;) rOr r r r r r8r:r;rIrJrPrArBrNs zPadIfNeeded.__init__r~r)rVkwargsrWc  s6tj|f|}|ddd\}}|jdk rd||jkrZt|j|d}|j||}qd}d}n0||j}|dkr|j|nd}|d}||}|jdk r||jkrt|j|d} |j|| } nd} d} n0||j} | dkr|j| nd} | d} | | } |j||| | d\}}} } |||| | d|S)Nrbrcg@r)h_toph_bottomw_leftw_right)pad_top pad_bottompad_left pad_right) rM update_paramsr rEr r r $_PadIfNeeded__update_position_paramsupdate) rOrVrrowscolsZ h_pad_topZ h_pad_bottomZ pad_remainedZpad_rowsZ w_pad_leftZ w_pad_rightZ pad_remainderZpad_colsrPrArBrsH      zPadIfNeeded.update_paramsrR)rSrrrrrVrWc Kstj||||||j|jdSN)r8r:)rYpad_with_paramsr8r:)rOrSrrrrrVrArArBr[(s zPadIfNeeded.apply)r\rrrrrVrWc Kstj||||||j|jdSr)rYrr8r;)rOr\rrrrrVrArArBr_;s zPadIfNeeded.apply_to_mask)r`rrrrrVrWc Ksj|ddd}t||d}tj||||||j|d} |ddd\} } t| | ||| ||fSNrbrc)rd)rrYZ pad_bboxesr8r) rOr`rrrrrVrdZ bboxes_nprrrrArArBrfNs  zPadIfNeeded.apply_to_bboxes)rgrrrrrVrWc Ks&tj||||||j|ddddSr)rYZ pad_keypointsr8)rOrgrrrrrVrArArBrihs zPadIfNeeded.apply_to_keypointsrjrkcCsdS)N)r r r r r r8r:r;rArlrArArBrm{sz)PadIfNeeded.get_transform_init_args_namesztuple[int, int, int, int])rrrrrWcCs|jdkr$||7}||7}d}d}n|jdkrH||7}||7}d}d}n|jdkrl||7}||7}d}d}nf|jdkr||7}||7}d}d}nB|jdkr||}||}td|}||}td|}||}||||fS)NZtop_leftrZ top_rightZ bottom_leftZ bottom_rightr)r rr)rOrrrrZh_padZw_padrArArBZ__update_position_paramss8       z$PadIfNeeded.__update_position_params)r=r>r?rnr#rorprqrrrsrrCr]rurNrr[r_rfrirmrrvrArArPrBr3s*1&1 c@sheZdZdZejejejejfZ ddddddZ dddddd Z dddd d d Z d dddZ dS)r-agFlip the input vertically around the x-axis. Args: p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - This transform flips the image upside down. The top of the image becomes the bottom and vice versa. - The dimensions of the image remain unchanged. - For multi-channel images (like RGB), each channel is flipped independently. - Bounding boxes are adjusted to match their new positions in the flipped image. - Keypoints are moved to their new positions in the flipped image. Mathematical Details: 1. For an input image I of shape (H, W, C), the output O is: O[i, j, k] = I[H-1-i, j, k] for all i in [0, H-1], j in [0, W-1], k in [0, C-1] 2. For bounding boxes with coordinates (x_min, y_min, x_max, y_max): new_bbox = (x_min, H-y_max, x_max, H-y_min) 3. For keypoints with coordinates (x, y): new_keypoint = (x, H-y) where H is the height of the image. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.array([ ... [[1, 2, 3], [4, 5, 6]], ... [[7, 8, 9], [10, 11, 12]] ... ]) >>> transform = A.VerticalFlip(p=1.0) >>> result = transform(image=image) >>> flipped_image = result['image'] >>> print(flipped_image) [[[ 7 8 9] [10 11 12]] [[ 1 2 3] [ 4 5 6]]] # The original image is flipped vertically, with rows reversed rRrrSrVrWcKst|SrX)r rOrSrVrArArBr[szVerticalFlip.applyr`rVrWcKs t|SrX)rYZ bboxes_vfliprOr`rVrArArBrfszVerticalFlip.apply_to_bboxesrgrVrWcKst||dS)Nr)rYZkeypoints_vfliprOrgrVrArArBriszVerticalFlip.apply_to_keypoints tuple[()]rkcCsdSNrArArlrArArBrmsz*VerticalFlip.get_transform_init_args_namesNr=r>r?rnr#rorprqrrrsr[rfrirmrArArArBr-s .c@sheZdZdZejejejejfZ ddddddZ dddddd Z dddd d d Z d dddZ dS)r.zFlip the input horizontally around the y-axis. Args: p (float): probability of applying the transform. Default: 0.5. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 rRrr cKst|SrX)rr!rArArBr[szHorizontalFlip.applyr"cKs t|SrX)rYZ bboxes_hflipr#rArArBrfszHorizontalFlip.apply_to_bboxesr$cKst||dS)Nr)rYZkeypoints_hflipr%rArArBrisz!HorizontalFlip.apply_to_keypointsr&rkcCsdSr'rArlrArArBrmsz,HorizontalFlip.get_transform_init_args_namesNr(rArArArBr.s  cseZdZdZejejejejfZ ddddfdd Z d d d d d d dZ ddddZ d d d dddZ d d d dddZddddZZS)r/zNDeprecated. Consider using HorizontalFlip, VerticalFlip, RandomRotate90 or D4.NrDrFrGrIrJcs"tj||dtdtdddS)NrLzVFlip is deprecated. Consider using HorizontalFlip, VerticalFlip, RandomRotate90 or D4.rcr)rMrNrrrOrIrJrPrArBrNs z Flip.__init__rRrEr)rSdrVrWcKs t||S)aArgs: d (int): code that specifies how to flip the input. 0 for vertical flipping, 1 for horizontal flipping, -1 for both vertical and horizontal flipping (which is also could be seen as rotating the input by 180 degrees). )rYZ random_flip)rOrSr+rVrArArBr[sz Flip.applyzdict[str, int]rkcCsdtddiS)Nr+rr&rrlrArArB get_params!szFlip.get_paramsr"cKst||dS)Nr+)rYZ bboxes_flipr#rArArBrf%szFlip.apply_to_bboxesr$cKst||d|dS)Nr+rb)rYZkeypoints_flipr%rArArBri(szFlip.apply_to_keypointsr&cCsdSr'rArlrArArBrm+sz"Flip.get_transform_init_args_names)NrD)r=r>r?rnr#rorprqrrrsrNr[r,rfrirmrvrArArPrBr/ sc@sheZdZdZejejejejfZ ddddddZ dddddd Z dddd d d Z d dddZ dS)r0axTranspose the input by swapping its rows and columns. This transform flips the image over its main diagonal, effectively switching its width and height. It's equivalent to a 90-degree rotation followed by a horizontal flip. Args: p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - The dimensions of the output will be swapped compared to the input. For example, an input image of shape (100, 200, 3) will result in an output of shape (200, 100, 3). - This transform is its own inverse. Applying it twice will return the original input. - For multi-channel images (like RGB), the channels are preserved in their original order. - Bounding boxes will have their coordinates adjusted to match the new image dimensions. - Keypoints will have their x and y coordinates swapped. Mathematical Details: 1. For an input image I of shape (H, W, C), the output O is: O[i, j, k] = I[j, i, k] for all i in [0, W-1], j in [0, H-1], k in [0, C-1] 2. For bounding boxes with coordinates (x_min, y_min, x_max, y_max): new_bbox = (y_min, x_min, y_max, x_max) 3. For keypoints with coordinates (x, y): new_keypoint = (y, x) Example: >>> import numpy as np >>> import albumentations as A >>> image = np.array([ ... [[1, 2, 3], [4, 5, 6]], ... [[7, 8, 9], [10, 11, 12]] ... ]) >>> transform = A.Transpose(p=1.0) >>> result = transform(image=image) >>> transposed_image = result['image'] >>> print(transposed_image) [[[ 1 2 3] [ 7 8 9]] [[ 4 5 6] [10 11 12]]] # The original 2x2x3 image is now 2x2x3, with rows and columns swapped rRrr cKs t|SrX)rYZ transposer!rArArBr[cszTranspose.applyr"cKs t|SrX)rYZbboxes_transposer#rArArBrffszTranspose.apply_to_bboxesr$cKs t|SrX)rYZkeypoints_transposer%rArArBriiszTranspose.apply_to_keypointsr&rkcCsdSr'rArlrArArBrmlsz'Transpose.get_transform_init_args_namesNr(rArArArBr0/s 1c seZdZdZGdddejZddejejddddfddddd d d d d fd d Z ddddddZ ddfdd Z Z S)r1a Apply optical distortion to images, masks, bounding boxes, and keypoints. This transformation simulates lens distortion effects by warping the image using a camera matrix and distortion coefficients. It's particularly useful for augmenting data in computer vision tasks where camera lens effects are relevant. Args: distort_limit (float or tuple of float): Range of distortion coefficient. If distort_limit is a single float, the range will be (-distort_limit, distort_limit). Default: (-0.05, 0.05). shift_limit (float or tuple of float): Range of shifts for the image center. If shift_limit is a single float, the range will be (-shift_limit, shift_limit). Default: (-0.05, 0.05). interpolation (OpenCV flag): Interpolation method used for image transformation. 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): Border mode used for handling pixels outside the image. Should be one of: cv2.BORDER_CONSTANT, cv2.BORDER_REPLICATE, cv2.BORDER_REFLECT, cv2.BORDER_WRAP, cv2.BORDER_REFLECT_101. Default: cv2.BORDER_REFLECT_101. value (int, float, list of int, list of float): Padding value if border_mode is cv2.BORDER_CONSTANT. Default: None. mask_value (int, float, list of int, list of float): Padding value for mask if border_mode is cv2.BORDER_CONSTANT. Default: None. always_apply (bool): If True, the transform will be always applied. Default: None. p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - The distortion is applied using OpenCV's initUndistortRectifyMap and remap functions. - The distortion coefficient (k) is randomly sampled from the distort_limit range. - The image center is shifted by dx and dy, randomly sampled from the shift_limit range. - Bounding boxes and keypoints are transformed along with the image to maintain consistency. Example: >>> import albumentations as A >>> transform = A.Compose([ ... A.OpticalDistortion(distort_limit=0.1, shift_limit=0.1, p=1.0), ... ]) >>> transformed = transform(image=image, mask=mask, bboxes=bboxes, keypoints=keypoints) >>> transformed_image = transformed['image'] >>> transformed_mask = transformed['mask'] >>> transformed_bboxes = transformed['bboxes'] >>> transformed_keypoints = transformed['keypoints'] c@seZdZUded<ded<dS)zOpticalDistortion.InitSchemar distort_limitrNr<rArArArBrCs rC)grNrDr!rEr9rFrG)r-rr7r8r:r;rIrJc sDtj||||||dttttf||_ttttf||_dSr})rMrNrrrGrr-) rOr-rr7r8r:r;rIrJrPrArBrNs zOpticalDistortion.__init__r~rcCs|ddd\}}|}|}tj|j}ttj|j}ttj|j} |d|} |d| } tj|d| gd|| gdddggtjd} tj||dddgtjd} t | | dd||ftj \}}||dS)NrbrcrDrr&)Zdtyper) rrr-roundrrarrayrr]ZinitUndistortRectifyMapZCV_32FC1)rOrVrrrZfxZfykrrZcxcyZ camera_matrixrZrTrUrArArBrs   (z.OpticalDistortion.get_params_dependent_on_datarjrkcstdS)Nr-r)r-rrrlrPrArBrmsz/OpticalDistortion.get_transform_init_args_namesrrArArPrBr1ps3"c seZdZdZGdddejZddejejdddddf d d d d d d d d dd fdd Z ddddddZ ddfdd Z Z S)r2a Apply grid distortion to images, masks, bounding boxes, and keypoints. This transformation divides the image into a grid and randomly distorts each cell, creating localized warping effects. It's particularly useful for data augmentation in tasks like medical image analysis, OCR, and other domains where local geometric variations are meaningful. Args: num_steps (int): Number of grid cells on each side of the image. Higher values create more granular distortions. Must be at least 1. Default: 5. distort_limit (float or tuple[float, float]): Range of distortion. If a single float is provided, the range will be (-distort_limit, distort_limit). Higher values create stronger distortions. Should be in the range of -1 to 1. Default: (-0.3, 0.3). interpolation (int): OpenCV interpolation method used for image transformation. Options include cv2.INTER_LINEAR, cv2.INTER_CUBIC, etc. Default: cv2.INTER_LINEAR. border_mode (int): OpenCV border mode used for handling pixels outside the image. Options include cv2.BORDER_REFLECT_101, cv2.BORDER_CONSTANT, etc. Default: cv2.BORDER_REFLECT_101. value (int, float, list of int, list of float, optional): Padding value if border_mode is cv2.BORDER_CONSTANT. Default: None. mask_value (int, float, list of int, list of float, optional): Padding value for mask if border_mode is cv2.BORDER_CONSTANT. Default: None. normalized (bool): If True, ensures that the distortion does not move pixels outside the image boundaries. This can result in less extreme distortions but guarantees that no information is lost. Default: True. always_apply (bool): If True, the transform will be always applied. Default: None. p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - The same distortion is applied to all targets (image, mask, bboxes, keypoints) to maintain consistency. - When normalized=True, the distortion is adjusted to ensure all pixels remain within the image boundaries. Example: >>> import albumentations as A >>> transform = A.Compose([ ... A.GridDistortion(num_steps=5, distort_limit=0.3, p=1.0), ... ]) >>> transformed = transform(image=image, mask=mask, bboxes=bboxes, keypoints=keypoints) >>> transformed_image = transformed['image'] >>> transformed_mask = transformed['mask'] >>> transformed_bboxes = transformed['bboxes'] >>> transformed_keypoints = transformed['keypoints'] c@sDeZdZUded<ded<ded<ededddd d d Zd S) zGridDistortion.InitSchemazAnnotated[int, Field(ge=1)] num_stepsrr-ry normalizedrr )vrrWcCs$d}t|}t|f||jf|S)Nr)r%rr)rr4rrrrArArB check_limitssz&GridDistortion.InitSchema.check_limitsN)r=r>r?r@r rr5rArArArBrC s rC)g333333ӿg333333?NTrDrEr!r9ryrFrG) r2r-r7r8r:r;r3rIrJc s<tj|||||| d||_ttttf||_||_dSr})rMrNr2rrrGr-r3) rOr2r-r7r8r:r;r3rIrJrPrArBrNs zGridDistortion.__init__r~rc s|ddd}fddtjdD}fddtjdD}jrrt|j||}|d|d}}t|||j\}}||d S) Nrbrccsg|]}dtjjqSr&rrr-rrrlrArB 3sz?GridDistortion.get_params_dependent_on_data..r&csg|]}dtjjqSr7r8r9rlrArBr:4ssteps_xsteps_yr)rr2r3rYZnormalize_grid_distortion_stepsZ generate_grid) rOrVrrdr;r<Znormalized_paramsrTrUrArlrBr1sz+GridDistortion.get_params_dependent_on_datarjrkcstdS)Nr2r-r3)r2r-r3rrlrPrArBrmCsz,GridDistortion.get_transform_init_args_namesrrArArPrBr2s6$cseZdZdZejejejejfZ Gddde Z ddddfd d Z d d d d dddZ d d d d dddZd d d d dddZddddZddddZZS)r4aApplies one of the eight possible D4 dihedral group transformations to a square-shaped input, maintaining the square shape. These transformations correspond to the symmetries of a square, including rotations and reflections. The D4 group transformations include: - 'e' (identity): No transformation is applied. - 'r90' (rotation by 90 degrees counterclockwise) - 'r180' (rotation by 180 degrees) - 'r270' (rotation by 270 degrees counterclockwise) - 'v' (reflection across the vertical midline) - 'hvt' (reflection across the anti-diagonal) - 'h' (reflection across the horizontal midline) - 't' (reflection across the main diagonal) Even if the probability (`p`) of applying the transform is set to 1, the identity transformation 'e' may still occur, which means the input will remain unchanged in one out of eight cases. Args: p (float): Probability of applying the transform. Default: 1.0. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - This transform is particularly useful for augmenting data that does not have a clear orientation, such as top-view satellite or drone imagery, or certain types of medical images. - The input image should be square-shaped for optimal results. Non-square inputs may lead to unexpected behavior or distortions. - When applied to bounding boxes or keypoints, their coordinates will be adjusted according to the selected transformation. - This transform preserves the aspect ratio and size of the input. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.Compose([ ... A.D4(p=1.0), ... ]) >>> transformed = transform(image=image) >>> transformed_image = transformed['image'] # The resulting image will be one of the 8 possible D4 transformations of the input c@s eZdZdS)z D4.InitSchemaN)r=r>r?rArArArBrCysrCNr&rFrGr)cstj||ddSrK)rMrNr*rPrArBrN|sz D4.__init__rRrr)rS group_elementrVrWcKs t||SrX)rYZd4)rOrSr=rVrArArBr[szD4.apply)r`r=rVrWcKs t||SrX)rYZ bboxes_d4)rOr`r=rVrArArBrfszD4.apply_to_bboxes)rgr=rVrWcKst|||dSrh)rYZ keypoints_d4)rOrgr=rVrArArBriszD4.apply_to_keypointszdict[str, D4Type]rkcCsdttiS)Nr=)rrr$rlrArArBr,sz D4.get_paramsr&cCsdSr'rArlrArArBrmsz D4.get_transform_init_args_names)Nr&)r=r>r?rnr#rorprqrrrsrrCrNr[rfrir,rmrvrArArPrBr4Gs/cseZdZdZejejejejfZ Gddde Z e j e jddfdddddd d fd d Zed d d dddZddddddZd d dd dddZd d dd dddZd d dd dddZd d dd dd d!Zd"d#d$d%ZZS)&r5a 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 Image types: uint8, float32 Example: >>> transform = GridElasticDeform(num_grid_xy=(4, 4), magnitude=10, p=1.0) >>> result = transform(image=image, mask=mask) >>> transformed_image, transformed_mask = result['image'], result['mask'] Note: This transformation is particularly useful for data augmentation in medical imaging and other domains where elastic deformations can simulate realistic variations. c@s8eZdZUded<eddZded<ded<ded <d S) zGridElasticDeform.InitSchemaz7Annotated[tuple[int, int], AfterValidator(check_1plus)] num_grid_xyr)gtrE magnituderr7rN)r=r>r?r@r r@rArArArBrCs rCrNrrErGrF)r>r@r7rrJrIcs,tj||d||_||_||_||_dSrK)rMrNr>r@r7r)rOr>r@r7rrJrIrPrArBrNs zGridElasticDeform.__init__rR)polygons dimensionsrWcCst|dd|fS)Nrr)rZhstackreshape)rArBrArArB generate_meshszGridElasticDeform.generate_meshr~rcCsj|ddd}t||j}tdd|D|jdddd}t||j}|||}d|iS)NrbrccSs(g|] }|d|d|d|dgqS)r&rrcrA)rZtilerArArBr:szBGridElasticDeform.get_params_dependent_on_data..r)rgenerated_mesh) rYZsplit_uniform_gridr>rr/rCZ generate_distorted_grid_polygonsr@rD)rOrVrrdZtilesrBrArFrArArBrs z.GridElasticDeform.get_params_dependent_on_datar)rSrFrVrWcKst|||jSrX)rY distort_imager7)rOrSrFrVrArArBr[szGridElasticDeform.apply)r\rFrVrWcKst|||jSrX)rYrGr)rOr\rFrVrArArBr_szGridElasticDeform.apply_to_mask)r`rFrVrWcKsBt||ddd}tt|||ddd|dddSra)rrrYZbbox_distort_image)rOr`rFrVrerArArBrfsz!GridElasticDeform.apply_to_bboxes)rgrFrVrWcKst|||dddSra)rYZdistort_image_keypoints)rOrgrFrVrArArBrisz$GridElasticDeform.apply_to_keypointsrjrkcCsdS)N)r>r@r7rrArlrArArBrm sz/GridElasticDeform.get_transform_init_args_names)r=r>r?rnr#rorprqrrrsrrCr]rtr^rNrrDrr[r_rfrirmrvrArArPrBr5s ! )J __future__rrtypingrrrrwarningsrr]ZnumpyrZskimage.transformrZalbucorerr Zpydanticr r r r rZtyping_extensionsrrZalbumentationsrZ"albumentations.augmentations.utilsrZalbumentations.core.bbox_utilsrrZalbumentations.core.pydanticrrrrrZ(albumentations.core.transforms_interfacerrZalbumentations.core.typesrrrrr r!r"r#r$Zalbumentations.core.utilsr%r'rY__all__r6r)r*r+r(r,r3r-r.r/r0r1r2r4r5rArArArBsl    ,  _r0x` >#AerS