hڕ.SrSSKJr SSKJrJr SSKrSSKrSSK J r J r J r J r JrJr SSKJr SSKJr SSKJr /S Qr\S#S$S jj5rS%S jr\S&S j5rS'S jrS(SjrS)SjrS*SjrS+SjrS,SjrS-Sjr S.Sjr!S/Sjr"\"S5S0Sj5r#\"S5S1Sj5r$S2Sjr%S3Sjr&S4Sjr'\"S5S5Sj5r(\"S5S6Sj5r)S7S8Sjjr*S9S jr+S:S!jr,S;S"jr-g)[Un[R"U[R5(aUR SUS-XS9$[R"U[R 5(aUR SX1S9RU5$[SU35e)aGenerate a random fill array based on the given dtype and target shape. This function creates a numpy array filled with random values. The range and type of these values depend on the input dtype. For integer dtypes, it generates random integers. For floating-point dtypes, it generates random floats. Args: dtype (np.dtype): The data type of the array to be generated. shape (tuple[int, ...]): The shape of the array to be generated. random_generator (np.random.Generator): The random generator to use for generating values. If None, the default numpy random generator is used. Returns: np.ndarray: A numpy array of the specified shape and dtype, filled with random values. Raises: ValueError: If the input dtype is neither integer nor floating-point. Examples: >>> import numpy as np >>> random_state = np.random.RandomState(42) >>> result = generate_random_fill(np.dtype('uint8'), (2, 2), random_state) >>> print(result) [[172 251] [ 80 141]] r)sizedtyper!zUnsupported dtype: ) rnp issubdtypeintegerintegersfloatinguniformastype ValueError)r"shaperandom_generator max_values rrrCs@$E*I }}UBJJ''((IM(SS }}UBKK((''9'AHHOO *5'2 33rc[U5n[R"URSS[RS9nUHupVpxSXFU2XW24'M US:Xa[ R O[ Rn US:XaUR[:XaUR5n[ R"U[ R5n [ R"XSU 5n U[:Xa([ R"U [ R5S$[ R"U [ R5$[ R"XSU 5$) aoApply OpenCV inpainting to fill the holes in the image. Args: img (np.ndarray): Input image (grayscale or BGR) holes (np.ndarray): Array of [x1, y1, x2, y2] coordinates method (Literal["inpaint_telea", "inpaint_ns"]): Inpainting method to use Returns: np.ndarray: Inpainted image Raises: NotImplementedError: If image has more than 3 channels Nr" inpaint_telear ).N)rr$zerosr,uint8cv2 INPAINT_TELEA INPAINT_NSndimrsqueezecvtColorCOLOR_GRAY2BGRinpaintCOLOR_BGR2GRAY) rholesmethod num_channelsmaskx_miny_minx_maxy_maxinpaint_methodimg_3chresults rapply_inpaintingrKks  $C(L 88CIIbqM 2D&+"e),5[%+ %&',+1O*CS&&Nq 883 3++-C,,sC$6$67WA~>;; LL!3!3 4Y ? fc&8&89 ;;s!^ 44rc.UHup4pVX XF2X524'M U$)zFill holes with a constant value. Args: img (np.ndarray): Input image holes (np.ndarray): Array of [x1, y1, x2, y2] coordinates fill (np.ndarray): Value to fill the holes with )rr@rrDrErFrGs rfill_holes_with_valuerNs)',"e(,EK $%', Jrc4UHup4pVX SS2XF2X524'M U$)zFill holes in a volume with a constant value. Args: volume (np.ndarray): Input volume holes (np.ndarray): Array of [x1, y1, x2, y2] coordinates fill (np.ndarray): Value to fill the holes with NrM)volumer@rrDrErFrGs rfill_volume_holes_with_valuerQs+',"e.2q%+u{*+', Mrc:UHup4pVX SS2SS2XF2X524'M U$)zFill holes in a batch of volumes with a constant value. Args: volumes (np.ndarray): Input batch of volumes holes (np.ndarray): Array of [x1, y1, x2, y2] coordinates fill (np.ndarray): Value to fill the holes with NrM)volumesr@rrDrErFrGs rfill_volumes_holes_with_valuerTs-',"e261ek5;./', NrcUHuupEpgU(aSOXu- Xd- 4nUR[:wa,U(aSURS4O/UQURSP7n[URX5n XXW2XF24'Mw U$)aFill holes with random values. Args: img (np.ndarray): Input image holes (np.ndarray): Array of [x1, y1, x2, y2] coordinates random_generator (np.random.Generator): Random number generator uniform (bool): If True, use same random value for entire hole )r r r0)r:rr,rr") rr@r-r)rDrErFrGr, random_fills rfill_holes_with_randomrWs',"eemU]%C 88. .)0Q ! %6L6Lsyy|6LE*399eN (3EK $% ', JrcTUHupEpgU(aURSSS4OURSXu- Xd- 4nURS:wa;U(a URSSSURS4O/UQURSP7n[URX5n XSS2XW2XF24'M U$)aPFill holes in a volume with random values. Args: volume (np.ndarray): Input volume of shape (D, H, W, C) or (D, H, W) holes (np.ndarray): Array of [x1, y1, x2, y2] coordinates random_generator (np.random.Generator): Random number generator uniform (bool): If True, use same random value for entire hole in each image. rr r4Nr,r:rr") rPr@r-r)rDrErFrGr,rVs rfill_volume_holes_with_randomrZs',"e+2a!Q'a%-Y^Yf8g ;;! @GV\\!_aFLLO>&,,/ / 8 0@PZ_` ` # #0@PZ^_ _4TF;<<$e %%XXd,,7 +F:FF$ll3J{{a%%' ??fll1o -!'{6<<?2CE  (z BB; s Fc 2UR5n[U[5(aUS;acUVVs/sH#nUHn[XQ[ SU55PM M% nnn[ R "U5nURUR5$US:Xa [XUSS9$US:Xa [XUSS9$[SU35e[U[[45(a*[ R "X RS 9n[XU5$[ R "X RS 9nURS :XaUUR!5nUR"URS :wa([S UR"S URS 35e[XU5$s snnf)acApply cutout augmentation to a batch of volumes of shape (N, D, H, W) or (N, D, H, W, C) Args: volumes (np.ndarray): The image to augment holes (np.ndarray): Array of [x1, y1, x2, y2] coordinates fill (tuple[float, ...] | float | Literal["random", "random_uniform", "inpaint_telea", "inpaint_ns"]): Value to fill holes with. Can be: - number (int/float): Will be broadcast to all channels - sequence (tuple/list/ndarray): Must match number of channels - "random": Different random values for each pixel - "random_uniform": Same random value for entire hole, different values across images - "inpaint_telea"/"inpaint_ns": OpenCV inpainting methods random_generator (np.random.Generator): Random number generator for random fills Raises: ValueError: If fill length doesn't match number of channels r_rarbFrcrdTrer1r\rfrg)rrhrirKrr$rlrpr,r]r+rjrkr"rTr:rmr!) rSr@rr-rPrrqrJrns rcutout_on_volumesrus0llnG$ 2 2& %F!C!T2Z\`-ab!c%   XX./F>>'--0 0 8 1'BR\ab b # #1'BR\`a a4TF;<<$e %%XXd--8 ,WZHH$mm4J||q%%' ??gmmA. .!'{7==3C2DF  ) DD? s*F keypointscUSS2S4SS2[R4nUSS2S4SS2[R4nUSS2S4nUSS2S4nUSS2S4nUSS2S4nX$:X&:-X5:-X7:-n[R"USS9)n X $)aFilter out keypoints that are inside any of the holes. Args: keypoints (np.ndarray): Array of keypoints with shape (num_keypoints, 2+). The first two columns are x and y coordinates. holes (np.ndarray): Array of holes with shape (num_holes, 4). Each hole is represented as [x1, y1, x2, y2]. Returns: np.ndarray: Array of keypoints that are not inside any hole. Nrr r0r4axis)r$newaxisany) rvr@kp_xkp_yhole_x1hole_y1hole_x2hole_y2 inside_holevalid_keypointss rrrs QT?1bjj= )D QT?1bjj= )DAqDkGAqDkGAqDkGAqDkG?t~6$/Jdn]Kvvk22O  %%rbboxescUSS2S4R[5nUSS2S4R[5nUSS2S4R[5nUSS2S4R[5n/n[[U55Vs/sHoqX7XW2X'XG24PM nnUV s/sHn SU - PM n n [ [ X55HunupU R 5(dMU R SS9n U R SS9n[R"U 5Sn[R"U5SnU R5nX'US-US'X7US-US'X'US-S-US'X7US-S-US'URU5 M U(a[R"U5$[R"SURS4URS9$s snfs sn f) z:Resize boxes to their largest visible rectangular regions.Nrr r0r4rxr1)r*rjrangelen enumeratezipr{r$nonzerorappendrlr5r,r")boxes hole_maskx1y1x2y2 new_boxesiregionsregion visible_areasvisiblebox y_visible x_visibley_coordsx_coordsnew_boxs rresize_boxes_to_visible_arears q!t  C B q!t  C B q!t  C B q!t  C B#%I@Ec%j@QR@Q1 56@QGR.56gFQZgM6&s='@A>G{{}} KKQK' KKQK' ::i(+::i(+((*UXa[( UXa[( UXb\)A- UXb\)A- !%B,#,288I a1ekk!n:MUZU`U`1aa3S6s G)+G.c[U5S:Xd[U5S:XaU$[R"U[RS9nUH$nUR [ 5upxpSXXU 2Xy24'M& UR [ 5n U SS2S4U SS2S4- U SS2S4U SS2S4- -n [R "U SS2SS24V VVVs/sH$upnn[R"X^U2X245PM& snnnn 5nU U- nUU - nUU:UU:-US:-nUUn[U5S:Xa%[R"SURS45$[UU5$s snnnn f)aFilter bounding boxes by holes. This function filters bounding boxes by holes. Args: bboxes (np.ndarray): Array of bounding boxes. holes (np.ndarray): Array of holes. image_shape (tuple[int, int]): Shape of the image. min_area (float): Minimum area of a bounding box. min_visibility (float): Minimum visibility of a bounding box. Returns: np.ndarray: Filtered bounding boxes. rr1r Nr0r4r\) rr$r5r6r*rjrlsumemptyr,r)rr@ image_shapemin_areamin_visibilityrholerDrErFrG bboxes_int box_areasxyrrintersection_areasremaining_areasvisibility_ratiosrC valid_boxess rrr s}, 6{a3u:? BHH5I%)[[%5"e./ +u{*+ s#JAqD!Jq!t$44AqD9IJWXZ[W[L\9\]IU_`acedece`eUf"gUf\Q2r266)bD!$J*?#@Uf"gh"44O')3 x ',=,O PTcfgTg hD,K ;1xxFLLO,-- ( Y ??#hs +EcUSSupEUb2US[USS5:a [S5eUR"U6nXf4$U(aUupxXW-n XH-n X4$[SUS-5n [SUS-5n X4$)aPCalculate the dimensions of grid units for GridDropout. This function determines the size of grid units based on the input parameters. It supports three modes of operation: 1. Using a range of unit sizes 2. Using a specified number of holes in x and y directions 3. Falling back to a default calculation Args: image_shape (tuple[int, int]): The shape of the image as (height, width). unit_size_range (tuple[int, int] | None, optional): A range of possible unit sizes. If provided, a random size within this range will be chosen for both height and width. holes_number_xy (tuple[int, int] | None, optional): The number of holes in the x and y directions. If provided, the grid dimensions will be calculated to fit this number of holes. random_generator (np.random.Generator): The random generator to use for generating random values. Returns: tuple[int, int]: The calculated grid unit dimensions as (unit_height, unit_width). Raises: ValueError: If the upper limit of unit_size_range is greater than the shortest image edge. Notes: - If both unit_size_range and holes_number_xy are None, the function falls back to a default calculation, where the grid unit size is set to max(2, image_dimension // 10) for both height and width. - The function prioritizes unit_size_range over holes_number_xy if both are provided. - When using holes_number_xy, the actual number of holes may be slightly different due to integer division. Examples: >>> image_shape = (100, 200) >>> calculate_grid_dimensions(image_shape, unit_size_range=(10, 20)) (15, 15) # Random value between 10 and 20 >>> calculate_grid_dimensions(image_shape, holes_number_xy=(5, 10)) (20, 20) # 100 // 5 and 200 // 10 >>> calculate_grid_dimensions(image_shape) (10, 20) # Default calculation: max(2, dimension // 10) Nr0r z8Grid size limits must be within the shortest image edge. )minr+r'max) runit_size_rangeholes_number_xyr-heightwidth unit_sizeholes_number_xholes_number_y unit_width unit_heights rrr:s\ OMF" 1 KO 4 4WX X$--? ##)8&, . &&Q $Ja2&K  ""rc8USSupg[XU5nUSS2S4USS2S4- n USS2S4USS2S4- n [R"X-SU S- 5R[5n [R"X-SU S- 5R[5n X- n X- nU(a+UR SU S-5nUR SUS-5nO2[R "XS5n[R "XS5n[R"USS2S4U-SX|- 5n[R"USS2S4U-SXk- 5n[R"UU -U5n[R"UU -U5n[R"UUUU45$)aGenerate a list of holes for GridDropout using a uniform grid. This function creates a grid of holes for use in the GridDropout augmentation technique. It allows for customization of the grid size, hole size ratio, and positioning of holes. Args: image_shape (tuple[int, int]): The shape of the image as (height, width). grid (tuple[int, int]): The grid size as (rows, columns). This determines the number of cells in the grid, where each cell may contain a hole. ratio (float): The ratio of the hole size to the grid cell size. Should be between 0 and 1. A ratio of 1 means the hole will fill the entire grid cell. random_offset (bool): If True, applies random offsets to each hole within its grid cell. If False, uses the global shift specified by shift_xy. shift_xy (tuple[int, int]): The global shift to apply to all holes as (shift_x, shift_y). Only used when random_offset is False. random_generator (np.random.Generator): The random generator for generating random offsets and shuffling. If None, a new Generator will be created. Returns: np.ndarray: An array of hole coordinates, where each hole is represented as [x1, y1, x2, y2]. The shape of the array is (n_holes, 4), where n_holes is determined by the grid size. Notes: - The function first creates a uniform grid based on the image shape and specified grid size. - Hole sizes are calculated based on the provided ratio and grid cell sizes. - If random_offset is True, each hole is randomly positioned within its grid cell. - If random_offset is False, all holes are shifted by the global shift_xy value. - The function ensures that all holes remain within the image boundaries. Examples: >>> image_shape = (100, 100) >>> grid = (5, 5) >>> ratio = 0.5 >>> random_offset = True >>> random_state = np.random.RandomState(42) >>> shift_xy = (0, 0) >>> holes = generate_grid_holes(image_shape, grid, ratio, random_offset, random_state, shift_xy) >>> print(holes.shape) (25, 4) >>> print(holes[0]) # Example output: [x1, y1, x2, y2] of the first hole [ 1 21 11 31] Nr0rr4r ) r r$clipr*rjr' full_likeminimum column_stack)rgridratio random_offsetshift_xyr-rrcells cell_heights cell_widths hole_heights hole_widths max_offset_y max_offset_xoffset_yoffset_xrDrErFrGs rrr|sh OMF {2B CEA;q!t,L1+ad +K77</L14DELLSQL''+-q+/BII#NK .L,L#,,Q q0@A#,,Q q0@A<< qk:<< qk: GGE!Q$K(*Au/B CE GGE!Q$K(*Av/D EE JJu{*E 2E JJu|+V 4E ??E5%7 88rctUupVURS:acURSS:XaURS5nO>URSS::a[R"USS9nO[R"USS9n[R SU2SU24upxUSSS24USS2SSS4:USSS24USS2SSS4:*-USSS24USS2SSS4:-USSS24USS2SSS4:*-n USS2S4USS2S4- USS2S4USS2S4- -n [R "X)-S S9n X- n X:X:-n X $) aFilter and resize bounding boxes based on dropout mask. Args: bboxes (np.ndarray): Array of bounding boxes with shape (num_boxes, 4+) dropout_mask (np.ndarray): Binary mask indicating dropped areas image_shape (tuple[int, int]): Shape of the image (height, width) min_area (float): Minimum area of a bounding box to keep min_visibility (float): Minimum visibility ratio of a bounding box to keep Returns: np.ndarray: Filtered and resized bounding boxes r0rr rr\rxNr4)r r0)r:r,r;r$r{ogridr)r dropout_maskrrrrrrr box_masksrrvisibility_ratio keep_masks rmask_dropout_bboxesrs* MF1   a A %'//2L    #q (66,R8L66,Q7L 88GVGVeVO $DA 47vaD$./ / T1W:1dD 01 1 3 T1W:1dD 01 1 3 T1W:1dD 01 1 31q!t ,1q!t 1LMIFF9}46BM%0*/?/QRI  rc2URS:acURSS:XaURS5nO>URSS::a[R"USS9nO[R"USS9nUSS2SS24R [ 5nUSS2S4S:USS2S4URS:-USS2S4S:-USS2S4URS:-n[R"U5(aX#nXSS2S4USS2S44)X3'X$)zFilter keypoints based on dropout mask. Args: keypoints (np.ndarray): Array of keypoints with shape (num_keypoints, 2+) dropout_mask (np.ndarray): Binary mask indicating dropped areas Returns: np.ndarray: Filtered keypoints r0rr rr\rxN)r:r,r;r$r{r*rj)rvrcoords valid_mask valid_coordss rmask_dropout_keypointsr s? 1   a A %'//2L    #q (66,R8L66,Q7Lq"1"u  $ $S )F 1  !Q$<,,,Q/ / 1 !Q$<1   !Q$<,,,Q/ / 1 vvj) ".AqD/A[R"UR[R55up4US:Xag/n/n[ SU5Hn[R "XG:H5n[U5S:XaM,[R"[U55n UR[U5USS9n Xn URU SS2SSS245 URU /U-5 M U(a,[R"U5[R"U54$S$)aNSample points from connected components in a mask. Args: mask (np.ndarray): Binary mask num_points (int): Number of points to sample random_generator (np.random.Generator): Random number generator Returns: tuple[np.ndarray, np.ndarray] | None: Tuple of (x_coordinates, y_coordinates) or None if no valid components r NrT)r!replacer) r7rr*r$r6rargwherersqrtchoiceextendrl) rC num_pointsr-rrcenters obj_sizesrpointsobj_sizeindicessampled_pointss rsample_points_from_componentsrs 00RXX1FGJQGIq*%V_- v;!  773v;'#))#f+JPT)U~a2g./(j01& 8?BHHW rxx 2 3HDHrc[R"U[R"U55n[R"U5(d2[R"/[RS9R S5$[ XaU5nUc2[R"/[RS9R S5$Uup[U5n URSSupURUSUSU S9U -n URUSUSU S9U -nU S-nUS-n[R"USS2S4U- USS2S4U- USS2S4U-USS2S4U-/5R[R5n[R"USS2S4SU S- 5USS2S4'[R"USS2S4SU S- 5USS2S4'[R"USS2S4SU 5USS2S4'[R"USS2S4SU 5USS2S4'USS2S4USS2S4- S:USS2S4USS2S4- S:-nUU$) z*Generate holes based on segmentation mask.r1)rr\Nr0rr r#r4) r$isinrlr{rrprrr,r)rr*r)rCnum_holes_per_obj mask_indicesrrr-rrJrr num_centersrrrr half_heights half_widthsr@ valid_holess rget_holes_from_maskr sh''$ 67K 66+  xx"((+33F;; *;K[ \F ~xx"((+33F;;Gg,KJJrNMF   a a  !      Q  Q  !    1$L"K OO AqDMK ' AqDML ( AqDMK ' AqDML (    fRXX ''%1+q%!)4E!Q$K''%1+q&1*5E!Q$K''%1+q%0E!Q$K''%1+q&1E!Q$KA;q!t,q0U1a4[5A;5NQR5RSK  r)r)r np.ndarrayrz"int | tuple[int, ...] | np.ndarrayrztuple[float, ...] | floatreturnr)r"znp.dtyper,ztuple[int, ...]r-np.random.Generatorrr)rrr@rrArarr)rrr@rrrrr)rPrr@rrrrr)rSrr@rrrrr) rrr@rr-rr)boolrr) rPrr@rr-rr)rrr) rSrr@rr-rr)rrr) rrr@rr^tuple[float, ...] | float | Literal['random', 'random_uniform', 'inpaint_telea', 'inpaint_ns']r-rrr) rPrr@rrrr-rrr) rSrr@rrrr-rrr)rvrr@rrr)rrrrrr) rrr@rrtuple[int, int]rrkrrkrr) rrrtuple[int, int] | Nonerrr-rrr)rrrrrrkrrrrr-rrr) rrrrrrrrkrrkrr)rvrrrrr)Fr0)rCrrrrrjrz#np.ndarray | tuple[np.ndarray, int]) rrrrjrtuple[float, float]rrr-rrr)rCrrrjr-rrz$tuple[np.ndarray, np.ndarray] | None)rCrrrjrz list[int]rrrrr-rrr).__doc__ __future__rtypingrrr7numpyr$albucorerrrr r r 1albumentations.augmentations.geometric.functionalr "albumentations.augmentations.utilsr $albumentations.core.type_definitionsr__all__rrrKrNrQrTrWrZr]rrrrurrrrrrrrrrr rMrrrsf# QAH '( 8 $ 6%4 %4 %4*%4 %4P #5 #5L     *   2  *   2  *   <59 59 59 i59* 59  59p:C :C :C i:C* :C  :Cz<E <E <E i<E* <E  <E~K &!&>H'b 'b'b'b'bT,@ ,@ ,@!,@ ,@  ,@  ,@^?# ?#+?#,?#* ?#  ?#DR9 R9 R9 R9 R9  R9 * R9R9jH4 44!4 4  4  44nK '!'!'!'!!'!T)