^jڕdZddlmZddlmZmZddlZddlZddl m Z m Z m Z m Z mZmZddlmZddlmZddlmZgd Ze d# d$d Z d%d Zed&d Zd'd Zd(dZd)dZ d*dZ d+dZ d,dZ d-dZ d.dZ! d/dZ"edd0dZ#ed d1dZ$ d2dZ% d3dZ& d4dZ'ed d5dZ(ed d6dZ)d7d8dZ* d9d Z+ d:d!Z, d;d"Z-y)>> 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'((IMU(SS }}UBKK(''95'AHHOO *5'2 33rct|}tj|jddtj}|D]\}}}}d|||||f<|dk(rt j nt j} |dk(r|jtk(r|j}t j|t j} t j| |d| } |tk(r't j| t jdSt j| t jSt j||d| S) aApply 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&+-"ueU),U5[%+ %&-+1O*CS&&Nq 883 3++-C,,sC$6$67WdA~>;; LL!3!3 4Y ? fc&8&89 ;;sD!^ 44rc4|D]\}}}}||||||f<|S)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_valuerNs8',-"ueU(,E%Ku $%- Jrc:|D]\}}}}||dd||||f<|S)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:',3"ueU.2q%+uU{*+3 Mrc@|D]\}}}}||dddd||||f<|S)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<',7"ueU261eEk5;./7 Nrc|D]q\}}}}|rdn ||z ||z f}|jtk7r'|rd|jdfng||jd}t|j||} | |||||f<s|S)a&Fill 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',4"ueUeemUU]%C 88. .)0Q ! %6L6Lsyy|6LE*399e=MN (3E%Ku $% 4 JrcJ|D]\}}}}|r|jdddfn|jd||z ||z f}|jdk7r6|r |jddd|jdfng||jd}t|j||} | |dd||||f<|S)ahFill 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',:"ueU+2a!Q'a%RW-Y^afYf8g ;;! @GV\\!_aFLLO"ueU]]1 w}}Q/A 6--"GMM!$4eemUU]S  <<1 PWq!7==#3Q7==;KL]w_d]wfmfsfstufv]w +7==%AQR 2=1eEk5;./ > Nrc|j}t|trQ|dvrt||t d|S|dk(rt |||dS|dk(rt |||dSt d|t|ttfr.tj||j }t|||Stj||j }|jtk(rT|j}|j |j"d k7r(t d |j d |j"d t|||S) alApply cutout augmentation to the image by cutting out holes and filling them. Args: img (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 - "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  inpaint_nsr3&Literal['inpaint_telea', 'inpaint_ns']randomFr)random_uniformTUnsupported string fill: r1r0;Fill value must have same number of channels as image. Got , expected )r isinstancestrrKrrWr+intfloatr$arrayr"rNr:rravelr!r,)rr@rr- fill_arrays rrr sA0 ((*C$ 2 2#C5]_c0de e 8 )#u6FPUV V # #)#u6FPTU U4TF;<<$e %XXd#))4 $S%<<$cii0J xx//%%' ??ciil *!'{399Q<.B  !eZ 88rc |j}t|tr|dvrT|Dcgc]}t||t d|}}t j |}|j|jS|dk(rt|||dS|dk(rt|||dStd|t|ttfr.t j ||j }t|||St j ||j }|jd k(rT|j!}|j"|jd k7r(td |j"d |jd t|||Scc}w)aApply cutout augmentation to a volume of shape (D, H, W) or (D, H, W, C) by cutting out holes and filling them. Args: volume (np.ndarray): The volume 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\r4rfrg)rrhrirKrr$rlreshaper,rZr+rjrkr"rQr:rmr!)rPr@rr-rprocessed_imagesrJrns rcutout_on_volumerrDs0[[]F$ 2 2nt gj eT2Z\`-ab   XX./F>>&,,/ / 8 0@PZ_` ` # #0@PZ^_ _4TF;<<$e %XXd&,,7 +FE:FF$fll3J{{a%%' ??fll1o -!'{6<<?2CE  (z BB; sFc &|j}t|tr|dvr]|Dcgc] }|D]}t||t d|"}}}t j |}|j|jS|dk(rt|||dS|dk(rt|||dStd|t|ttfr.t j ||j }t|||St j ||j }|jd k(rT|j!}|j"|jd k7r(td |j"d |jd t|||Scc}}w)aApply 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& ! !eT2Z\`-ab b    XX./F>>'--0 0 8 1'5BR\ab b # #1'5BR\`a a4TF;<<$e %XXd'--8 ,WeZHH$gmm4J||q%%' ??gmmA. .!'{7==3C2DF  )% DD? s%F  keypointsc*|dddfddtjf}|dddfddtjf}|dddf}|dddf}|dddf}|dddf}||k\||kz||k\z||kz}tj|d} || S)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= )DAqDkGAqDkGAqDkGAqDkG7?tg~6$'/JdU\n]Kvvk22O _ %%rbboxesc|dddfjt}|dddfjt}|dddfjt}|dddfjt}g}tt|Dcgc]}|||||||||f}}|D cgc]} d| z  } } t t | |D]\}\} } | j s| j d} | j d}tj| d}tj|d}| j}|||dz|d<|||dz|d<|||dzdz|d<|||dzdz|d<|j||rtj|Stjd|jdf|jScc}wcc} w) 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@QR1yAA11 56RGR.56FQZ6M6&s=%'@A">GS{{} KKQK' KKQK' ::i(+::i(+((*UXa[( UXa[( UXb\)A- UXb\)A- !%",#,288I a1ekk!n:MUZU`U`1aa3S6s G&- G+ct|dk(st|dk(r|Stj|tj}|D]'}|j t \}}} } d||| || f<)|j t } | dddf| dddfz | dddf| dddfz z} tj | ddddfD cgc]%\} }}}tj|||| |f'c}}}} }| |z }|| z }||k\||k\z|dkDz}||}t|dk(r$tjd|jdfSt||Scc}}}} w)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:? BHH5I0%)[[%5"ueU./ %+uU{*+0 s#JAqD!Jq!t$44AqD9IJWXZ[W[L\9\]IU_`acedece`eUf"g"g\Q2r266)AbD!B$J*?#@"gh"44O')3 x ',=,O PTcfgTg hD,K ;1xxFLLO,-- ( Y ??#hs *Ec|dd\}}|2|dt|ddkDr td|j|}||fS|r|\}}||z} ||z} | | fStd|dz} td|dz} | | fS)aCalculate 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\ OMFE" 1 KO 4 4WX X-$--? )##)8&n, . J&&Q $Ja2&K  ""rc0|dd\}}t|||}|dddf|dddfz } |dddf|dddfz } tj| |zd| dz jt} tj| |zd| dz jt} | | z } | | z }|r+|j d| dz}|j d|dz}n2tj | |d}tj ||d}tj|dddf|zd|| z }tj|dddf|zd|| z }tj|| z|}tj|| z|}tj||||fS)a Generate 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 OMFE {D2B CEA;q!t,L1+ad +K77<%/L14DELLSQL''+-q+/BII#NK ,.L,L#,,Q q0@A#,,Q q0@A<< hqk:<< hqk: GGE!Q$K(*Au{/B CE GGE!Q$K(*Av /D EE JJu{*E 2E JJu|+V 4E ??E5%7 88rc|\}}|jdkDre|jddk(r|jd}nA|jddkrtj|d}ntj|d}tj d|d|f\}}|dddf|dddddfk\|dddf|dddddfkz|dddf|dddddfk\z|dddf|dddddfkz} |dddf|dddfz |dddf|dddfz z} tj | |zd } | | z } | |k\| |k\z} || S) 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* MFE1   a A %'//2L    #q (66,R8L66,Q7L 88GVGVeVO $DAq 47vaD$./ / T1W:1dD 01 1 3 T1W:1dD 01 1 3 T1W:1dD 01 1 31q!t ,1q!t 1LMIFF9 }46BM%y0(*/?>/QRI ) rc0|jdkDre|jddk(r|jd}nA|jddkrtj|d}ntj|d}|ddddfj t }|dddfdk\|dddf|jdkz|dddfdk\z|dddf|jdkz}tj|r||}||dddf|dddff||<||S)aFilter 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 sD 1   a A %'//2L    #q (66,R8L66,Q7Lq"1"u  $ $S )F 1  !Q$<,,,Q/ / 1 !Q$<1   !Q$<,,,Q/ / 1 vvjj) ".|AqD/Arsf# 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)