U hA@sRddlmZddlZddlmZmZmZddlm Z ddl m Z ddl m Z ddlmZddlmZmZd d d d d ddgZed/ddddddd Zddddddd Zd0dddddddd Zedddddd Zdddd d dd!d"d Zdd#d#dd$d%dZddd d&dddd'd(dZedddd d dd)d*d+Zedddd,d-d.ZdS)1) annotationsN)MAX_VALUES_BY_DTYPEis_grayscale_imagepreserve_channel_dim)Literal) random_utils)split_uniform_grid)handle_empty_array)MONO_CHANNEL_DIMENSIONS ColorTypecutoutchannel_dropoutfilter_keypoints_in_holesgenerate_random_fillfilter_bboxes_by_holescalculate_grid_dimensionsgenerate_grid_holesz np.ndarrayz"int | tuple[int, ...] | np.ndarrayr )imgchannels_to_drop fill_valuereturncCs,t|rd}t||}||d|f<|S)Nz0Only one channel. ChannelDropout is not defined..)rNotImplementedErrorcopy)rrrmsgrS/tmp/pip-unpacked-wheel-e8onvpoz/albumentations/augmentations/dropout/functional.pyr s  znp.dtypeztuple[int, ...]znp.random.RandomState | None)dtypeshape random_statercCsft|}t|tjr.tjd|d|||dSt|tjrTtjd|||d|St d|dS)a9Generate 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_state (np.random.RandomState | None): The random state to use for generating values. If None, the default numpy random state 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)sizerr)r rzUnsupported dtype: N) rnpZ issubdtypeintegerrrandintZfloatinguniformastype ValueError)rrrZ max_valuerrrr&s zColorType | Literal['random'])rholesrrrc Cs|}t|ttttfr*tj||jd}|D]\}}}}t|t r|dkr|j t krf||||fn|||||j df}t |j||} | |||||f<q.||||||f<q.|S)a Apply cutout augmentation to the image by cutting out holes and filling them with either a given value or random noise. Args: img (np.ndarray): The image to augment. Can be a 2D (grayscale) or 3D (color) array. holes (np.ndarray): An array of holes with shape (num_holes, 4). Each hole is represented as [x1, y1, x2, y2]. fill_value (Union[ColorType, Literal["random"]], optional): The fill value to use for the holes. Can be a single integer, a tuple or list of numbers for multichannel images, or the string "random" to fill with random noise. random_state (np.random.RandomState | None, optional): The random state to use for generating random fill values. If None, a new random state will be used. Defaults to None. Returns: np.ndarray: The augmented image with cutout holes applied. Raises: ValueError: If the fill_value is not of the expected type. Note: - The function creates a copy of the input image before applying the cutout. - For multichannel images, the fill_value should match the number of channels. - When using "random" fill, the random values are generated to match the image's dtype and shape. Example: >>> import numpy as np >>> img = np.ones((100, 100, 3), dtype=np.uint8) * 255 >>> holes = np.array([[20, 20, 40, 40], [60, 60, 80, 80]]) >>> result = cutout(img, holes, fill_value=0) >>> print(result.shape) (100, 100, 3) rrandom)r isinstanceintfloattuplelistr!arrayrstrndimr rr) rr'rrx_miny_minx_maxy_maxrZ random_fillrrrr Ms&) keypointsr'rc Cs|dddfddtjf}|dddfddtjf}|dddf}|dddf}|dddf}|dddf}||k||k@||k@||k@}tj|dd} || 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. Nrrr*Zaxis)r!Znewaxisany) r7r'Zkp_xZkp_yZhole_x1Zhole_y1Zhole_x2Zhole_y2Z inside_holeZvalid_keypointsrrrrs ztuple[int, int]r-)bboxesr' image_shapemin_areamin_visibilityrcCsBt|dkst|dkr|Stj|tjd}|D]*}|t\}}} } d||| || f<q0|t} | dddf| dddf| dddf| dddff\}}} } | || |} tjt|td} tt|D]`}t|||| |||| |f}| ||}d|| |}||ko2||k| |<q|| S)aFilter bounding boxes based on their remaining visible area and visibility ratio after intersection with holes. Args: bboxes (np.ndarray): Array of bounding boxes, each represented as [x_min, y_min, x_max, y_max]. holes (np.ndarray): Array of holes, each represented as [x_min, y_min, x_max, y_max]. image_shape (tuple[int, int]): Shape of the image (height, width). min_area (int): Minimum remaining visible area to keep the bounding box. min_visibility (float): Minimum visibility ratio to keep the bounding box. Calculated as 1 - (intersection_area / bbox_area). Returns: np.ndarray: Filtered array of bounding boxes. rr(rNr*r8) lenr!zerosZuint8r%r,boolrangesum)r;r'r<r=r>Z hole_maskZholer3r4r5r6Z bboxes_int box_areasmaskiZintersection_areaZremaining_areavisibility_ratiorrrrs  D* ztuple[int, int] | None)r<unit_size_rangeholes_number_xyrc Cs|dd\}}|dk rJ|dt|ddkr8tdtj|}||fS|rn|\}}||}||} | |fStd|d}td|d} | |fS)a]Calculate 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. 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) Nr*rz8Grid size limits must be within the shortest image edge. )minr&rr#max) r<rHrIheightwidthZ unit_sizeZholes_number_xZholes_number_yZ unit_widthZ unit_heightrrrrs+ rA)r<gridratio random_offsetrshift_xyrcCsh|dd\}}t|||}|dddf|dddf} |dddf|dddf} t| |d| dt} t| |d| dt} | | } | | }|r|dk r|d| d}|d|d}n t| |d}t||d}t|dddf|d|| }t|dddf|d|| }t|| |}t|| |}t||||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. random_state (np.random.RandomState | None): The random state for generating random offsets and shuffling. If None, a new RandomState will be created. 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. 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] Nr*rr8r) rr!Zclipr%r,r#Z full_likeZminimumZ column_stack)r<rOrPrQrrRrMrNcellsZ cell_heightsZ cell_widthsZ hole_heightsZ hole_widthsZ max_offset_yZ max_offset_xZoffset_yZoffset_xr3r4r5r6rrrrs$3    "")r; dropout_maskr<r=r>rcCs*|\}}tjd|d|f\}}|dddf|dddddfk|dddf|dddddfk@|dddf|dddddfk@|dddf|dddddfk@} |dddf|dddf|dddf|dddf} tj| |@dd} | | } | |k| |k@} || S)aFilter out bounding boxes based on their intersection with the dropout mask. Args: bboxes (np.ndarray): Array of bounding boxes with shape (N, 4+) in format [x_min, y_min, x_max, y_max, ...]. dropout_mask (np.ndarray): Boolean mask of shape (height, width) where True values indicate dropped out regions. image_shape (Tuple[int, int]): The shape of the original image as (height, width). min_area (float): Minimum area of the bounding box to be kept. min_visibility (float): Minimum visibility ratio of the bounding box to be kept. Returns: np.ndarray: Filtered array of bounding boxes. Nrr*rr8)rr*r9)r!ZogridrCZsqueeze)r;rTr<r=r>rMrNyxZ box_masksrDZ visible_areasrGZ keep_maskrrrmask_dropout_bboxesks""""@rW)r7rTrcs tfdd|D}||S)Ncs*g|]"}t|dt|df qS)rr)r,).0ZkprTrr sz*mask_dropout_keypoints..)r!r0)r7rTZ keep_indicesrrYrmask_dropout_keypointssr[)r)N) __future__rZnumpyr!ZalbucorerrrZtyping_extensionsrZalbumentationsrZ1albumentations.augmentations.geometric.functionalrZ"albumentations.augmentations.utilsr Zalbumentations.core.typesr r __all__r rr rrrrrWr[rrrrs<      +:2?T-