U h@sddlmZddlZddlZddlmZmZmZmZddl Z ddl Z ddl m Z mZmZmZddlmZddlmZddlmZddlmZdd lmZmZmZmZdd lm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&d dl'mZ(ddddddddgZ)dZ*dZ+d)dddddddZ,Gdd d e Z-Gd!dde!Z.Gd"dde.Z/Gd#dde.Z0Gd$dde!Z1Gd%dde!Z2Gd&dde!Z3Gd'dde!Z4Gd(dde!Z5dS)*) annotationsN)AnyLiteralTuplecast)FieldValidationInfofield_validatormodel_validator)Self) random_utils) functional) check_range)NonNegativeFloatRangeTypeOnePlusFloatRangeTypeOnePlusIntRangeTypeSymmetricRangeType)BaseTransformInitSchemaImageOnlyTransform)ScaleFloatType ScaleIntType)to_tupleBlur MotionBlur GaussianBlur GlassBlur AdvancedBlur MedianBlurDefocusZoomBlur?rrfloattuple[int, int])valueinfo min_valuereturncCsZdtdf}t||}t|f||jf|D]&}|dkr.|ddkr.td|q.|S)Nrinfr"r"Blur limit must be 0 or odd. Got: )r#rr field_name ValueError)r%r&r'Zboundsresultvr/P/tmp/pip-unpacked-wheel-e8onvpoz/albumentations/augmentations/blur/transforms.pyprocess_blur_limit"s  r1c@s4eZdZUded<ededdddddZdS) BlurInitSchemar blur_limitrr$r%r&r(cCst||ddS)Nr'r1clsr%r&r/r/r0 process_blur0szBlurInitSchema.process_blurN)__name__ __module__ __qualname____annotations__r classmethodr:r/r/r/r0r2-s r2csleZdZdZGdddeZdddd d fd d Zd ddd dddZddddZddddZ Z S)rakApply uniform box blur to the input image using a randomly sized square kernel. This transform uses OpenCV's cv2.blur function, which performs a simple box filter blur. The size of the blur kernel is randomly selected for each application, allowing for varying degrees of blur intensity. Args: blur_limit (tuple[int, int] | int): Controls the range of the blur kernel size. - If a single int is provided, the kernel size will be randomly chosen between 3 and that value. - If a tuple of two ints is provided, it defines the inclusive range of possible kernel sizes. The kernel size must be odd and greater than or equal to 3. Larger kernel sizes produce stronger blur effects. Default: (3, 7) p (float): Probability of applying the transform. Default: 0.5 Notes: - The blur kernel is always square (same width and height). - Only odd kernel sizes are used to ensure the blur has a clear center pixel. - Box blur is faster than Gaussian blur but may produce less natural results. - This blur method averages all pixels under the kernel area, which can reduce noise but also reduce image detail. Targets: image Image types: uint8, float32 Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.Blur(blur_limit=(3, 7), p=1.0) >>> result = transform(image=image) >>> blurred_image = result["image"] c@s eZdZdS)zBlur.InitSchemaN)r;r<r=r/r/r/r0 InitSchema_sr@r5r!Nrr# bool | Noner3p always_applycs(tj||dttttf||_dSNrErF)super__init__rrintr3selfr3rErF __class__r/r0rJbsz Blur.__init__ np.ndarrayrKrimgkernelparamsr(cKs t||SN)fblurZblurrMrRrSrTr/r/r0applyfsz Blur.applydict[str, Any]r(cCs*dttt|jd|jdddiS)NrSrrr")r choicelistranger3rMr/r/r0 get_paramsiszBlur.get_paramstuple[str, ...]cCsdS)N)r3r/r^r/r/r0get_transform_init_args_nameslsz"Blur.get_transform_init_args_names)rAr!N r;r<r=__doc__r2r@rJrXr_ra __classcell__r/r/rNr0r6s (csreZdZdZGdddeZddd d d d fd d Zddfdd ZdddddddZddddZ Z S)ra Apply motion blur to the input image using a random-sized kernel. This transform simulates the effect of camera or object motion during image capture, creating a directional blur. It uses a line-shaped kernel with random orientation to achieve this effect. Args: blur_limit (int | tuple[int, int]): Maximum kernel size for blurring the input image. Should be in range [3, inf). - If a single int is provided, the kernel size will be randomly chosen between 3 and that value. - If a tuple of two ints is provided, it defines the inclusive range of possible kernel sizes. Default: (3, 7) allow_shifted (bool): If set to True, allows the motion blur kernel to be randomly shifted from the center. If False, the kernel will always be centered. Default: True p (float): Probability of applying the transform. Default: 0.5 Targets: image Image types: uint8, float32 Number of channels: Any Note: - The blur kernel is always a straight line, simulating linear motion. - The angle of the motion blur is randomly chosen for each application. - Larger kernel sizes result in more pronounced motion blur effects. - When `allow_shifted` is True, the blur effect can appear more natural and varied, as it simulates motion that isn't perfectly centered in the frame. - This transform is particularly useful for: * Simulating camera shake or motion blur in action scenes * Data augmentation for object detection or tracking tasks * Creating more challenging inputs for image stabilization algorithms Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.MotionBlur(blur_limit=7, allow_shifted=True, p=0.5) >>> result = transform(image=image) >>> motion_blurred_image = result["image"] References: - Motion blur: https://en.wikipedia.org/wiki/Motion_blur - OpenCV filter2D (used internally): https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga27c049795ce870216ddfb366086b5a04 c@s6eZdZUded<ded<eddddd d Zd S) zMotionBlur.InitSchemabool allow_shiftedrr3aftermoder rZcCsHt|jd|_|jrDt|jtrDtdd|jDrDtd|j|S)Nr5css|]}|ddkVqdS)r"rNr/).0xr/r/r0 sz5MotionBlur.InitSchema.process_blur..z0Blur limit must be odd when centered=True. Got: )rr3rf isinstancetupleanyr,r^r/r/r0r:s&z"MotionBlur.InitSchema.process_blurN)r;r<r=r>r r:r/r/r/r0r@s r@rBTNr!rrerCr#)r3rfrFrEcs0tj|||d||_ttttf||_dSNrD)rIrJrfrrrKr3)rMr3rfrFrErNr/r0rJszMotionBlur.__init__r`rZcstdS)Nrf)rf)rIrar^rNr/r0rasz(MotionBlur.get_transform_init_args_namesrPrrQcKstj||dSN)rSfmainZconvolverWr/r/r0rXszMotionBlur.applyrYc sttt|jd|jddd}|tkr 2. Got: )ZdtyperKr$)v1v2r(cSs>t||d}|ddkr6||kr.|d8}n|d8}||fS)Nrr")abs)rtruZlen_vr/r/r0 make_odd_vals   z+MotionBlur.get_params..make_odd_valr!c3s|]}t|VqdSrUrKrji)dxr/r0rlsz(MotionBlur.get_params..c3s|]}t|VqdSrUrxry)dyr/r0rls)Z thicknessrS)randomr[r\r]r3TWOr,npzerosZuint8randintsamplerfcv2lineastypefloat32sum) rMksizerSx1Zx2y1y2rwZxcZyccenterr/)r{r|r0r_s*&""    zMotionBlur.get_params)rBTNr!) r;r<r=rcrr@rJrarXr_rdr/r/rNr0rps7 cs@eZdZdZdddddfd d Zd d d d dddZZS)ra8Apply median blur to the input image. This transform uses a median filter to blur the input image. Median filtering is particularly effective at removing salt-and-pepper noise while preserving edges, making it a popular choice for noise reduction in image processing. Args: blur_limit (int | tuple[int, int]): Maximum aperture linear size for blurring the input image. Must be odd and in the range [3, inf). - If a single int is provided, the kernel size will be randomly chosen between 3 and that value. - If a tuple of two ints is provided, it defines the inclusive range of possible kernel sizes. Default: (3, 7) p (float): Probability of applying the transform. Default: 0.5 Targets: image Image types: uint8, float32 Number of channels: Any Note: - The kernel size (aperture linear size) must always be odd and greater than 1. - Unlike mean blur or Gaussian blur, median blur uses the median of all pixels under the kernel area, making it more robust to outliers. - This transform is particularly useful for: * Removing salt-and-pepper noise * Preserving edges while smoothing images * Pre-processing images for edge detection algorithms - For color images, the median is calculated independently for each channel. - Larger kernel sizes result in stronger blurring effects but may also remove fine details from the image. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.MedianBlur(blur_limit=(3, 7), p=0.5) >>> result = transform(image=image) >>> blurred_image = result["image"] References: - Median filter: https://en.wikipedia.org/wiki/Median_filter - OpenCV medianBlur: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga564869aa33e58769b4469101aac458f9 rBr!Nrr#rCrDcstj|||ddSrp)rIrJrLrNr/r0rJ!szMedianBlur.__init__rPrKrrQcKs t||SrU)rVZ median_blurrWr/r/r0rX$szMedianBlur.apply)rBr!N)r;r<r=rcrJrXrdr/r/rNr0rs3cspeZdZdZGdddeZddd d d d fd d Zddd dddddZddddZddddZ Z S)ra Apply Gaussian blur to the input image using a randomly sized kernel. This transform blurs the input image using a Gaussian filter with a random kernel size and sigma value. Gaussian blur is a widely used image processing technique that reduces image noise and detail, creating a smoothing effect. Args: blur_limit (tuple[int, int] | int): Controls the range of the Gaussian kernel size. - If a single int is provided, the kernel size will be randomly chosen between 0 and that value. - If a tuple of two ints is provided, it defines the inclusive range of possible kernel sizes. Must be zero or odd and in range [0, inf). If set to 0, it will be computed from sigma as `round(sigma * (3 if img.dtype == np.uint8 else 4) * 2 + 1) + 1`. Larger kernel sizes produce stronger blur effects. Default: (3, 7) sigma_limit (tuple[float, float] | float): Range for the Gaussian kernel standard deviation (sigma). Must be in range [0, inf). - If a single float is provided, sigma will be randomly chosen between 0 and that value. - If a tuple of two floats is provided, it defines the inclusive range of possible sigma values. If set to 0, sigma will be computed as `sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8`. Larger sigma values produce stronger blur effects. Default: 0 p (float): Probability of applying the transform. Should be in the range [0, 1]. Default: 0.5 Targets: image Image types: uint8, float32 Number of channels: Any Note: - The relationship between kernel size and sigma affects the blur strength: larger kernel sizes allow for stronger blurring effects. - When both blur_limit and sigma_limit are set to ranges starting from 0, the blur_limit minimum is automatically set to 3 to ensure a valid kernel size. - For uint8 images, the computation might be faster than for floating-point images. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.GaussianBlur(blur_limit=(3, 7), sigma_limit=(0.1, 2), p=1) >>> result = transform(image=image) >>> blurred_image = result["image"] c@sLeZdZUded<ededddddd Zed d d d ddZdS)zGaussianBlur.InitSchemar sigma_limitr3rrr$r4cCst||ddS)Nrr6r7r8r/r/r0r:csz$GaussianBlur.InitSchema.process_blurrgrhr rZcCst|jttfr`|jddkr`t|jttfr`|jddkr`dtd|jdf|_tjdddt|jtr|jD](}|dkrr|ddkrrtd|jqr|S)Nrr5rzkblur_limit and sigma_limit minimum value can not be both equal to 0. blur_limit minimum value changed to 3.r" stacklevelr*) rmr3rnr\rmaxwarningswarnr,)rMr.r/r/r0validate_limitshs$    z'GaussianBlur.InitSchema.validate_limitsN) r;r<r=r>r r?r:r rr/r/r/r0r@`s r@rArNr!rrrCr#)r3rrFrEcs:t||ttttf||_ttttf||_dSrU)rIrJrrrKr3r#r)rMr3rrFrErNr/r0rJ~szGaussianBlur.__init__rPrKr)rRrsigmarTr(cKstj|||dS)N)r)rVZ gaussian_blur)rMrRrrrTr/r/r0rXszGaussianBlur.applyzdict[str, float]rZcCsXt|jd|jdd}|dkrF|ddkrF|d|jdd}|tj|jdS)Nrrr")rr)r} randranger3uniformr)rMrr/r/r0r_szGaussianBlur.get_paramstuple[str, str]cCsdS)N)r3rr/r^r/r/r0rasz*GaussianBlur.get_transform_init_args_names)rArNr!rbr/r/rNr0r(s7  csxeZdZdZGdddeZdd d d d d d dfdd ZddddddddZddddddZddddZ Z S) ra Apply a glass blur effect to the input image. This transform simulates the effect of looking through textured glass by locally shuffling pixels in the image. It creates a distorted, frosted glass-like appearance. Args: sigma (float): Standard deviation for the Gaussian kernel used in the process. Higher values increase the blur effect. Must be non-negative. Default: 0.7 max_delta (int): Maximum distance in pixels for shuffling. Determines how far pixels can be moved. Larger values create more distortion. Must be a positive integer. Default: 4 iterations (int): Number of times to apply the glass blur effect. More iterations create a stronger effect but increase computation time. Must be a positive integer. Default: 2 mode (Literal["fast", "exact"]): Mode of computation. Options are: - "fast": Uses a faster but potentially less accurate method. - "exact": Uses a slower but more precise method. Default: "fast" p (float): Probability of applying the transform. Should be in the range [0, 1]. Default: 0.5 Targets: image Image types: uint8, float32 Number of channels: Any Note: - This transform is particularly effective for creating a 'looking through glass' effect or simulating the view through a frosted window. - The 'fast' mode is recommended for most use cases as it provides a good balance between effect quality and computation speed. - Increasing 'iterations' will strengthen the effect but also increase the processing time linearly. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.GlassBlur(sigma=0.7, max_delta=4, iterations=3, mode="fast", p=1) >>> result = transform(image=image) >>> glass_blurred_image = result["image"] References: - This implementation is based on the technique described in: "ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness" https://arxiv.org/abs/1903.12261 - Original implementation: https://github.com/hendrycks/robustness/blob/master/ImageNet-C/create_c/make_imagenet_c.py c@sLeZdZUeddZded<eddZded<eddZded<d ed <d S) zGlassBlur.InitSchemar)ger#rrrK max_delta iterationsLiteral[('fast', 'exact')]riN)r;r<r=rrr>rrr/r/r/r0r@s r@ffffff?r"fastNr!r#rKrrC)rrrrirFrEcs,tj||d||_||_||_||_dSrG)rIrJrrrri)rMrrrrirFrErNr/r0rJs zGlassBlur.__init__rPr)rRargsdxyrTr(cOst||j|j|j||jSrU)rVZ glass_blurrrrri)rMrRrrrTr/r/r0rXszGlassBlur.applyrYdict[str, np.ndarray])rTdatar(c Csb|ddd\}}||jd}||jd}t||}tj|j |j||jdfd}d|iS)Nshaper")sizer)rrKr rr) rMrTrheightwidthZ width_pixelsZ height_pixelsZ total_pixelsrr/r/r0get_params_dependent_on_datas  z&GlassBlur.get_params_dependent_on_dataztuple[str, str, str, str]rZcCsdS)N)rrrrir/r^r/r/r0rasz'GlassBlur.get_transform_init_args_names)rrr"rNr!) r;r<r=rcrr@rJrXrrardr/r/rNr0rs= c szeZdZdZGdddeZdd d d d d d d d ddd fdd ZdddddddZddddZddddZ Z S) ruApplies a Generalized Gaussian blur to the input image with randomized parameters for advanced data augmentation. This transform creates a custom blur kernel based on the Generalized Gaussian distribution, which allows for a wide range of blur effects beyond standard Gaussian blur. It then applies this kernel to the input image through convolution. The transform also incorporates noise into the kernel, resulting in a unique combination of blurring and noise injection. Key features of this augmentation: 1. Generalized Gaussian Kernel: Uses a generalized normal distribution to create kernels that can range from box-like blurs to very peaked blurs, controlled by the beta parameter. 2. Anisotropic Blurring: Allows for different blur strengths in horizontal and vertical directions (controlled by sigma_x and sigma_y), and rotation of the kernel. 3. Kernel Noise: Adds multiplicative noise to the kernel before applying it to the image, creating more diverse and realistic blur effects. Implementation Details: The kernel is generated using a 2D Generalized Gaussian function. The process involves: 1. Creating a 2D grid based on the kernel size 2. Applying rotation to this grid 3. Calculating the kernel values using the Generalized Gaussian formula 4. Adding multiplicative noise to the kernel 5. Normalizing the kernel The resulting kernel is then applied to the image using convolution. Args: blur_limit (tuple[int, int] | int, optional): Controls the size of the blur kernel. If a single int is provided, the kernel size will be randomly chosen between 3 and that value. Must be odd and ≥ 3. Larger values create stronger blur effects. Default: (3, 7) sigma_x_limit (tuple[float, float] | float): Controls the spread of the blur in the x direction. Higher values increase blur strength. If a single float is provided, the range will be (0, limit). Default: (0.2, 1.0) sigma_y_limit (tuple[float, float] | float): Controls the spread of the blur in the y direction. Higher values increase blur strength. If a single float is provided, the range will be (0, limit). Default: (0.2, 1.0) rotate_limit (tuple[int, int] | int): Range of angles (in degrees) for rotating the kernel. This rotation allows for diagonal blur directions. If limit is a single int, an angle is picked from (-rotate_limit, rotate_limit). Default: (-90, 90) beta_limit (tuple[float, float] | float): Shape parameter of the Generalized Gaussian distribution. - beta = 1 gives a standard Gaussian distribution - beta < 1 creates heavier tails, resulting in more uniform, box-like blur - beta > 1 creates lighter tails, resulting in more peaked, focused blur Default: (0.5, 8.0) noise_limit (tuple[float, float] | float): Controls the strength of multiplicative noise applied to the kernel. Values around 1.0 keep the original kernel mostly intact, while values further from 1.0 introduce more variation. Default: (0.75, 1.25) p (float): Probability of applying the transform. Default: 0.5 Notes: - This transform is particularly useful for simulating complex, real-world blur effects that go beyond simple Gaussian blur. - The combination of blur and noise can help in creating more robust models by simulating a wider range of image degradations. - Extreme values, especially for beta and noise, may result in unrealistic effects and should be used cautiously. Reference: This transform is inspired by techniques described in: "Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data" https://arxiv.org/abs/2107.10833 Targets: image Image types: uint8, float32 c@sjeZdZUded<ded<ded<ded<ded<ededd d d d Zed dddddZdS)zAdvancedBlur.InitSchemar sigma_x_limit sigma_y_limit beta_limit noise_limitr rotate_limitrztuple[float, float])r%r(cCs:t|dd}|ddkr(|dks6nd}t||S)Nr)low?rz&beta_limit is expected to include 1.0.)rr,)r9r%r-msgr/r/r0check_beta_limitVs  z(AdvancedBlur.InitSchema.check_beta_limitrgrhr rZcCsLt|jttfrH|jddkrHt|jttfrH|jddkrHd}t||S)NrzHsigma_x_limit and sigma_y_limit minimum value cannot be both equal to 0.)rmrrnr\rr,)rMrr/r/r0r_s  z'AdvancedBlur.InitSchema.validate_limitsN) r;r<r=r>r r?rr rr/r/r/r0r@Os r@rAg?rNiZr!g @g?g?r!rrzScaleFloatType | NonerCr#) r3rr sigmaX_limit sigmaY_limitrrrrFrEc stj| | d|dk r,tjdtdd|}|dk rHtjdtdd|}ttttf||_ttt t f||_ ttt t f||_ ttttf||_ ttt t f||_ ttt t f||_dS)NrHz6sigmaX_limit is deprecated; use sigma_x_limit instead.r"rz6sigmaY_limit is deprecated; use sigma_y_limit instead.)rIrJrrDeprecationWarningrrrKr3r#rrrrr) rMr3rrrrrrrrFrErNr/r0rJks zAdvancedBlur.__init__rPrrQcKstj||dSrqrrrWr/r/r0rXszAdvancedBlur.applyrrZc Cst|jd|jddd}tj|j}tj|j}ttj|j}tt krft|j ddntd|j d}t j|j d||fi}t | dd|dd}tjt||dd}t|ddgd|dgg} tt|t| gt|t|gg} t| t| | j} tj| } tdttt|| |d|} | |9} | tjt| } d | iS) Nrrr"rr)ZaxisgrS)r}rr3rrrrZdeg2radrHALFrr rarangestackZmeshgridarraycossindotTZlinalginvexppowerrrr)rMrZsigma_xZsigma_yZanglebetaZ noise_matrixZaxZgridZd_matrixZu_matrixZ sigma_matrixZ inverse_sigmarSr/r/r0r_s"  .0 *zAdvancedBlur.get_paramsz#tuple[str, str, str, str, str, str]cCsdS)N)r3rrrrrr/r^r/r/r0rasz*AdvancedBlur.get_transform_init_args_names) rArrNNrrrNr!rbr/r/rNr0rs R&!cspeZdZdZGdddeZddd d d d fd d Zddd dddddZddddZddddZ Z S)racApply defocus blur to the input image. This transform simulates the effect of an out-of-focus camera by applying a defocus blur to the image. It uses a combination of disc kernels and Gaussian blur to create a realistic defocus effect. Args: radius (tuple[int, int] | int): Range for the radius of the defocus blur. If a single int is provided, the range will be [1, radius]. Larger values create a stronger blur effect. Default: (3, 10) alias_blur (tuple[float, float] | float): Range for the standard deviation of the Gaussian blur applied after the main defocus blur. This helps to reduce aliasing artifacts. If a single float is provided, the range will be (0, alias_blur). Larger values create a smoother, more aliased effect. Default: (0.1, 0.5) p (float): Probability of applying the transform. Should be in the range [0, 1]. Default: 0.5 Targets: image Image types: uint8, float32 Note: - The defocus effect is created using a disc kernel, which simulates the shape of a camera's aperture. - The additional Gaussian blur (alias_blur) helps to soften the edges of the disc kernel, creating a more natural-looking defocus effect. - Larger radius values will create a stronger, more noticeable defocus effect. - The alias_blur parameter can be used to fine-tune the appearance of the defocus, with larger values creating a smoother, potentially more realistic effect. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.Defocus(radius=(4, 8), alias_blur=(0.2, 0.4), always_apply=True) >>> result = transform(image=image) >>> defocused_image = result['image'] References: - https://en.wikipedia.org/wiki/Defocus_aberration - https://www.researchgate.net/publication/261311609_Realistic_Defocus_Blur_for_Multiplane_Computer-Generated_Holography c@seZdZUded<ded<dS)zDefocus.InitSchemarradiusr alias_blurNr;r<r=r>r/r/r/r0r@s r@r5 g?r!Nr!rrrCr#)rrrFrEcs:t||ttttf||_ttttf||_dSrU)rIrJrrrKrr#r)rMrrrFrErNr/r0rJszDefocus.__init__rPrKr)rRrrrTr(cKst|||SrU)rVZdefocus)rMrRrrrTr/r/r0rXsz Defocus.applyrYrZcCstj|jtj|jdSN)rr)r}rrrrr^r/r/r0r_s  zDefocus.get_paramsrcCsdSrr/r^r/r/r0rasz%Defocus.get_transform_init_args_names)rrNr! r;r<r=rcrr@rJrXr_rardr/r/rNr0rs0 csneZdZdZGdddeZdddd d d fd d ZdddddddZddddZddddZ Z S)r aApply zoom blur transform. Args: max_factor ((float, float) or float): range for max factor for blurring. If max_factor is a single float, the range will be (1, limit). Default: (1, 1.31). All max_factor values should be larger than 1. step_factor ((float, float) or float): If single float will be used as step parameter for np.arange. If tuple of float step_factor will be in range `[step_factor[0], step_factor[1])`. Default: (0.01, 0.03). All step_factor values should be positive. p (float): probability of applying the transform. Default: 0.5. Targets: image Image types: unit8, float32 Reference: https://arxiv.org/abs/1903.12261 c@seZdZUded<ded<dS)zZoomBlur.InitSchemar max_factorr step_factorNrr/r/r/r0r@s r@rg(\?g{Gz?gQ?Nr!rrCr#)rrrFrEcs:t||ttttf||_ttttf||_dSrU)rIrJrrr#rr)rMrrrFrErNr/r0rJszZoomBlur.__init__rPr)rR zoom_factorsrTr(cKs t||SrU)rVZ zoom_blur)rMrRrrTr/r/r0rX*szZoomBlur.applyrYrZcCs4tj|j}td|tj|j}dtd||iS)Nrrr)r}rrrrrr)rMrrr/r/r0r_-s zZoomBlur.get_paramsrcCsdS)N)rrr/r^r/r/r0ra2sz&ZoomBlur.get_transform_init_args_names)rrNr!rr/r/rNr0r s )r)6 __future__rr}rtypingrrrrrZnumpyrZpydanticrrr r Ztyping_extensionsr Zalbumentationsr Zalbumentations.augmentationsr rsZ"albumentations.augmentations.utilsrZalbumentations.core.pydanticrrrrZ(albumentations.core.transforms_interfacerrZalbumentations.core.typesrrZalbumentations.core.utilsrrV__all__rr~r1r2rrrrrrrr r/r/r/r0s:         :};oe=M