U h @sddlmZddlZddlZddlmZmZmZmZddl m Z ddl Z ddl Z ddlmZmZmZmZddlmZmZddlmZddlmZdd lmZmZmZmZm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.d dl/mZ0d ddddddddddg Z1Gddde2Z3Gddde#Z4Gddde$Z5Gdd d e5Z6Gddde5Z7Gd dde5Z8Gd!dde5Z9Gd"d#d#e#Z:Gd$d%d%e$Z;Gd&dde;ZGd)dde5Z?Gd*dde?Z@Gd+dde$ZAGd,dde5ZBdS)-) annotationsN)AnySequenceTuplecast)warn)AfterValidatorFieldfield_validatormodel_validator) AnnotatedSelf) functional)union_of_bboxes)BorderModeTypeInterpolationTypeOnePlusIntRangeTypeZeroOneRangeType check_0pluscheck_01)BaseTransformInitSchema DualTransform) NUM_MULTI_CHANNEL_DIMENSIONSPAIR ColorType PercentTypePxType ScalarTypeScaleFloatType ScaleIntTypeTargets RandomCrop CenterCropCropCropNonEmptyMaskIfExistsRandomSizedCropRandomResizedCropRandomCropNearBBoxRandomSizedBBoxSafeCrop CropAndPadRandomCropFromBordersBBoxSafeRandomCropc@s eZdZdS) CropSizeErrorN__name__ __module__ __qualname__r2r2Q/tmp/pip-unpacked-wheel-e8onvpoz/albumentations/augmentations/crops/transforms.pyr-5sr-c@s2eZdZUeddZded<eddZded<dS)CropInitSchemar!)ge int | NoneheightwidthN)r/r0r1r r7__annotations__r8r2r2r2r3r49s r4cseZdZejejejejfZddddfdd Z dd d dd d d Z dd d ddddZ dd d ddddZ e d dd dddZZS)BaseCrop?Nfloat bool | Nonep always_applycstj||ddSNr>)super__init__)selfr?r@ __class__r2r3rCAszBaseCrop.__init__ np.ndarraytuple[int, int, int, int]rimg crop_coordsparamsreturncKs4|d}|d}|d}|d}tj|||||dS)Nrr!x_miny_minx_maxy_max)fcropscrop)rDrJrKrLrQrRrSrTr2r2r3applyDs zBaseCrop.applybboxesrKrLrMcKst|||dSNshaperUZcrop_bboxes_by_coordsrDrYrKrLr2r2r3apply_to_bboxesKszBaseCrop.apply_to_bboxes keypointsrKrLrMcKs t||SN)rUcrop_keypoints_by_coords)rDr`rKrLr2r2r3apply_to_keypointsSszBaseCrop.apply_to_keypointstuple[int, int])bbox image_shaperMcCs`|dd\}}|\}}}}t|d|}t|d|}t|||}t|||}||||fS)NrNr)npclip)rerfr7r8rQrRrSrTr2r2r3 _clip_bbox[s zBaseCrop._clip_bbox)r;N)r/r0r1r IMAGEMASKBBOXES KEYPOINTS_targetsrCrWr^rc staticmethodri __classcell__r2r2rEr3r:>sr:cs^eZdZdZGdddeZdddddd fd d Zd d d dddZddddZZ S)r"aCrop a random part of the input. Args: height: height of the crop. width: width of the crop. p: probability of applying the transform. Default: 1. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 c@s eZdZdS)zRandomCrop.InitSchemaNr.r2r2r2r3 InitSchemawsrqr;Nintr<r=r7r8r?r@cs tj||d||_||_dSrArBrCr7r8rDr7r8r?r@rEr2r3rCzszRandomCrop.__init__dict[str, Any]$dict[str, tuple[int, int, int, int]]rLdatarMc Cs|ddd}|\}}|j|ks,|j|krPtd|j|jfd|ddt}t}t||j|jf||}d|iS)Nr[rNzDCrop size (height, width) exceeds image dimensions (height, width): z vs rK)r7r8r-randomrUget_crop_coords) rDrLryrf image_height image_widthh_startw_startrKr2r2r3get_params_dependent_on_datasz'RandomCrop.get_params_dependent_on_datatuple[str, ...]rMcCsdSN)r7r8r2rDr2r2r3get_transform_init_args_namessz(RandomCrop.get_transform_init_args_names)r;N) r/r0r1__doc__r4rqrCrrrpr2r2rEr3r"gs cs^eZdZdZGdddeZdddddd fd d Zd d ddZddddddZZ S)r#aCrop the central part of the input. This transform crops the center of the input image, mask, bounding boxes, and keypoints to the specified dimensions. It's useful when you want to focus on the central region of the input, discarding peripheral information. Args: height (int): The height of the crop. Must be greater than 0. width (int): The width of the crop. Must be greater than 0. p (float): Probability of applying the transform. Default: 1.0. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - If the specified crop size is larger than the input image in either dimension, it will raise a CropSizeError. - For bounding boxes and keypoints, only those that fall within the cropped area are kept, and their coordinates are adjusted to the new image size. 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.CenterCrop(height=80, width=80, p=1.0), ... ]) >>> transformed = transform(image=image) >>> transformed_image = transformed['image'] # 80x80 center crop of the original image c@s eZdZdS)zCenterCrop.InitSchemaNr.r2r2r2r3rqsrqr;Nrrr<r=rscs tj||d||_||_dSrArtrurEr2r3rCszCenterCrop.__init__rrcCsdSrr2rr2r2r3rsz(CenterCrop.get_transform_init_args_namesrvrwrxcCs,|ddd}t||j|jf}d|iSNr[rNrK)rUget_center_crop_coordsr7r8)rDrLryrfrKr2r2r3rsz'CenterCrop.get_params_dependent_on_data)r;N) r/r0r1rr4rqrCrrrpr2r2rEr3r#s !csbeZdZdZGdddeZdddddd d d fd d ZddddZddddddZZ S)r$a Crop a specific region from the input image. This transform crops a rectangular region from the input image, mask, bounding boxes, and keypoints based on specified coordinates. It's useful when you want to extract a specific area of interest from your inputs. Args: x_min (int): Minimum x-coordinate of the crop region (left edge). Must be >= 0. Default: 0. y_min (int): Minimum y-coordinate of the crop region (top edge). Must be >= 0. Default: 0. x_max (int): Maximum x-coordinate of the crop region (right edge). Must be > x_min. Default: 1024. y_max (int): Maximum y-coordinate of the crop region (bottom edge). Must be > y_min. Default: 1024. always_apply (bool, optional): If set to True, the transform will be always applied. Default: None. p (float): Probability of applying the transform. Default: 1.0. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - The crop coordinates are applied as follows: x_min <= x < x_max and y_min <= y < y_max. - If the specified crop region extends beyond the image boundaries, it will be clipped to fit within the image. - For bounding boxes and keypoints, only those that fall within the cropped region are kept, and their coordinates are adjusted relative to the new image size. 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.Crop(x_min=10, y_min=20, x_max=80, y_max=90, p=1.0), ... ]) >>> transformed = transform(image=image) >>> transformed_image = transformed['image'] # 70x70 crop of the original image c@sFeZdZUded<ded<ded<ded<eddd d d d Zd S)zCrop.InitSchemazAnnotated[int, Field(ge=0)]rQrRzAnnotated[int, Field(gt=0)]rSrTaftermoder rcCs4|j|jksd}t||j|jks0d}t||S)Nz x_max must be greater than x_minz y_max must be greater than y_min)rQrS ValueErrorrRrTrDmsgr2r2r3validate_coordinatess  z$Crop.InitSchema.validate_coordinatesN)r/r0r1r9r rr2r2r2r3rqs rqrNr;rrr=r<)rQrRrSrTr@r?cs,tj||d||_||_||_||_dSrA)rBrCrQrRrSrT)rDrQrRrSrTr@r?rEr2r3rCs z Crop.__init__rrcCsdS)NrPr2rr2r2r3rsz"Crop.get_transform_init_args_namesrvrwrxcCsd|j|j|j|jfiS)NrKrP)rDrLryr2r2r3rsz!Crop.get_params_dependent_on_data)rrrrNr;) r/r0r1rrrqrCrrrpr2r2rEr3r$s%csveZdZdZGdddeZddddddd d fd d Zd d dddZddddfdd ZddddZ Z S)r%aCrop area with mask if mask is non-empty, else make random crop. This transform attempts to crop a region containing a mask (non-zero pixels). If the mask is empty or not provided, it falls back to a random crop. This is particularly useful for segmentation tasks where you want to focus on regions of interest defined by the mask. Args: height (int): Vertical size of crop in pixels. Must be > 0. width (int): Horizontal size of crop in pixels. Must be > 0. ignore_values (list of int, optional): Values to ignore in mask, `0` values are always ignored. For example, if background value is 5, set `ignore_values=[5]` to ignore it. Default: None. ignore_channels (list of int, optional): Channels to ignore in mask. For example, if background is the first channel, set `ignore_channels=[0]` to ignore it. Default: None. p (float): Probability of applying the transform. Default: 1.0. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - If a mask is provided, the transform will try to crop an area containing non-zero (or non-ignored) pixels. - If no suitable area is found in the mask or no mask is provided, it will perform a random crop. - The crop size (height, width) must not exceed the original image dimensions. - Bounding boxes and keypoints are also cropped along with the image and mask. Raises: ValueError: If the specified crop size is larger than the input image dimensions. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> mask = np.zeros((100, 100), dtype=np.uint8) >>> mask[25:75, 25:75] = 1 # Create a non-empty region in the mask >>> transform = A.Compose([ ... A.CropNonEmptyMaskIfExists(height=50, width=50, p=1.0), ... ]) >>> transformed = transform(image=image, mask=mask) >>> transformed_image = transformed['image'] >>> transformed_mask = transformed['mask'] # The resulting crop will likely include part of the non-zero region in the mask c@seZdZUded<ded<dS)z#CropNonEmptyMaskIfExists.InitSchemalist[int] | None ignore_valuesignore_channelsNr/r0r1r9r2r2r2r3rqMs rqNr;rrrr=r<)r7r8rrr@r?cs,tj||d||_||_||_||_dSrA)rBrCr7r8rr)rDr7r8rrr@r?rEr2r3rCQs z!CropNonEmptyMaskIfExists.__init__rG)maskrMc s|jdd\}}jdk r>tj}tt||d|}|jtkrjdk rtfddt |jdD}tj ||dd}j |ksj |krt dj dj d |d|d |S) NrNrcsg|]}|jkr|qSr2)r).0chrr2r3 is z=CropNonEmptyMaskIfExists._preprocess_mask..Zaxisz Crop size (,z) is larger than image ())r[rrgarraywhereisinndimrrrangeZtaker7r8r)rDr mask_height mask_widthZignore_values_npZtarget_channelsr2rr3_preprocess_maskas  " z)CropNonEmptyMaskIfExists._preprocess_maskrvr)rLkwargsrMc sztj|f|d|kr(||d}n^d|krzt|drz|d}|t|d}|ddD]}|||O}qdn d}t||jdd\}}|r*|j t kr|j ddn|}t |} t | \} } | t d|jd} | t d|jd} t| d||j} t| d||j} n$t d||j} t d||j} | |j}| |j}| | ||f}||d <|S) Nrmasksrr!z.Can not find mask for CropNonEmptyMaskIfExistsrNrrrK)rB update_paramsrlenrgcopy RuntimeErrorr[anyrrsumZargwhererzchoicerandintr8r7rh)rDrLrrrmrrrZ non_zero_yxyxrQrRrSrTrKrEr2r3rss4     z&CropNonEmptyMaskIfExists.update_paramsrrcCsdS)N)r7r8rrr2rr2r2r3rsz6CropNonEmptyMaskIfExists.get_transform_init_args_names)NNNr;) r/r0r1rr4rqrCrrrrpr2r2rEr3r%s-#c@s2eZdZUded<ededddddZdS)BaseRandomSizedCropInitSchemardsize)valuerMcCstdd|Drtd|S)Ncss|]}|dkVqdS)rNr2)rrr2r2r3 sz;BaseRandomSizedCropInitSchema.check_size..z1All elements of 'size' must be positive integers.)rr)clsrr2r2r3 check_sizesz(BaseRandomSizedCropInitSchema.check_sizeN)r/r0r1r9r classmethodrr2r2r2r3rs rcseZdZGdddeZejddfddddd fd d Zd d ddd dddZd d dd dddZ d d dd dddZ ddddZ Z S)_BaseRandomSizedCropc@seZdZUejZded<dS)z_BaseRandomSizedCrop.InitSchemar interpolationN)r/r0r1cv2 INTER_LINEARrr9r2r2r2r3rqs rqNr;rdrrr=r<)rrr@r?cst||||_||_dSra)rBrCrr)rDrrr@r?rEr2r3rCsz_BaseRandomSizedCrop.__init__rGrHr)rJrKrrLrMcKs tj|f|}t||j|Sra)rUrV fgeometricresizer)rDrJrKrrLrVr2r2r3rWsz_BaseRandomSizedCrop.applyrXcKst|||dSrZr\r]r2r2r3r^sz$_BaseRandomSizedCrop.apply_to_bboxesr_c KsVt||}|d|d}|d|d}|jd|}|jd|}t|||S)NrOr!rNr)rUrbrrkeypoints_scale) rDr`rKrLZcropped_keypoints crop_height crop_widthscale_xscale_yr2r2r3rcs  z'_BaseRandomSizedCrop.apply_to_keypointsrrcCsdS)N)rrr2rr2r2r3rsz2_BaseRandomSizedCrop.get_transform_init_args_names) r/r0r1rrqrrrCrWr^rcrrpr2r2rEr3rs  rc seZdZdZejejejejfZ Gddde Z dde j dddddd d d d d d d fddZddddddZddfdd ZZS)r&a Crop a random part of the input and rescale it to a specific size. This transform first crops a random portion of the input and then resizes it to a specified size. The size of the random crop is controlled by the 'min_max_height' parameter. Args: min_max_height (tuple[int, int]): Minimum and maximum height of the crop in pixels. size (tuple[int, int]): Target size for the output image, i.e. (height, width) after crop and resize. w2h_ratio (float): Aspect ratio (width/height) of crop. Default: 1.0 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. p (float): Probability of applying the transform. Default: 1.0 Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - The crop size is randomly selected for each execution within the range specified by 'min_max_height'. - The aspect ratio of the crop is determined by the 'w2h_ratio' parameter. - After cropping, the result is resized to the specified 'size'. - Bounding boxes that end up fully outside the cropped area will be removed. - Keypoints that end up outside the cropped area will be removed. - This transform differs from RandomResizedCrop in that it allows more control over the crop size through the 'min_max_height' parameter, rather than using a scale parameter. Mathematical Details: 1. A random crop height h is sampled from the range [min_max_height[0], min_max_height[1]]. 2. The crop width w is calculated as: w = h * w2h_ratio 3. A random location for the crop is selected within the input image. 4. The image is cropped to the size (h, w). 5. The crop is then resized to the specified 'size'. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.RandomSizedCrop( ... min_max_height=(50, 80), ... size=(64, 64), ... w2h_ratio=1.0, ... interpolation=cv2.INTER_LINEAR, ... p=1.0 ... ) >>> result = transform(image=image) >>> transformed_image = result['image'] # transformed_image will be a 64x64 image, resulting from a crop with height # between 50 and 80 pixels, and the same aspect ratio as specified by w2h_ratio, # taken from a random location in the original image and then resized. c@sneZdZUded<ded<ded<eddd Zd ed <edd d Zd ed <ded<eddddddZdS)zRandomSizedCrop.InitSchemarrrmin_max_heightzAnnotated[float, Field(gt=0)] w2h_ratioNzInitializing with 'size' as an integer and a separate 'width' is deprecated. Please use a tuple (height, width) for the 'size' argument. deprecatedr6r8zqInitializing with 'height' and 'width' is deprecated. Please use a tuple (height, width) for the 'size' argument.r7ScaleIntType | Nonerrrr rcCspt|jtr4t|jtr(|j|jf|_n d}t||jdkrl|jdksR|jdkr^d}t||j|jf|_|SNz:If size is an integer, width as integer must be specified.zGIf 'size' is not provided, both 'height' and 'width' must be specified. isinstancerrrr8 TypeErrorr7rrDrmessager2r2r3process-s   z"RandomSizedCrop.InitSchema.process r/r0r1r9r r8r7r rr2r2r2r3rqs rqNr;)rrr@r?rdrr6r<rrr=)rrr8r7rrr@r?c s2tjttttf||||d||_||_dSN)rrr?r@)rBrCrrrrrr) rDrrr8r7rrr@r?rEr2r3rC=s "zRandomSizedCrop.__init__rvrwrxc CsZ|ddd}tj|j}t||j}||f}t}t}t||||} d| iSr)rzrrrrrrUr{) rDrLryrfrr crop_shaper~rrKr2r2r3rNs z,RandomSizedCrop.get_params_dependent_on_datarrcstdS)Nrr)rrrBrrrEr2r3rasz-RandomSizedCrop.get_transform_init_args_names)NNNr/r0r1rr rjrkrlrmrnrrqrrrCrrrpr2r2rEr3r&s6($c seZdZdZejejejejfZ Gddde Z ddde j dddd d d d d d d ddfddZddddddZddddZZS)r'a Crop a random part of the input and rescale it to a specified size. This transform first crops a random portion of the input image (or mask, bounding boxes, keypoints) and then resizes the crop to a specified size. It's particularly useful for training neural networks on images of varying sizes and aspect ratios. Args: size (tuple[int, int]): Target size for the output image, i.e. (height, width) after crop and resize. scale (tuple[float, float]): Range of the random size of the crop relative to the input size. For example, (0.08, 1.0) means the crop size will be between 8% and 100% of the input size. Default: (0.08, 1.0) ratio (tuple[float, float]): Range of aspect ratios of the random crop. For example, (0.75, 1.3333) allows crop aspect ratios from 3:4 to 4:3. Default: (0.75, 1.3333333333333333) 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 p (float): Probability of applying the transform. Default: 1.0 Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - This transform attempts to crop a random area with an aspect ratio and relative size specified by 'ratio' and 'scale' parameters. If it fails to find a suitable crop after 10 attempts, it will return a crop from the center of the image. - The crop's aspect ratio is defined as width / height. - Bounding boxes that end up fully outside the cropped area will be removed. - Keypoints that end up outside the cropped area will be removed. - After cropping, the result is resized to the specified size. Mathematical Details: 1. A target area A is sampled from the range [scale[0] * input_area, scale[1] * input_area]. 2. A target aspect ratio r is sampled from the range [ratio[0], ratio[1]]. 3. The crop width and height are computed as: w = sqrt(A * r) h = sqrt(A / r) 4. If w and h are within the input image dimensions, the crop is accepted. Otherwise, steps 1-3 are repeated (up to 10 times). 5. If no valid crop is found after 10 attempts, a centered crop is taken. 6. The crop is then resized to the specified size. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8) >>> transform = A.RandomResizedCrop(size=80, scale=(0.5, 1.0), ratio=(0.75, 1.33), p=1.0) >>> result = transform(image=image) >>> transformed_image = result['image'] # transformed_image will be a 80x80 crop from a random location in the original image, # with the crop's size between 50% and 100% of the original image size, # and the crop's aspect ratio between 3:4 and 4:3. c@sneZdZUded<ded<edddZded <edddZded <d ed <d ed<eddddddZdS)zRandomResizedCrop.InitSchemaz8Annotated[tuple[float, float], AfterValidator(check_01)]scalez;Annotated[tuple[float, float], AfterValidator(check_0plus)]ratioNzGInitializing with 'height' and 'width' is deprecated. Use size instead.rr6r8r7rrrrrrr rcCspt|jtr4t|jtr(|j|jf|_n d}t||jdkrl|jdksR|jdkr^d}t||j|jf|_|Srrrr2r2r3rs   z$RandomResizedCrop.InitSchema.processrr2r2r2r3rqs rqN)g{Gz?r;)g?gUUUUUU?r;)rrrr@r?rr6ztuple[float, float]rrr=r<)rr8r7rrrr@r?c s2tjttttf||||d||_||_dSr)rBrCrrrrrr) rDrr8r7rrrr@r?rEr2r3rCs "zRandomResizedCrop.__init__rvrwrxcCs|ddd}|\}}||}tdD] }tj|j|}t|jdt|jdf} ttj| } tt t || } tt t || } d| kr|kr(nq(d| kr|kr(nq(t d|| } t d|| }| d|| d}|d|| d}| | f}t ||||}d|iSq(||}|t|jkrl|} tt |t|j} n4|t|jkr|} tt | t|j} n|} |} || d} || d}| d|| d}|d|| d}| | f}t ||||}d|iS) Nr[rN rr!r;g|=rK)rrzuniformrmathlogrexprrroundsqrtrrUr{minmax)rDrLryrfr|r}area_Z target_areaZ log_ratioZ aspect_ratior8r7ijr~rrrKZin_ratior2r2r3rsB 0  z.RandomResizedCrop.get_params_dependent_on_datarrcCsdS)N)rrrrr2rr2r2r3rsz/RandomResizedCrop.get_transform_init_args_names)NNNrr2r2rEr3r'es9"$7cseZdZdZejejejejfZ Gddde Z ddd d d d d fdd Z ddddddZ eddddZddddZZS)r(aCrop bbox from image with random shift by x,y coordinates Args: max_part_shift (float, (float, float)): Max shift in `height` and `width` dimensions relative to `cropping_bbox` dimension. If max_part_shift is a single float, the range will be (0, max_part_shift). Default (0, 0.3). cropping_bbox_key (str): Additional target key for cropping box. Default `cropping_bbox`. cropping_box_key (str): [Deprecated] Use `cropping_bbox_key` instead. p (float): probability of applying the transform. Default: 1. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Examples: >>> aug = Compose([RandomCropNearBBox(max_part_shift=(0.1, 0.5), cropping_bbox_key='test_bbox')], >>> bbox_params=BboxParams("pascal_voc")) >>> result = aug(image=image, bboxes=bboxes, test_bbox=[0, 5, 10, 20]) c@seZdZUded<ded<dS)zRandomCropNearBBox.InitSchemarmax_part_shiftstrcropping_bbox_keyNrr2r2r2r3rq's rqrg333333? cropping_bboxNr;rrz str | Noner=r<)rrcropping_box_keyr@r?csHtj||d|dk r*tdtdd|}ttttf||_||_dS)Nr>zwThe parameter 'cropping_box_key' is deprecated and will be removed in future versions. Use 'cropping_bbox_key' instead.rN) stacklevel) rBrCrDeprecationWarningrrr<rr)rDrrrr@r?rEr2r3rC+szRandomCropNearBBox.__init__rvzdict[str, tuple[float, ...]]rxc Cs$||j}|ddd}|||}t|d|d|jd}t|d|d|jd}|dt| |}|dt| |}|dt| |} |dt| |} ||| || f|} | d| dks| d| dkr|d|d|d|df} t|| } d| iS)Nr[rNrOr!rrK)rrirrrzrrUr) rDrLryrerfZ h_max_shiftZ w_max_shiftrQrSrRrTrKrr2r2r3rBs  "  z/RandomCropNearBBox.get_params_dependent_on_data list[str]rcCs|jgSra)rrr2r2r3targets_as_params^sz$RandomCropNearBBox.targets_as_paramsrcCsdS)N)rrr2rr2r2r3rbsz0RandomCropNearBBox.get_transform_init_args_names)rrNNr;)r/r0r1rr rjrkrlrmrnrrqrCrpropertyrrrpr2r2rEr3r( scseZdZdZejejejejfZ Gddde Z ddddd fd d Z d d dddZ ddddddZeddddZddddZZS)r,aCrop a random part of the input without loss of bounding boxes. This transform performs a random crop of the input image while ensuring that all bounding boxes remain within the cropped area. It's particularly useful for object detection tasks where preserving all objects in the image is crucial. Args: erosion_rate (float): A value between 0.0 and 1.0 that determines the minimum allowable size of the crop as a fraction of the original image size. For example, an erosion_rate of 0.2 means the crop will be at least 80% of the original image height. Default: 0.0 (no minimum size). p (float): Probability of applying the transform. Default: 1.0. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: This transform ensures that all bounding boxes in the original image are fully contained within the cropped area. If it's not possible to find such a crop (e.g., when bounding boxes are too spread out), it will default to cropping the entire image. Example: >>> import numpy as np >>> import albumentations as A >>> image = np.ones((300, 300, 3), dtype=np.uint8) >>> bboxes = [(10, 10, 50, 50), (100, 100, 150, 150)] >>> transform = A.Compose([ ... A.BBoxSafeRandomCrop(erosion_rate=0.2, p=1.0), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['labels'])) >>> transformed = transform(image=image, bboxes=bboxes, labels=['cat', 'dog']) >>> transformed_image = transformed['image'] >>> transformed_bboxes = transformed['bboxes'] c@s"eZdZUedddZded<dS)zBBoxSafeRandomCrop.InitSchemar;r5ler< erosion_rateNr/r0r1r rr9r2r2r2r3rqs rqrr;Nr<r=rr?r@cstj||d||_dSrA)rBrCr)rDrr?r@rEr2r3rCszBBoxSafeRandomCrop.__init__rdrH)rfrMc Csj|\}}t|d|j}||kr&|n t||}t|||}t}t}||f} t|| ||S)Nr;)rrrrzrrUr{) rDrfr|r}Z erosive_hrrr~rrr2r2r3_get_coords_no_bboxsz&BBoxSafeRandomCrop._get_coords_no_bboxrvrwrxcCs"|ddd}t|ddkr2||}d|iSt|d|jd}|dkr^||}d|iS|\}}}} t|dd}t|dd}t||d}t| |d} |\} } t|t| } t|t| } |d|t}| d| t}t|| }t|| }d| | ||fiS)Nr[rNrYrrK)rYrr!)rrrrrgrhrrrz)rDrLryrfrKZ bbox_unionrQrRrSrTr|r}Z crop_x_minZ crop_y_minZ bbox_xmaxZ bbox_ymaxZ crop_x_maxZ crop_y_maxr2r2r3rs*     z/BBoxSafeRandomCrop.get_params_dependent_on_datarrcCsdgS)NrYr2rr2r2r3rsz$BBoxSafeRandomCrop.targets_as_paramsrcCsdS)N)rr2rr2r2r3rsz0BBoxSafeRandomCrop.get_transform_init_args_names)rr;N)r/r0r1rr rjrkrlrmrnrrqrCrrrrrrpr2r2rEr3r,fs$$cseZdZdZejejejejfZ Gddde Z de j ddfddddd dd fd d Zd ddd dddZd ddd dddZddfdd ZZS)r)a Crop a random part of the input and rescale it to a specific size without loss of bounding boxes. This transform first attempts to crop a random portion of the input image while ensuring that all bounding boxes remain within the cropped area. It then resizes the crop to the specified size. This is particularly useful for object detection tasks where preserving all objects in the image is crucial while also standardizing the image size. Args: height (int): Height of the output image after resizing. width (int): Width of the output image after resizing. erosion_rate (float): A value between 0.0 and 1.0 that determines the minimum allowable size of the crop as a fraction of the original image size. For example, an erosion_rate of 0.2 means the crop will be at least 80% of the original image height and width. Default: 0.0 (no minimum size). 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.AREA, cv2.INTER_LANCZOS4. Default: cv2.INTER_LINEAR. p (float): Probability of applying the transform. Default: 1.0. Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - This transform ensures that all bounding boxes in the original image are fully contained within the cropped area. If it's not possible to find such a crop (e.g., when bounding boxes are too spread out), it will default to cropping the entire image. - After cropping, the result is resized to the specified (height, width) size. - Bounding box coordinates are adjusted to match the new image size. - Keypoints are moved along with the crop and scaled to the new image size. - If there are no bounding boxes in the image, it will fall back to a random crop. Mathematical Details: 1. A crop region is selected that includes all bounding boxes. 2. The crop size is determined by the erosion_rate: min_crop_size = (1 - erosion_rate) * original_size 3. If the selected crop is smaller than min_crop_size, it's expanded to meet this requirement. 4. The crop is then resized to the specified (height, width) size. 5. Bounding box coordinates are transformed to match the new image size: new_coord = (old_coord - crop_start) * (new_size / crop_size) Example: >>> import numpy as np >>> import albumentations as A >>> image = np.random.randint(0, 256, (300, 300, 3), dtype=np.uint8) >>> bboxes = [(10, 10, 50, 50), (100, 100, 150, 150)] >>> transform = A.Compose([ ... A.RandomSizedBBoxSafeCrop(height=224, width=224, erosion_rate=0.2, p=1.0), ... ], bbox_params=A.BboxParams(format='pascal_voc', label_fields=['labels'])) >>> transformed = transform(image=image, bboxes=bboxes, labels=['cat', 'dog']) >>> transformed_image = transformed['image'] >>> transformed_bboxes = transformed['bboxes'] # transformed_image will be a 224x224 image containing all original bounding boxes, # with their coordinates adjusted to the new image size. c@s*eZdZUedddZded<ded<dS) z"RandomSizedBBoxSafeCrop.InitSchemarr;rr<rrrNrr2r2r2r3rq s rqrNr;rrr<r=)r7r8rrr@r?cs(tj|||d||_||_||_dS)Nr)rBrCr7r8r)rDr7r8rrr@r?rEr2r3rCs z RandomSizedBBoxSafeCrop.__init__rGrHrrIcKs(tj|f|}t||j|jf|jSra)rUrVrrr7r8r)rDrJrKrLrVr2r2r3rW"szRandomSizedBBoxSafeCrop.applyr_cKsPt||}|d|d}|d|d}|j|}|j|}tj|||dS)NrOr!rNr)rr)rUrbr7r8rr)rDr`rKrLrrrrr2r2r3apply_to_keypoint+s    z)RandomSizedBBoxSafeCrop.apply_to_keypointrrcstdS)Nr7r8r)r7r8rrrrEr2r3r:sz5RandomSizedBBoxSafeCrop.get_transform_init_args_names)r/r0r1rr rjrkrlrmrnr4rqrrrCrWrrrpr2r2rEr3r)s8  c sZeZdZdZejejejejfZ Gddde Z dde j dddde jddf dd d d d d d d d dd fdd Zddddd dddddZddddd dddddZddddddddd Zddddddd!d"d#Zed d d dd$d%d&Zed'd d d'd(d)d*Zd+d+d+d,d-d.Zd'd/d0d1Zd2d/d3d4Zed d5d6d7d8Zd9d/d:d;ZZS)>> import albumentations as A >>> transform = A.Compose([ ... A.CropAndPad(px=(-10, 20, 30, -40), pad_mode=cv2.BORDER_REFLECT, 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@sfeZdZUded<ded<ded<ded<ded <d ed <d ed <d ed<eddddddZdS)zCropAndPad.InitSchemaz PxType | NonepxzPercentType | Nonepercentrpad_mode=ScalarType | tuple[ScalarType, ScalarType] | list[ScalarType]pad_cval pad_cval_maskbool keep_sizesample_independentlyrrrrr rcCsD|jdkr |jdkr d}t||jdk r@|jdk r@d}t||S)Nz=Both px and percent parameters cannot be None simultaneously.zOnly px or percent may be set!)rrrrr2r2r3check_px_percentsz&CropAndPad.InitSchema.check_px_percentN)r/r0r1r9r rr2r2r2r3rqs rqNrTr;zint | list[int] | Nonezfloat | list[float] | Nonerrrrr=r<) rrrrrrrrr@r?c sDtj| | d||_||_||_||_||_||_||_||_ dSrA) rBrCrrrrrrrr) rDrrrrrrrrr@r?rEr2r3rCs zCropAndPad.__init__rGz Sequence[int]rr)rJ crop_params pad_params pad_valuerrLrMc Ks(t|||||ddd||j|jSNr[rNrUZ crop_and_padrr)rDrJrrrrrLr2r2r3rWs zCropAndPad.apply)rrrpad_value_maskrrLrMc Ks(t|||||ddd||j|jSrr)rDrrrrrrLr2r2r3 apply_to_masks zCropAndPad.apply_to_maskrHrd)rYrr result_shaperLrMcKst||||ddd|Sr)rUZcrop_and_pad_bboxes)rDrYrrrrLr2r2r3r^szCropAndPad.apply_to_bboxes)r`rrrrLrMcKs"t||||ddd||jSr)rUZcrop_and_pad_keypointsr)rDr`rrrrLr2r2r3rcszCropAndPad.apply_to_keypoints)val1val2max_valrMcCszt|d}|d}|d}|||kr0|d7}||krN||}|}||7}n||krj||}|}||7}||||fS)Nr!rN)abs)r r r ZregainZregain1Zregain2Zdiffr2r2r3Z__prevent_zeros   zCropAndPad.__prevent_zeroz list[int])rr7r8rMc Cs||\}}}}|||}|||}|dkr>t|||\}}|dkrXt|||\}}t|dt|dt|dt|dgS)Nr!r)r*_CropAndPad__prevent_zeror) rr7r8toprightbottomleftZremaining_heightZremaining_widthr2r2r3 _prevent_zeros   zCropAndPad._prevent_zerorvrxcCsr|ddd\}}|jdk r(|}nD|}t|d|t|d|t|d|t|d|g}dd|D}|dd|D||}|\} } } } | | || || g}|d|d} |d|d}||kr| |krg}|\} } } } | | | | g}t|r"| | | 7} || | 7}ng}|p.d|p6d|dkrDdn ||j|dkr\dn ||j| |fd S) Nr[rNrr!rOcSsg|]}t|dqSr)rrrr2r2r3r0sz;CropAndPad.get_params_dependent_on_data..cSsg|]}t|d qSr)rrr2r2r3r2s)rrrrr) r_get_px_params_get_percent_paramsrrrr_get_pad_valuerr)rDrLryr7r8 new_paramsZpercent_paramsrrrrrrZ result_rowsZ result_colsr2r2r3r"s:       z'CropAndPad.get_params_dependent_on_datarcsjdkrd}t|tjtr0jgd}ntjtkrtjr\fddtdD}qtj j}|gd}nLtjdtrj}n4tjdtkrddjD}nddjD}|S)Nz px is not setcsg|]}tjjqSr2)rz randrangerrrrr2r3rTsz-CropAndPad._get_px_params..rcSsg|]}tj|qSr2)rzrrr2r2r3r[scSsg|]}t|qSr2rzrrr2r2r3r]s) rrrrrrrrrrzrrDrrLrr2rr3rKs     zCropAndPad._get_px_paramsz list[float]csjdkrd}t|tjtr0jgd}ntjtkrtjr\fddtdD}qtj j}|gd}nPtjdt tfrj}n4tjdtkrddjD}nddjD}|S)Nzpercent is not setrcsg|]}tjjqSr2)rzrrrrr2r3rjsz2CropAndPad._get_percent_params..rcSsg|]}tj|qSr2)rzrrr2r2r3rqscSsg|]}t|qSr2rrr2r2r3rss) rrrr<rrrrrzrrrrr2rr3ras     zCropAndPad._get_percent_paramsr)rrMcCs\t|ttfr|St|tkrR|\}}t|trFt|trFt||St||St|Sra) rrrr<rrrzrrr)rabr2r2r3rws   zCropAndPad._get_pad_valuercCsdS)N)rrrrrrrrr2rr2r2r3rsz(CropAndPad.get_transform_init_args_names)r/r0r1rr rjrkrlrmrnrrqrZBORDER_CONSTANTrrCrWrr^rcror rrrrrrrpr2r2rEr3r*>s8N&  )csveZdZdZejejejejfZ Gddde Z dddddddd fd d Z d d d dddZ ddddZZS)r+a/ Randomly crops the input from its borders without resizing. This transform randomly crops parts of the input (image, mask, bounding boxes, or keypoints) from each of its borders. The amount of cropping is specified as a fraction of the input's dimensions for each side independently. Args: crop_left (float): The maximum fraction of width to crop from the left side. Must be in the range [0.0, 1.0]. Default: 0.1 crop_right (float): The maximum fraction of width to crop from the right side. Must be in the range [0.0, 1.0]. Default: 0.1 crop_top (float): The maximum fraction of height to crop from the top. Must be in the range [0.0, 1.0]. Default: 0.1 crop_bottom (float): The maximum fraction of height to crop from the bottom. Must be in the range [0.0, 1.0]. Default: 0.1 p (float): Probability of applying the transform. Default: 1.0 Targets: image, mask, bboxes, keypoints Image types: uint8, float32 Note: - The actual amount of cropping for each side is randomly chosen between 0 and the specified maximum for each application of the transform. - The sum of crop_left and crop_right must not exceed 1.0, and the sum of crop_top and crop_bottom must not exceed 1.0. Otherwise, a ValueError will be raised. - This transform does not resize the input after cropping, so the output dimensions will be smaller than the input dimensions. - Bounding boxes that end up fully outside the cropped area will be removed. - Keypoints that end up outside the cropped area 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.RandomCropFromBorders( ... crop_left=0.1, crop_right=0.2, crop_top=0.2, crop_bottom=0.1, p=1.0 ... ) >>> result = transform(image=image) >>> transformed_image = result['image'] # The resulting image will have random crops from each border, with the maximum # possible crops being 10% from the left, 20% from the right, 20% from the top, # and 10% from the bottom. The image size will be reduced accordingly. c@sveZdZUedddZded<edddZded<edddZded<edddZded<e d d d d d dZ dS)z RandomCropFromBorders.InitSchemarr;rr< crop_left crop_rightcrop_top crop_bottomrrr rcCs<|j|jdkrd}t||j|jdkr8d}t||S)Nr;z1The sum of crop_left and crop_right must be <= 1.z1The sum of crop_top and crop_bottom must be <= 1.)r r!rr"r#rr2r2r3validate_crop_valuessz5RandomCropFromBorders.InitSchema.validate_crop_valuesN) r/r0r1r r r9r!r"r#r r$r2r2r2r3rqs$ rq皙?Nr;r<r=)r r!r"r#r@r?cs,tj||d||_||_||_||_dSrA)rBrCr r!r"r#)rDr r!r"r#r@r?rEr2r3rCs zRandomCropFromBorders.__init__rvrwrxc Cs|ddd\}}tdt|j|}tt|dtd|j||}tdt|j|}tt|dtd|j||}||||f} d| iS)Nr[rNrr!rK)rzrrrr rr!r"r#) rDrLryr7r8rQrSrRrTrKr2r2r3rs$$ z2RandomCropFromBorders.get_params_dependent_on_datarrcCsdS)N)r r!r"r#r2rr2r2r3rsz3RandomCropFromBorders.get_transform_init_args_names)r%r%r%r%Nr;)r/r0r1rr rjrkrlrmrnrrqrCrrrpr2r2rEr3r+s/)C __future__rrrztypingrrrrwarningsrrZnumpyrgZpydanticrr r r Ztyping_extensionsr r Z&albumentations.augmentations.geometricrrZalbumentations.core.bbox_utilsrZalbumentations.core.pydanticrrrrrrZ(albumentations.core.transforms_interfacerrZalbumentations.core.typesrrrrrrrrr rU__all__ Exceptionr-r4r:r"r#r$r%rrr&r'r(r,r)r*r+r2r2r2r3s\     , )08P{ ;(ZllX