h`SrSSKJr SSKJrJrJrJr SSKJ r SSK r SSK r SSK Jr SSKJrJrJrJr SSKJr SS KJrJr SS KJrJrJr SS KJrJr SS K J!r!J"r" SS K#J$r$ SSK%J&r' /SQr("SS\5r)"SS\)5r*"SS\)5r+"SS\)5r,"SS\)5r-"SS\)5r.g)aNGeometric distortion transforms for image augmentation. This module provides various geometric distortion transformations that modify the spatial arrangement of pixels in images while preserving their intensity values. These transforms can create non-rigid deformations that are useful for data augmentation, especially when training models that need to be robust to geometric variations. Available transforms: - ElasticTransform: Creates random elastic deformations by displacing pixels along random vectors - GridDistortion: Distorts the image by moving the nodes of a grid placed on the image - OpticalDistortion: Simulates lens distortion effects (barrel/pincushion) using camera or fisheye models - PiecewiseAffine: Divides the image into a grid and applies random affine transformations to each cell - ThinPlateSpline: Applies smooth deformations based on the thin plate spline interpolation technique All transforms inherit from BaseDistortion, which provides a common interface and functionality for applying distortion maps to various target types (images, masks, bounding boxes, keypoints). These transforms are particularly useful for: - Data augmentation to increase training set diversity - Simulating real-world distortion effects like camera lens aberrations - Creating more challenging test cases for computer vision models - Medical image analysis where anatomy might appear in different shapes Each transform supports customization through various parameters controlling the strength, type, and characteristics of the distortion, as well as interpolation methods for different target types. ) annotations) AnnotatedAnyLiteralcast)warnN)batch_transform)AfterValidatorFieldValidationInfofield_validator) check_range)denormalize_bboxesnormalize_bboxes)NonNegativeFloatRangeTypeSymmetricRangeTypecheck_range_bounds)BaseTransformInitSchema DualTransform) ALL_TARGETS BIG_INTEGER)to_tuple) functional)ElasticTransformGridDistortionOpticalDistortionPiecewiseAffineThinPlateSplinecz^\rSrSrSr\r"SS\5r\ RSS4SU4Sjjjr SSjr \ "SS S S 9SS j5r\ "SS S S 9SS j5r\ "SS S S 9SSj5r\ "SS S S 9SSj5rSSjrSSjrSSjrSrU=r$)BaseDistortionKaBase 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). 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. keypoint_remapping_method (Literal["direct", "mask"]): Method to use for keypoint remapping. - "mask": Uses mask-based remapping. Faster, especially for many keypoints, but may be less accurate for large distortions. Recommended for large images or many keypoints. - "direct": Uses inverse mapping. More accurate for large distortions but slower. Default: "mask" p (float): Probability of applying the transform. Targets: image, mask, bboxes, keypoints, volume, mask3d 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. Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> class CustomDistortion(A.BaseDistortion): ... def __init__(self, distort_limit=0.3, *args, **kwargs): ... super().__init__(*args, **kwargs) ... self.distort_limit = distort_limit ... ... def get_params_dependent_on_data(self, params, data): ... height, width = params["shape"][:2] ... # Create distortion maps - a simple radial distortion in this example ... map_x = np.zeros((height, width), dtype=np.float32) ... map_y = np.zeros((height, width), dtype=np.float32) ... ... # Calculate distortion center ... center_x = width / 2 ... center_y = height / 2 ... ... # Generate distortion maps ... for y in range(height): ... for x in range(width): ... # Distance from center ... dx = (x - center_x) / width ... dy = (y - center_y) / height ... r = np.sqrt(dx * dx + dy * dy) ... ... # Apply radial distortion ... factor = 1 + self.distort_limit * r ... map_x[y, x] = x + dx * factor ... map_y[y, x] = y + dy * factor ... ... return {"map_x": map_x, "map_y": map_y} >>> >>> # 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 the custom distortion >>> transform = A.Compose([ ... CustomDistortion( ... distort_limit=0.2, ... interpolation=cv2.INTER_LINEAR, ... mask_interpolation=cv2.INTER_NEAREST, ... keypoint_remapping_method="mask", ... 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'] >>> transformed_mask = transformed['mask'] >>> transformed_bboxes = transformed['bboxes'] >>> transformed_keypoints = transformed['keypoints'] cR\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S rg )BaseDistortion.InitSchemaaLiteral[cv2.INTER_NEAREST, cv2.INTER_LINEAR, cv2.INTER_CUBIC, cv2.INTER_AREA, cv2.INTER_LANCZOS4] interpolationmask_interpolationLiteral['direct', 'mask']keypoint_remapping_methodoLiteral[cv2.BORDER_CONSTANT, cv2.BORDER_REPLICATE, cv2.BORDER_REFLECT, cv2.BORDER_WRAP, cv2.BORDER_REFLECT_101] border_modetuple[float, ...] | floatfill fill_maskN__name__ __module__ __qualname____firstlineno____annotations____static_attributes__r0k/var/www/fran/franai/venv/lib/python3.13/site-packages/albumentations/augmentations/geometric/distortion.py InitSchemar$s2xx  $=<  (',,r8r:rch>[TU]US9 XlX lX0lXPlX`lXplg)N)p)super__init__r'r(r*r,r.r/) selfr'r(r*r<r,r.r/ __class__s r9r>BaseDistortion.__init__s78 1*"4)B&& "r8c t[R"UUUURURUR5$)a2Apply the distortion to the input image. Args: img (np.ndarray): Input image to be distorted. map_x (np.ndarray): X-coordinate map of the distortion. map_y (np.ndarray): Y-coordinate map of the distortion. **params (Any): Additional parameters. Returns: np.ndarray: Distorted image. ) fgeometricremapr'r,r.)r?imgmap_xmap_yparamss r9applyBaseDistortion.applys9&          II   r8spatialTF) has_batch_dim has_depth_dimc (UR"U40UD6$)zApply the distortion 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. rI)r?imagesrHs r9apply_to_imagesBaseDistortion.apply_to_images zz&+F++r8c (UR"U40UD6$)zApply the distortion to a volume. Args: volume (np.ndarray): Volume to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted volume. rO)r?volumerHs r9apply_to_volumeBaseDistortion.apply_to_volumerSr8c (UR"U40UD6$)zApply the distortion 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. rO)r?volumesrHs r9apply_to_volumesBaseDistortion.apply_to_volumes'szz',V,,r8c (UR"U40UD6$)zApply the distortion 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_mask)r?mask3drHs r9apply_to_mask3dBaseDistortion.apply_to_mask3d5s!!&3F33r8c t[R"UUUURURUR5$)a"Apply the distortion to a mask. Args: mask (np.ndarray): Mask to be distorted. map_x (np.ndarray): X-coordinate map of the distortion. map_y (np.ndarray): Y-coordinate map of the distortion. **params (Any): Additional parameters. Returns: np.ndarray: Distorted mask. )rCrDr(r,r/)r?maskrFrGrHs r9r]BaseDistortion.apply_to_maskCs9&     # #    NN   r8c pUSSSn[X5n[R"UUUU5n[Xu5$)a@Apply the distortion to bounding boxes. Args: bboxes (np.ndarray): Bounding boxes to be distorted. map_x (np.ndarray): X-coordinate map of the distortion. map_y (np.ndarray): Y-coordinate map of the distortion. **params (Any): Additional parameters. Returns: np.ndarray: Distorted bounding boxes. shapeN)rrC remap_bboxesr)r?bboxesrFrGrH image_shape bboxes_denormbboxes_returneds r9apply_to_bboxesBaseDistortion.apply_to_bboxes_sG&Wobq) *6? $11        ==r8c URS:Xa[R"XX4S5$[R"XX4S5$)a4Apply the distortion to keypoints. Args: keypoints (np.ndarray): Keypoints to be distorted. map_x (np.ndarray): X-coordinate map of the distortion. map_y (np.ndarray): Y-coordinate map of the distortion. **params (Any): Additional parameters. Returns: np.ndarray: Distorted keypoints. directre)r*rCremap_keypointsremap_keypoints_via_mask)r? keypointsrFrGrHs r9apply_to_keypoints!BaseDistortion.apply_to_keypoints|sA&  ) )X 5--igW W229USZO\\r8)r,r.r/r'r*r()r'r&r(r&r*r)r<floatr,r+r.r-r/r-) rE np.ndarrayrFrvrGrvrHrreturnrv)rPrvrHrrwrv)rUrvrHrrwrv)rYrvrHrrwrv)r^rvrHrrwrv) rbrvrFrvrGrvrHrrwrv) rhrvrFrvrGrvrHrrwrv) rrrvrFrvrGrvrHrrwrv)r2r3r4r5__doc__r_targetsrr:cv2BORDER_CONSTANTr>rIr rQrVrZr_r]rlrsr7 __classcell__r@s@r9r!r!KsgRH-,-X   *+/05"# "# "# $=!"#" #"#$ %"#2(3"#4-5"#"#H         8Yd%H ,I ,Ye4H ,I ,Yd$G -H -Yd%H 4I 4         8>>> >  >  >:]]] ]  ]  ]]r8r!c ^\rSrSrSr"SS\R 5rSS\RSS\RSS \RS S S 4 SU4S jjjr SS jr Sr U=r$)riaXApply 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 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 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. noise_distribution (Literal["gaussian", "uniform"]): Distribution used to generate the displacement fields. "gaussian" generates fields using normal distribution (more natural deformations). "uniform" generates fields using uniform distribution (more mechanical deformations). Default: "gaussian". keypoint_remapping_method (Literal["direct", "mask"]): Method to use for keypoint remapping. - "mask": Uses mask-based remapping. Faster, especially for many keypoints, but may be less accurate for large distortions. Recommended for large images or many keypoints. - "direct": Uses inverse mapping. More accurate for large distortions but slower. Default: "mask" p (float): Probability of applying the transform. Default: 0.5 Targets: image, mask, bboxes, keypoints, volume, mask3d 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. Examples: >>> 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'] cR\rSrSr%S\S'S\S'S\S'S\S'S \S 'S \S 'S rg)ElasticTransform.InitSchemaizAnnotated[float, Field(ge=0)]alphazAnnotated[float, Field(ge=1)]sigmabool approximate same_dxdyLiteral['gaussian', 'uniform']noise_distributionr)r*r0Nr1r0r8r9r:rs%,,,,::#<[T U]UUUU U U U S9 XlX lX@lXPlXplgNr'r(r*r<r,r.r/)r=r>rrrrr)r?rrr'rrr(rr*r,r.r/r<r@s r9r>ElasticTransform.__init__sJB '1&?#    &""4r8c BUSSSup4UR(aSOSn[R"X44URURUR UUR URS9upg[R"[R"[R"U5[R"U555nU[R"Xg/5-n U SR[R5U SR[R5S .$) a=Generate displacement fields for the elastic transform. Args: params (dict[str, Any]): Dictionary containing parameters for the transform. data (dict[str, Any]): Dictionary containing data for the transform. Returns: dict[str, Any]: Dictionary containing displacement fields for the elastic transform. reNrf)r)rr)r kernel_sizerandom_generatorrrrrFrG)rrCgenerate_displacement_fieldsrrrrrnpstackmeshgridarangeastypefloat32) r?rHdataheightwidthrdxdycoordsmapss r9get_params_dependent_on_data-ElasticTransform.get_params_dependent_on_datasw+ "&"2"2h 88 O JJ JJnn#!22#66 "++bii&6 &8IJK"**!W^^BJJ/!W^^BJJ/  r8)rrrrr)rrurrur'r&rrrrr(r&rrr*r)r,r+r.r-r/r-r<rurHdict[str, Any]rrrwrr2r3r4r5rxr!r:rz INTER_LINEAR INTER_NEARESTr{r>rr7r|r}s@r9rrs?B=^..=   !   =G?E   *+/0?.5.5.5 .5.5.5 .5(;).5*$=+.5, -.5:(;.5<-=.5> ?.5.5`# # #   # # r8rc ^\rSrSrSr"SS\R 5rSSS\R\RSSS \RS S 4 SU4S jjjr SS jr S r U=r$)ri4a 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 (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. 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. 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. keypoint_remapping_method (Literal["direct", "mask"]): Method to use for keypoint remapping. - "mask": Uses mask-based remapping. Faster, especially for many keypoints, but may be less accurate for large distortions. Recommended for large images or many keypoints. - "direct": Uses inverse mapping. More accurate for large distortions but slower. Default: "mask" p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, keypoints, bboxes, volume, mask3d 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. Examples: >>> 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"] cv\rSrSr%S\S'S\S'S\S'S\S'\"SS5\S S j55rS rg ) PiecewiseAffine.InitSchemairrscaletuple[int, int] | intnb_rowsnb_colsrabsolute_scalec\S[4n[X5n[U/UQURP76 U$)Nrf)rrr field_name)clsvalueinfoboundsresults r9_process_range)PiecewiseAffine.InitSchema._process_rangexs2 ^Fe+F  9 9 9Mr8r0N)rrrr rwtuple[int, int]) r2r3r4r5r6r classmethodrr7r0r8r9r:rrsW((&&&& I .  ( !     / r8r:)gQ?皙?)rFrbrrc >[T U]UUUUU U U S9 [SSS9 [SU5Ul[SU5Ul[SU5UlX`lg)N)r<r'r(r*r,r.r/zcThis augmenter is very slow. Try to use ``ElasticTransform`` instead, which is at least 10x faster.rf) stackleveltuple[float, float]r)r=r>rrrrrr) r?rrrr'r(rr*r<r,r.r/r@s r9r>PiecewiseAffine.__init__sr@ '1&?#   q /7 -w7 -w7 ,r8cUSSSn[R"URR"UR6SS5n[R"URR"UR 6SS5nURR "UR6n[R"UXE4UURURS9upxXxS.$)Get the parameters dependent on the data. Args: params (dict[str, Any]): Parameters. data (dict[str, Any]): Data. Returns: dict[str, Any]: Parameters. reNrf)rigridrrrr) rclip py_randomrandintrruniformrrCcreate_piecewise_affine_mapsrr) r?rHrrirrrrFrGs r9r,PiecewiseAffine.get_params_dependent_on_datasWobq) ''$..00$,,?DI''$..00$,,?DI&& 3!>>##..!22  //r8)rrrr)rtuple[float, float] | floatrrrrr'r&r(r&rrr*r)r<rur,r+r.r-r/r-rrr}s@r9rr4s;z^..(.:)/)/      $?E   *+/0=2-*2-'2-' 2-  2- 2-&'2-($=)2-* +2-, -2-:(;2-<-=2-2-h000  00r8rc ^\rSrSrSr"SS\R 5rS\R\RSSS\RS S 4 S U4S jjjr SS jr S r U=r$)riu Apply optical distortion to images, masks, bounding boxes, and keypoints. Supports two distortion models: 1. Camera matrix model (original): Uses OpenCV's camera calibration model with k1=k2=k distortion coefficients 2. Fisheye model: Direct radial distortion: r_dist = r * (1 + gamma * r²) Args: distort_limit (float | tuple[float, float]): Range of distortion coefficient. For camera model: recommended range (-0.05, 0.05) For fisheye model: recommended range (-0.3, 0.3) Default: (-0.05, 0.05) mode (Literal['camera', 'fisheye']): Distortion model to use: - 'camera': Original camera matrix model - 'fisheye': Fisheye lens model Default: 'camera' 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. 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. keypoint_remapping_method (Literal["direct", "mask"]): Method to use for keypoint remapping. - "mask": Uses mask-based remapping. Faster, especially for many keypoints, but may be less accurate for large distortions. Recommended for large images or many keypoints. - "direct": Uses inverse mapping. More accurate for large distortions but slower. Default: "mask" p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, bboxes, keypoints, volume, mask3d 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. - Bounding boxes and keypoints are transformed along with the image to maintain consistency. - Fisheye model directly applies radial distortion Examples: >>> import albumentations as A >>> transform = A.Compose([ ... A.OpticalDistortion(distort_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'] c4\rSrSr%S\S'S\S'S\S'Srg ) OpticalDistortion.InitSchemair distort_limitLiteral['camera', 'fisheye']moder)r*r0Nr1r0r8r9r:rs))**#<[T U]UUUUUUU S9 [SU5UlX@lgNrr)r=r>rrr) r?rr'r(rr*r<r,r.r/r@s r9r>OpticalDistortion.__init__sC< '1&?#  ""7G r8cUSSSnURR"UR6nURS:Xa[R "UU5upVO[R "UU5upVXVS.$)rreNrfrr)rrrrrC!get_camera_matrix_distortion_mapsget_fisheye_distortion_maps)r?rHrrikrFrGs r9r.OpticalDistortion.get_params_dependent_on_dataEs}Wobq)  NN " "D$6$6 7 99 %GGLE5 &AALE //r8)rr)rrr'r&r(r&rrr*r)r<rur,r+r.r-r/r-rrr}s@r9rrs;z=^..=6C      -5?E   *+/09(2( ( ("+#($$=%(& '(( )(6(7(8-9((T 0 0 0  0 0r8rc ^\rSrSrSr"SS\R 5rSS\RS\RSS \RS S 4 SU4S jjjr SS jr S r U=r$)riha 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. 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. 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. keypoint_remapping_method (Literal["direct", "mask"]): Method to use for keypoint remapping. - "mask": Uses mask-based remapping. Faster, especially for many keypoints, but may be less accurate for large distortions. Recommended for large images or many keypoints. - "direct": Uses inverse mapping. More accurate for large distortions but slower. Default: "mask" p (float): Probability of applying the transform. Default: 0.5. Targets: image, mask, bboxes, keypoints, volume, mask3d 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. Examples: >>> 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'] ct\rSrSr%S\S'S\S'S\S'S\S '\"S5\S S j55rS rg )GridDistortion.InitSchemaizAnnotated[int, Field(ge=1)] num_stepsrrr normalizedr)r*cPSn[U5n[U/UQURP76 U$)N)r)rrr)rvrrrs r9 _check_limits'GridDistortion.InitSchema._check_limitss-Fa[F  9 9 9Mr8r0N)rrrr rwr) r2r3r4r5r6r rrr7r0r8r9r:rsU..))#<<  )  " ! !    * r8r:)g333333ӿg333333?Trbrrc f>[T U]UUUUUU U S9 Xl[SU5UlX@lgr)r=r>rrrr) r?rrr'rr(r*r<r,r.r/r@s r9r>GridDistortion.__init__sH> '1&?#  #!"7G$r8c"USSSn[URS-5Vs/sH)nSURR"UR6-PM+ nn[URS-5Vs/sH)nSURR"UR6-PM+ nnUR (a,[ R"UURUU5nUSUSpe[ R"UUUUR5upXS.$s snfs snf)rreNrfrsteps_xsteps_yr) rangerrrrrrCnormalize_grid_distortion_steps generate_grid) r?rHrri_rrnormalized_paramsrFrGs r9r+GridDistortion.get_params_dependent_on_datasWobq) LQRVR`R`cdRdLefLeq1t~~--t/A/ABBLefLQRVR`R`cdRdLefLeq1t~~--t/A/ABBLef ?? * J J ! "),!), "//    NN  //-gfs 0D/0D )rrr)rintrrr'r&rrr(r&r*r)r<rur,r+r.r-r/r-rrr}s@r9rrhs4l^..(5@      ?E   *+/0;*%*%3*% *%*% *%&$='*%( )*%* +*%8(9*%:-;*%*%X&0&0&0  &0&0r8rc ^\rSrSrSr"SS\R 5rSS\R\RSS\RS S 4 S U4S jjjr SS jr S r U=r$)riazApply Thin Plate Spline (TPS) transformation to create smooth, non-rigid deformations. Imagine the image printed on a thin metal plate that can be bent and warped smoothly: - Control points act like pins pushing or pulling the plate - The plate resists sharp bending, creating smooth deformations - The transformation maintains continuity (no tears or folds) - Areas between control points are interpolated naturally The transform works by: 1. Creating a regular grid of control points (like pins in the plate) 2. Randomly displacing these points (like pushing/pulling the pins) 3. Computing a smooth interpolation (like the plate bending) 4. Applying the resulting deformation to the image Args: scale_range (tuple[float, float]): Range for random displacement of control points. Values should be in [0.0, 1.0]: - 0.0: No displacement (identity transform) - 0.1: Subtle warping - 0.2-0.4: Moderate deformation (recommended range) - 0.5+: Strong warping Default: (0.2, 0.4) num_control_points (int): Number of control points per side. Creates a grid of num_control_points x num_control_points points. - 2: Minimal deformation (affine-like) - 3-4: Moderate flexibility (recommended) - 5+: More local deformation control Must be >= 2. Default: 4 interpolation (int): OpenCV interpolation flag. Used for image sampling. See also: cv2.INTER_* Default: cv2.INTER_LINEAR mask_interpolation (int): OpenCV interpolation flag. Used for mask sampling. See also: cv2.INTER_* Default: cv2.INTER_NEAREST keypoint_remapping_method (Literal["direct", "mask"]): Method to use for keypoint remapping. - "mask": Uses mask-based remapping. Faster, especially for many keypoints, but may be less accurate for large distortions. Recommended for large images or many keypoints. - "direct": Uses inverse mapping. More accurate for large distortions but slower. Default: "mask" p (float): Probability of applying the transform. Default: 0.5 Targets: image, mask, keypoints, bboxes, volume, mask3d Image types: uint8, float32 Note: - The transformation preserves smoothness and continuity - Stronger scale values may create more extreme deformations - Higher number of control points allows more local deformations - The same deformation is applied consistently to all targets Examples: >>> import numpy as np >>> import albumentations as A >>> import cv2 >>> >>> # Create sample data >>> image = np.zeros((100, 100, 3), dtype=np.uint8) >>> mask = np.zeros((100, 100), dtype=np.uint8) >>> mask[25:75, 25:75] = 1 # Square mask >>> bboxes = np.array([[10, 10, 40, 40]]) # Single box >>> bbox_labels = [1] >>> keypoints = np.array([[50, 50]]) # Single keypoint at center >>> keypoint_labels = [0] >>> >>> # Set up transform with Compose to handle all targets >>> transform = A.Compose([ ... A.ThinPlateSpline(scale_range=(0.2, 0.4), 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 to all targets >>> result = transform( ... image=image, ... mask=mask, ... bboxes=bboxes, ... bbox_labels=bbox_labels, ... keypoints=keypoints, ... keypoint_labels=keypoint_labels ... ) >>> >>> # Access transformed results >>> transformed_image = result['image'] >>> transformed_mask = result['mask'] >>> transformed_bboxes = result['bboxes'] >>> transformed_bbox_labels = result['bbox_labels'] >>> transformed_keypoints = result['keypoints'] >>> transformed_keypoint_labels = result['keypoint_labels'] References: - "Principal Warps: Thin-Plate Splines and the Decomposition of Deformations" by F.L. Bookstein https://doi.org/10.1109/34.24792 - Thin Plate Splines in Computer Vision: https://en.wikipedia.org/wiki/Thin_plate_spline - Similar implementation in Kornia: https://kornia.readthedocs.io/en/latest/augmentation.html#kornia.augmentation.RandomThinPlateSpline See Also: - ElasticTransform: For different type of non-rigid deformation - GridDistortion: For grid-based warping - OpticalDistortion: For lens-like distortions c@\rSrSr%S\S'\"SS9rS\S'S\S 'S rg ) ThinPlateSpline.InitSchemaizzHAnnotated[tuple[float, float], AfterValidator(check_range_bounds(0, 1))] scale_rangerf)gernum_control_pointsr)r*r0N)r2r3r4r5r6r rr7r0r8r9r:rzs]]"'1+C-#<[T U]UUUUUUU S9 XlX lgr)r=r>rr) r?rrr'r(r*r<r,r.r/r@s r9r>ThinPlateSpline.__init__s:< '1&?#  '"4r8cbUSSSup4[R"UR5nURR"UR 6S- nXPR RSUUR5-n[R"XW5up[R"[R"U5[R"U55up[R"U R5U R5/SS9R[R 5n [R""XU/- UUU 5n XU/-n U SS2S4R%X45R[R 5U SS2S4R%X45R[R 5S.$) rreNrf rr)axisr)rCgenerate_control_pointsrrrrrnormalrecompute_tps_weightsrrrrflattenrr tps_transformreshape)r?rHrrr src_pointsr dst_pointsweightsaffinexypoints transformeds r9r,ThinPlateSpline.get_params_dependent_on_dataslw+ 778O8OP &&(8(89B>"7"7">">    #  %88P{{299U+RYYv->?199; 41=DDRZZP!.. V_ $     v& !A&..v=DDRZZP A&..v=DDRZZP  r8)rr)rrrrr'r&r(r&r*r)r<rur,r+r.r-r/r-rrr}s@r9rrsqf=^..=,6"#      ?E   *+/09(5((5 (5 (5 (5$$=%(5& '(5( )(56(7(58-9(5(5T- - -   - - r8r)/rx __future__rtypingrrrrwarningsrrznumpyralbucorer pydanticr r r r "albumentations.augmentations.utilsralbumentations.core.bbox_utilsrralbumentations.core.pydanticrrr(albumentations.core.transforms_interfacerr$albumentations.core.type_definitionsrralbumentations.core.utilsrrrC__all__r!rrrrrr0r8r9rs8#00 $; /& F]]F]R ] ~] @a0na0HM0M0`[0^[0|P nP r8