bi`dZddlmZddlmZmZmZmZddlm Z ddl Z ddl Z ddl mZddlmZmZmZmZddlmZdd lmZmZdd lmZmZmZdd lmZmZdd l m!Z!m"Z"dd l#m$Z$ddl%m&Z'gdZ(GddeZ)Gdde)Z*Gdde)Z+Gdde)Z,Gdde)Z-Gdde)Z.y)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)ElasticTransformGridDistortionOpticalDistortionPiecewiseAffineThinPlateSplinecteZdZdZeZGddeZejddf dfd Z ddZ e ddd dd Z e dd d dd Ze ddd dd Ze ddd ddZ ddZ ddZ ddZxZS)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). 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'] cJeZdZUded<ded<ded<ded<ded <ded <y ) 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____annotations__l/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/albumentations/augmentations/geometric/distortion.py InitSchemar#s2xx  $=<  (',,r4r6rczt||||_||_||_||_||_||_y)N)p)super__init__r%r&r(r*r,r-) selfr%r&r(r8r*r,r- __class__s r5r:zBaseDistortion.__init__sC8 1*"4)B&& "r4c rtj||||j|j|jS)arApply 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 r5applyzBaseDistortion.applys9&          II   r4spatialTF) has_batch_dim has_depth_dimc (|j|fi|S)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. rD)r;imagesrCs r5apply_to_imageszBaseDistortion.apply_to_images tzz&+F++r4c (|j|fi|S)zApply the distortion to a volume. Args: volume (np.ndarray): Volume to be distorted. **params (Any): Additional parameters. Returns: np.ndarray: Distorted volume. rI)r;volumerCs r5apply_to_volumezBaseDistortion.apply_to_volumerLr4c (|j|fi|S)aApply 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. rI)r;volumesrCs r5apply_to_volumeszBaseDistortion.apply_to_volumes'stzz',V,,r4c (|j|fi|S)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;mask3drCs r5apply_to_mask3dzBaseDistortion.apply_to_mask3d5s"t!!&3F33r4c rtj||||j|j|jS)abApply 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. )r>r?r&r*r-)r;maskrArBrCs r5rTzBaseDistortion.apply_to_maskCs9&     # #    NN   r4c r|ddd}t||}tj||||}t||S)aApply 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)rr> remap_bboxesr)r;bboxesrArBrC image_shape bboxes_denormbboxes_returneds r5apply_to_bboxeszBaseDistortion.apply_to_bboxes_sK&Wobq) *6;? $11        ==r4c |jdk(rtj||||dStj||||dS)atApply 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. directrZ)r(r>remap_keypointsremap_keypoints_via_mask)r; keypointsrArBrCs r5apply_to_keypointsz!BaseDistortion.apply_to_keypoints|sI&  ) )X 5--ivgW W229eUFSZO\\r4)r%r$r&r$r(r'r8floatr*r)r,r+r-r+) r@ np.ndarrayrArirBrirCrreturnri)rJrirCrrjri)rNrirCrrjri)rQrirCrrjri)rUrirCrrjri) rXrirArirBrirCrrjri) r]rirArirBrirCrrjri) rfrirArirBrirCrrjri)r/r0r1__doc__r_targetsrr6cv2BORDER_CONSTANTr:rDr rKrOrRrVrTrarg __classcell__r<s@r5r!r!KsgRH-,-X   *+/05"# "# "# $=!"#" #"#$ %"#2(3"#4-5"#H         8Yd%H ,I ,Ye4H ,I ,Yd$G -H -Yd%H 4I 4         8>>> >  >  >:]]] ]  ]  ]r4r!c eZdZdZGddej Zddejddejddejd d d f d fd Z dd Z xZ S)ra0Apply 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'] cJeZdZUded<ded<ded<ded<ded <d ed <y ) ElasticTransform.InitSchemazAnnotated[float, Field(ge=0)]alphazAnnotated[float, Field(ge=1)]sigmabool approximate same_dxdyLiteral['gaussian', 'uniform']noise_distributionr'r(Nr.r3r4r5r6rss%,,,,::#<generate_displacement_fieldsrtrurxrrznpstackmeshgridarangeastypefloat32) r;rCdataheightwidthrdxdycoordsmapss r5get_params_dependent_on_dataz-ElasticTransform.get_params_dependent_on_datasw+ "&"2"2h 88 UO JJ JJnn#!22#66 B"++bii&6 &8IJK"b**!W^^BJJ/!W^^BJJ/  r4)rtrhrurhr%r$rwrvrxrvr&r$rzryr(r'r*r)r,r+r-r+r8rhrCdict[str, Any]rrrjr r/r0r1rkr!r6rm INTER_LINEAR INTER_NEARESTrnr:rrorps@r5rrs?B=^..=   !   =G?E   *+/0?.5.5.5 .5.5.5 .5(;).5*$=+.5, -.5:(;.5<-=.5> ?.5`# # #   # r4rc eZdZdZGddej Zdddejejdddejd d f d fd Z d d Z xZ S)raApply 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"] cleZdZUded<ded<ded<ded<edde d dZy ) PiecewiseAffine.InitSchemarscaletuple[int, int] | intnb_rowsnb_colsrvabsolute_scalec^dtf}t||}t|g||j|S)Nr[)rrr field_name)clsvalueinfoboundsresults r5_process_rangez)PiecewiseAffine.InitSchema._process_rangexs4 ^FeU+F  9 9 9Mr4N)rrrr rjtuple[int, int])r/r0r1r2r classmethodrr3r4r5r6rrsW((&&&& I .  ( !     / r4r6)gQ?皙?)rFrXr}rc t |||||| | | tddtd||_td||_td||_||_y)N)r8r%r&r(r*r,r-zcThis augmenter is very slow. Try to use ``ElasticTransform`` instead, which is at least 10x faster.r[) stackleveltuple[float, float]r)r9r:rrrrrr) r;rrrr%r&rr(r8r*r,r-r<s r5r:zPiecewiseAffine.__init__st@ '1&?#   q /7 -w7 -w7 ,r4c|ddd}tj|jj|jdd}tj|jj|j dd}|jj |j}tj|||f||j|j\}}||dS)Get the parameters dependent on the data. Args: params (dict[str, Any]): Parameters. data (dict[str, Any]): Data. Returns: dict[str, Any]: Parameters. rZNr[)r^gridrrrr) rclip py_randomrandintrruniformrr>create_piecewise_affine_mapsrr) r;rCrr^rrrrArBs r5rz,PiecewiseAffine.get_params_dependent_on_datasWobq) ''0$..00$,,?DI''0$..00$,,?DI&&& 3!>>#7#..!22  u//r4)rtuple[float, float] | floatrrrrr%r$r&r$rrvr(r'r8rhr*r)r,r+r-r+rrrps@r5rr4s;z^..(.:)/)/      $?E   *+/0=2-*2-'2-' 2-  2- 2-&'2-($=)2-* +2-, -2-:(;2-<-=2-h000  0r4rc eZdZdZGddej Zdejejdddejddf d fd Z d d Z xZ S) ru 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'] c,eZdZUded<ded<ded<y)OpticalDistortion.InitSchemar distort_limitLiteral['camera', 'fisheye']moder'r(Nr.r3r4r5r6rs))**#<!get_camera_matrix_distortion_mapsget_fisheye_distortion_maps)r;rCrr^krArBs r5rz.OpticalDistortion.get_params_dependent_on_dataEsWobq)  #DNN " "D$6$6 7 99 %GGLE5 &AALE5 //r4)rrr%r$r&r$rrr(r'r8rhr*r)r,r+r-r+rrrps@r5rrs;z=^..=6C      -5?E   *+/09(2( ( ("+#($$=%(& '(( )(6(7(8-9(T 0 0 0  0r4rc eZdZdZGddej Zddejdejddejd d f d fd Z d d Z xZ S)raJ 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'] cjeZdZUded<ded<ded<ded<ede d d Zy ) GridDistortion.InitSchemazAnnotated[int, Field(ge=1)] num_stepsrrrv normalizedr'r(cPd}t|}t|g||j|S)N)r)rrr)rvrrrs r5 _check_limitsz'GridDistortion.InitSchema._check_limitss-Fa[F  9 9 9Mr4N)rrrr rjr)r/r0r1r2r rrr3r4r5r6rsU..))#<<  )  " ! !    * r4r6)g333333ӿg333333?TrXr}rc pt ||||||| | ||_td||_||_yr)r9r:rrrr) r;rrr%rr&r(r8r*r,r-r<s r5r:zGridDistortion.__init__sL> '1&?#  #!"7G$r4c|ddd}t|jdzDcgc](}d|jj|jz*}}t|jdzDcgc](}d|jj|jz*}}|j r,t j||j||}|d|d}}t j||||j\}} || dScc}wcc}w)rrZNr[rsteps_xsteps_yr) rangerrrrrr>normalize_grid_distortion_steps generate_grid) r;rCrr^_rrnormalized_paramsrArBs r5rz+GridDistortion.get_params_dependent_on_datasWobq) LQRVR`R`cdRdLefq1-t~~--t/A/ABBffLQRVR`R`cdRdLefq1-t~~--t/A/ABBff ?? * J J ! "),!),G "//    NN  u//-gfs -C=,-D)rintrrr%r$rrvr&r$r(r'r8rhr*r)r,r+r-r+rrrps@r5rrhs4l^..(5@      ?E   *+/0;*%*%3*% *%*% *%&$='*%( )*%* +*%8(9*%:-;*%X&0&0&0  &0r4rc eZdZdZGddej Zddejejddejddf d fd Z d d Z xZ S) raApply 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>eZdZUded<edZded<ded<y ) ThinPlateSpline.InitSchemazHAnnotated[tuple[float, float], AfterValidator(check_range_bounds(0, 1))] scale_ranger[)gernum_control_pointsr'r(N)r/r0r1r2r rr3r4r5r6rzs]]"'1+C-#<< '1&?#  '"4r4cl|ddd\}}tj|j}|jj|j dz }||j jd||jz}tj||\}} tjtj|tj|\} } tj| j| jgdjtj } tj"| ||gz ||| } | ||gz} | dddfj%||jtj | dddfj%||jtj dS) rrZNr[ rr)axisr)r>generate_control_pointsrrrrrnormalrZcompute_tps_weightsrrrrflattenrr tps_transformreshape)r;rCrrr src_pointsr dst_pointsweightsaffinexypoints transformeds r5rz,ThinPlateSpline.get_params_dependent_on_datasw+ 778O8OP '&&(8(89B>$"7"7">">    #  %88ZP{{299U+RYYv->?1199; 41=DDRZZP!.. eV_ $     v& !A&..vu=DDRZZP A&..vu=DDRZZP  r4)rrrrr%r$r&r$r(r'r8rhr*r)r,r+r-r+rrrps@r5rrsqf=^..=,6"#      ?E   *+/09(5((5 (5 (5 (5$$=%(5& '(5( )(56(7(58-9(5T- - -   - r4r)/rk __future__rtypingrrrrwarningsrrmnumpyralbucorer pydanticr r r r "albumentations.augmentations.utilsralbumentations.core.bbox_utilsrralbumentations.core.pydanticrrr(albumentations.core.transforms_interfacerr$albumentations.core.type_definitionsrralbumentations.core.utilsrrr>__all__r!rrrrrr3r4r5rs8#00 $; /& F]]F]R ] ~] @a0na0HM0M0`[0^[0|P nP r4