U hʉ$@s* ddlmZddlZddlmZmZmZmZmZm Z m Z ddl Z ddl Z ddlZddlmZmZmZmZmZmZddlmZddlmZmZddlmZmZmZm Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(d d d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+g$Z)d,Z*d,Z+d-Z,ed.d/d.d0d1d!Z-ed.d2d.d3d4dZ.eed.d/d5d.d6d7d"Z/ed.d2d5d8d.d9d:d Z0ed"d.d;d/d/ddZ1ed.d;d?d5d.d@dAdZ2eed.d;d5d.dBdCdZ3ed.d5d/d.dDdEdZ4ed.d;d/d.dFdGdZ5ed.d;d;d.dHdIdJZ6d.d/d/dKd.dLdMdZ7ed.d/d/d.dNdOdZ8ed.d/d/d.dNdPdZ9ed.d.d/d/dQd/dRd/d.dS dTdZ:ed.d5d.d/d/dRd.dUdVdWZ;d.dRd;dXdYdZd.d.d`d/d/dad.dbdcddZ?ed.d]d/dad/d`d.dedfdZ@eed.d]d5dgd/d.dhdidjZAd]d`dkdldmdnZBed.d]d.dodpdqZCed.d]d.dodrdsZDed.d]d?d5d/d5d.dtdudvZEed.dwd/dxd;d.dydzdZFd#d.d5dRd.d|d}dZGd~ddddZHd5d.ddRddddZId$d.dRd~dd.dddZJed.dwd5d;d.dddZKed.dd5d;d.dddZLd.d2d.dddZMed.d/d.dddZNd.d.dddZOd.d/d.dddZPed.d.ddd%ZQed.d.ddd'ZRed.d/d.dddZSed.d.ddd#ZTeed.d/d.ddd&ZUeed.d/d.ddd(ZVeed.d/d5d.dddZWeed.d.ddd$ZXed.d/d/d/dzbboxes_d4..cSs t|dSNrIr6rWrSrSrTrYrZcSs t|dSNrAr\rWrSrSrTrYrZcSs t|dSNrBr\rWrSrSrTrYrZcSst|SrV)r:rWrSrSrTrYrZcSstt|dSr])r8r6rWrSrSrTrYrZcSst|SrV)r<rWrSrSrTrYrZcSst|SrV)r8rWrSrSrTrYrZeZr90Zr180Zr270vZhvthtInvalid group member: NrK)rErUtransformationsrSrSrTr4ps  ztuple[int, int]) keypointsrF image_shaperGc Cs^|dkrtd|dkr|S|dd\}}|tj}|dddf|dddf|dddf}}}|dkr||dddf<|d||dddf<|tjd|dddf<n|tkr|d||dddf<|d||dddf<|tj|dddf<nL|tkrZ|d||dddf<||dddf<|tjd|dddf<|S)a0Rotate keypoints by 90 degrees counter-clockwise (CCW) a specified number of times. Args: keypoints (np.ndarray): An array of keypoints with shape (N, 4+) in the format (x, y, angle, scale, ...). factor (int): The number of 90 degree CCW rotations to apply. Must be in the range [0, 3]. image_shape (tuple[int, int]): The shape of the image (height, width). Returns: np.ndarray: The rotated keypoints with the same shape as the input. Raises: ValueError: If the factor is not in the set {0, 1, 2, 3}. rHrJrNrArI)rKrLastypenpfloat32pirMrN) rgrFrhheightwidthrotated_keypointsrXyanglerSrSrTr7s(4  r)rgrUrhparamsrGc sdd\ddfddfddfddfddfd dfd dd dd }||krr|||Std |dS)aApplies a `D_4` symmetry group transformation to a keypoint. This function adjusts a keypoint's coordinates according to the specified `D_4` group transformation, which includes rotations and reflections suitable for image processing tasks. These transformations account for the dimensions of the image to ensure the keypoint remains within its boundaries. Parameters: - keypoints (np.ndarray): An array of keypoints with shape (N, 4+) in the format (x, y, angle, scale, ...). -group_member (D4Type): A string identifier for the `D_4` group transformation to apply. Valid values are 'e', 'r90', 'r180', 'r270', 'v', 'hv', 'h', 't'. - image_shape (tuple[int, int]): The shape of the image. - params (Any): Not used Returns: - KeypointInternalType: The transformed keypoint. Raises: - ValueError: If an invalid group member is specified, indicating that the specified transformation does not exist. Examples: - Rotating a keypoint by 90 degrees in a 100x100 image: `keypoint_d4((50, 30), 'r90', 100, 100)` This would move the keypoint from (50, 30) to (70, 50) assuming standard coordinate transformations. NrAcSs|SrVrSrWrSrSrTrYrZzkeypoints_d4..cs t|dSr[r7rWrhrSrTrYrZcs t|dSr]rsrWrtrSrTrYrZcs t|dSr^rsrWrtrSrTrYrZcs t|SrV)r;rW)rowsrSrTrYrZcstt|dSr])r9r7rWrtrSrTrYrZcs t|SrV)r=rW)colsrSrTrYrZcSst|SrV)r9rWrSrSrTrYrZr_rdre)rgrUrhrrrfrS)rvrhrurTr5s        floatzColorType | None)imgrq interpolation border_modevaluerGc CsL|jdd}t|}t||d}|\}} tt|| |f|||d} | |S)NrA?matrixdsizeflagsrz border_value)shaper>cv2getRotationMatrix2Dr warp_affine_with_value_extension) rxrqryrzr{rh image_centerr~rmrnwarp_fnrSrSrTr#sz#Literal[('largest_box', 'ellipse')])rErqmethodrhrGcCs(|}|dd\}}|dddf|dddf|dddf|dddff\}}}} |t|} |dkrt||||gd} t||| | gd} n|dkrL||d} | |d}tjdd tjd }| ddtjftt|| |dddtjf} |ddtjft t|||dddtjf} nt d |d t |}t || | t|| | }t| | | t || }|d}|d}tj |dd |dddf<tj |dd |dddf<tj |dd |dddf<tj |dd |dddf<|S)a-Rotates bounding boxes by angle degrees. Args: bboxes: A numpy array of bounding boxes with shape (num_bboxes, 4+). Each row represents a bounding box (x_min, y_min, x_max, y_max, ...). angle: Angle of rotation in degrees. method: Rotation method used. Should be one of: "largest_box", "ellipse". image_shape: Image shape (height, width). Returns: np.ndarray: A numpy array of rotated bounding boxes with the same shape as input. Reference: https://arxiv.org/abs/2109.13488 NrArrIrB largest_box?ellipsehZdtypeMethod is not a valid rotation method.axis)rLrwrj column_stackarangerknewaxissinradianscosrKdeg2radminmax)rErqrrhrurvrOrPrQrRr%rXrpwrbdataZ angle_radZx_tZy_trSrSrTr2s0D    <> $")rgrqrhrGcCst|}t||d}|tj}|ddddf}t|ddd| }||ddddf<|dddft |7<|S)a.Rotate keypoints by a specified angle. Args: keypoints (np.ndarray): An array of keypoints with shape (N, 4+) in the format (x, y, angle, scale, ...). angle (float): The angle by which to rotate the keypoints, in degrees. image_shape (tuple[int, int]): The shape of the image the keypoints belong to (height, width). **params: Additional parameters. Returns: np.ndarray: The rotated keypoints with the same shape as the input. Note: The rotation is performed around the center of the image. r|NrArI) r>rrrLrirjrk transformreshapesqueezer)rgrqrhrr~roxyZ xy_rotatedrSrSrTr3Ns)rx target_shaperyrGcCs:||jddkr|S|\}}ttj||f|d}||S)NrA)rry)rr rr$)rxrryrmrnZ resize_fnrSrSrTr$xs )rxr%ryrGcCs6|jdd\}}t||t||f}t|||Sr])rrDr$)rxr%ryrmrnZnew_sizerSrSrTr%s)rgscale_xscale_yrGc Cs|dddf|dddf|dddf|dddff\}}}}||}||}|t||} t|||| g} |jdtkrt| |ddtdfg} | S)aNScales keypoints by scale_x and scale_y. Args: keypoints: A numpy array of keypoints with shape (N, 4+) in the format (x, y, angle, scale, ...). scale_x: Scale coefficient x-axis. scale_y: Scale coefficient y-axis. Returns: A numpy array of scaled keypoints with the same shape as input. NrrIrArB)rrjrrr) rgrrrXrprqr%Zx_scaledZy_scaledZ scale_scaledZscaled_keypointsrSrSrTkeypoints_scales DrzCallable[..., Any])rxmax_sizeryfuncrGcsV|jdd}|t||dkrRtfdd|D\}}t|||f|dS|S)NrAr|c3s|]}t|VqdSrV)round).0Zdimr%rSrT sz!_func_max_size..ry)rrwtupler$)rxrryrrh new_height new_widthrSrrTr&s )rxrryrGcCst|||tSrV)r&rrxrryrSrSrTr'scCst|||tSrV)r&rrrSrSrTr(sz float | list[float] | np.ndarraybool) rxr~ max_width max_height border_valrz keep_sizeryrGc CsF|jdd}ttj|||f|||d} | |} |rBt| ||dS| S)NrA)Mr borderMode borderValuerr)rr rwarpPerspectiver$) rxr~rrrrzrryrhZperspective_funcwarpedrSrSrTr)s )rErhr~rrrrGcCs|dd\}}|}t|ddddf|} | j\} } } } t| | g| | g| | g| | ggddd}|dd}tj|ddd }t||||||}|ddddfddd}td d |D}|r|n||r|n|f}t ||}||ddddf<|S) aApplies perspective transformation to bounding boxes. This function transforms bounding boxes using the given perspective transformation matrix. It handles bounding boxes with additional attributes beyond the standard coordinates. Args: bboxes (np.ndarray): An array of bounding boxes with shape (num_bboxes, 4+). Each row represents a bounding box (x_min, y_min, x_max, y_max, ...). Additional columns beyond the first 4 are preserved unchanged. image_shape (tuple[int, int]): The shape of the image (height, width). matrix (np.ndarray): The perspective transformation matrix. max_width (int): The maximum width of the output image. max_height (int): The maximum height of the output image. keep_size (bool): If True, maintains the original image size after transformation. Returns: np.ndarray: An array of transformed bounding boxes with the same shape as input. The first 4 columns contain the transformed coordinates, and any additional columns are preserved from the input. Note: - This function modifies only the coordinate columns (first 4) of the input bounding boxes. - Any additional attributes (columns beyond the first 4) are kept unchanged. - The function handles denormalization and renormalization of coordinates internally. Example: >>> bboxes = np.array([[0.1, 0.1, 0.3, 0.3, 1], [0.5, 0.5, 0.8, 0.8, 2]]) >>> image_shape = (100, 100) >>> matrix = np.array([[1.5, 0.2, -20], [-0.1, 1.3, -10], [0.002, 0.001, 1]]) >>> transformed_bboxes = perspective_bboxes(bboxes, image_shape, matrix, 150, 150, False) NrArrIr)rr)rrAconstant)modec Ss`g|]X}t|dddft|dddft|dddft|dddfgqS)NrrI)rjrr)rZboxrSrSrT sz&perspective_bboxes..) rLrTrjarrayr0rr!perspective_keypointsr)rErhr~rrrrmrntransformed_bboxesZdenormalized_coordsrOrPrQrRpointsZpoints_reshapedZ points_paddedtransformed_pointsZ new_coords output_shapeZnormalized_coordsrSrSrTperspective_bboxess (,   r)r~y_uprGcCs.|rt|d|dSt|d |dS)z`Args: matrix (np.ndarray): Rotation matrix y_up (bool): is Y axis looks up or down rIrr)rjZarctan2)r~rrSrSrTr*+s)rgrhr~rrrrGcCs|tj}|dd\}}|dddf|dddf|dddf|dddff\}} } } t|| ftjddd} t| |} | j dkr| tj ddf} | dddf| dddf}} | t |ddddfdd7} t |dt |dd|d d}t |d t |d d|d d}| t||9} |r|dd\}}||}||}||9}| |9} | t||9} t|| | | g}|jdtkrt||ddtdfgS|S) NrArrIrBrTrr)rrI)rIrIr)rLrirjrkrrrperspectiveTransformrndimrr*signsqrtrrr)rgrhr~rrrrmrnrXrprqr%Zkeypoint_vectorrrrtransformed_keypointsrSrSrTr6s2 D  " ,,rz%skimage.transform.ProjectiveTransform)r~rGcCst|jtjdtjdS)NrBr)rjZallcloserrZeyerk)r~rSrSrTr+nsz Sequence[int]r)imager~rrrzrrGcCs(t|}t||}tj||||||dS)N)rrr)r extend_valuerZ warpAffine)rr~rrrzr num_channelsextended_valuerSrSrTrrs r)rr~rycvalrrrGc Cs^t|r |Stt|d}tt|d}||f}tt|jdd||||d} | |S)NrrIrAr})r+rDrjrr rrr) rr~ryrrrrmrnrrrSrSrTr,s  zdict[str, Any])rgr~rhr%rrGcCs|tj}t|r|S|tkrVt||\}}}}t|||||} t|| |dd}|ddddf} t | ddd|j dd } t|j dddd} |dddf| |dddf<t|d |d } |ddd f| 9<| |ddddf<|S) uApply an affine transformation to keypoints. This function transforms keypoints using the given affine transformation matrix. It handles reflection padding if necessary, updates coordinates, angles, and scales. Args: keypoints (np.ndarray): Array of keypoints with shape (N, 4+) where N is the number of keypoints. Each keypoint is represented as [x, y, angle, scale, ...]. matrix (skimage.transform.ProjectiveTransform): The affine transformation matrix. image_shape (tuple[int, int]): Shape of the image (height, width). scale (dict[str, Any]): Dictionary containing scale factors for x and y directions. Expected keys are 'x' and 'y'. mode (int): Border mode for handling keypoints near image edges. Use cv2.BORDER_REFLECT_101, cv2.BORDER_REFLECT, etc. Returns: np.ndarray: Transformed keypoints array with the same shape as input. Notes: - The function applies reflection padding if the mode is in REFLECT_BORDER_MODES. - Coordinates (x, y) are transformed using the affine matrix. - Angles are adjusted based on the rotation component of the affine transformation. - Scales are multiplied by the maximum of x and y scale factors. - The @angle_2pi_range decorator ensures angles remain in the [0, 2π] range. Example: >>> keypoints = np.array([[100, 100, 0, 1]]) >>> matrix = skimage.transform.ProjectiveTransform(...) >>> scale = {'x': 1.5, 'y': 1.2} >>> transformed_keypoints = keypoints_affine(keypoints, matrix, (480, 640), scale, cv2.BORDER_REFLECT_101) Tcenter_in_originNrArrIFrrXrprB)rLrirjrkr+r"calculate_affine_transform_paddingget_pad_grid_dimensionsgenerate_reflected_keypointsrrrrrrr*r)rgr~rhr%rpad_left pad_rightpad_top pad_bottomgrid_dimensionsrZxy_transformedZangle_adjustmentZ max_scalerSrSrTkeypoints_affines($ rztuple[int, int, int, int])r~rhrGcCs |dd\}}t|rdStddg|dg||gd|gg}||}t||f}|jdd\}}|jdd\} } |j} t||g| |g| | g|| gg} | | } | jdd\}}| jdd\} } tdtd|}tdt| |}tdtd|}tdt| |}||||fS)zSCalculate the necessary padding for an affine transformation to avoid empty spaces.NrA)rrrrrr) r+rjrvstackrrinversemathceil)r~rhrmrncornerstransformed_cornersZ all_cornersZmin_xZmin_yZmax_xZmax_yZinverse_matrixZ bbox_cornersZinverse_cornersrrrrrSrSrTrs$""r)rEr~rGc Cs:|dddf|dddf|dddf|dddff\}}}}t||g||g||g||ggddd}tj|dd|j}|ddd}tj|dddddfdd}tj |dddddfdd} tj|dddddfdd} tj |dddddfdd} t || | | |ddddfgS) aApply an affine transformation to bounding boxes and return the largest enclosing boxes. This function transforms each corner of every bounding box using the given affine transformation matrix, then computes the new bounding boxes that fully enclose the transformed corners. Args: bboxes (np.ndarray): An array of bounding boxes with shape (N, 4+) where N is the number of bounding boxes. Each row should contain [x_min, y_min, x_max, y_max] followed by any additional attributes (e.g., class labels). matrix (skimage.transform.ProjectiveTransform): The affine transformation matrix to apply. Returns: np.ndarray: An array of transformed bounding boxes with the same shape as the input. Each row contains [new_x_min, new_y_min, new_x_max, new_y_max] followed by any additional attributes from the input bounding boxes. Note: - This function assumes that the input bounding boxes are in the format [x_min, y_min, x_max, y_max]. - The resulting bounding boxes are the smallest axis-aligned boxes that completely enclose the transformed original boxes. They may be larger than the minimal possible bounding box if the original box becomes rotated. - Any additional attributes beyond the first 4 coordinates are preserved unchanged. - This method is called "largest box" because it returns the largest axis-aligned box that encloses all corners of the transformed bounding box. Example: >>> bboxes = np.array([[10, 10, 20, 20, 1], [30, 30, 40, 40, 2]]) # Two boxes with class labels >>> matrix = skimage.transform.AffineTransform(scale=(2, 2), translation=(5, 5)) >>> transformed_bboxes = bboxes_affine_largest_box(bboxes, matrix) >>> print(transformed_bboxes) [[ 25. 25. 45. 45. 1.] [ 65. 65. 85. 85. 2.]] NrrIrArBrrr) rjrr0skimagerZmatrix_transformrrrrrr) rEr~rOrPrQrRrr new_x_min new_x_max new_y_min new_y_maxrSrSrTbboxes_affine_largest_boxs$D"    rc Cs^|dddf|dddf|dddf|dddff\}}}}||d}||d}||}||} tjddtjd} tt| } tt| } |ddtjf| |ddtjf} |ddtjf| | ddtjf}tj| |gdd dd}tj |t |j ddfgdd }||j j }t|ddddfdkttj|ddddf|ddddf<||ddddfddddf}|t|dd}tj|dddddfdd }tj|dddddfdd }tj|dddddfdd }tj|dddddfdd }t|||||ddd dfgS) aApply an affine transformation to bounding boxes using an ellipse approximation method. This function transforms bounding boxes by approximating each box with an ellipse, transforming points along the ellipse's circumference, and then computing the new bounding box that encloses the transformed ellipse. Args: bboxes (np.ndarray): An array of bounding boxes with shape (N, 4+) where N is the number of bounding boxes. Each row should contain [x_min, y_min, x_max, y_max] followed by any additional attributes (e.g., class labels). matrix (skimage.transform.ProjectiveTransform): The affine transformation matrix to apply. Returns: np.ndarray: An array of transformed bounding boxes with the same shape as the input. Each row contains [new_x_min, new_y_min, new_x_max, new_y_max] followed by any additional attributes from the input bounding boxes. Note: - This function assumes that the input bounding boxes are in the format [x_min, y_min, x_max, y_max]. - The ellipse approximation method can provide a tighter bounding box compared to the largest box method, especially for rotations. - 360 points are used to approximate each ellipse, which provides a good balance between accuracy and computational efficiency. - Any additional attributes beyond the first 4 coordinates are preserved unchanged. - This method may be more suitable for objects that are roughly elliptical in shape. Example: >>> bboxes = np.array([[10, 10, 30, 20, 1], [40, 40, 60, 60, 2]]) # Two boxes with class labels >>> matrix = skimage.transform.AffineTransform(rotation=np.pi/4) # 45-degree rotation >>> transformed_bboxes = bboxes_affine_ellipse(bboxes, matrix) >>> print(transformed_bboxes) [[ 5.86 5.86 34.14 24.14 1. ] [30. 30. 70. 70. 2. ]] NrrIrArBrrrrr)rjrrkrrrrstackrZ concatenateZonesrrrrwhereZfinforwZepslenrrr)rEr~rOrPrQrRZ bbox_widthZ bbox_heightZcenter_xZcenter_yanglesZ cos_anglesZ sin_anglesrXrprrrrrrrSrSrTbboxes_affine_ellipseMs2$D  (("  (    r)rEr~ rotate_methodrhrzrrGc Cst|r |St||}|tkrPt||\}}}} t|| |||} t|| |dd}|dkrdt||} n$|dkrxt||} ntd|dt | |} t | |S)aApply an affine transformation to bounding boxes. For reflection border modes (cv2.BORDER_REFLECT_101, cv2.BORDER_REFLECT), this function: 1. Calculates necessary padding to avoid information loss 2. Applies padding to the bounding boxes 3. Adjusts the transformation matrix to account for padding 4. Applies the affine transformation 5. Validates the transformed bounding boxes For other border modes, it directly applies the affine transformation without padding. Args: bboxes (np.ndarray): Input bounding boxes matrix (skimage.transform.ProjectiveTransform): Affine transformation matrix rotate_method (str): Method for rotating bounding boxes ('largest_box' or 'ellipse') image_shape (Sequence[int]): Shape of the input image border_mode (int): OpenCV border mode output_shape (Sequence[int]): Shape of the output image Returns: np.ndarray: Transformed and normalized bounding boxes Trrrrr) r+rrrrgenerate_reflected_bboxesrrrKvalidate_bboxesr) rEr~rrhrzrrrrrrrZvalidated_bboxesrSrSrT bboxes_affines    rz1skimage.transform.PiecewiseAffineTransform | Nonestr)rxr~ryrrrGc Cs(|dkr |Stjj|||||d|jdS)NT)orderrrZpreserve_ranger)rrZwarpr)rxr~ryrrrSrSrTr-sF)rgrhinvertedrGc Cs|dd\}}t|dkr2tj||dftjdStjd|d|f\}}t|}t|dtjf|dddfd|dtjf|dddfd}|rd|dtjS|tjS)a(Generate a ``(H,W,N)`` array of distance maps for ``N`` keypoints. The ``n``-th distance map contains at every location ``(y, x)`` the euclidean distance to the ``n``-th keypoint. This function can be used as a helper when augmenting keypoints with a method that only supports the augmentation of images. Args: keypoints: A numpy array of shape (N, 2+) where N is the number of keypoints. Each row represents a keypoint's (x, y) coordinates. image_shape: tuple[int, int] shape of the image (height, width) inverted (bool): If ``True``, inverted distance maps are returned where each distance value d is replaced by ``d/(d+1)``, i.e. the distance maps have values in the range ``(0.0, 1.0]`` with ``1.0`` denoting exactly the position of the respective keypoint. Returns: np.ndarray: A ``float32`` array of shape (H, W, N) containing ``N`` distance maps for ``N`` keypoints. Each location ``(y, x, n)`` in the array denotes the euclidean distance at ``(y, x)`` to the ``n``-th keypoint. If `inverted` is ``True``, the distance ``d`` is replaced by ``d/(d+1)``. The height and width of the array match the height and width in ``image_shape``. NrArr.rI) rrjzerosrkZmgridrrrri) rgrhrrmrnyyxxZkeypoints_arrayZ distancesrSrSrTr.s  Bz%Sequence[int] | dict[str, Any] | Noneztuple[bool, float, float])if_not_found_coordsrGcCsp|dkr dSt|ttfrDt|tkr2d}t|d|d|dfSt|tr`d|d|dfSd }t|dS) z5Validate and process `if_not_found_coords` parameter.N)TrrzIExpected tuple/list 'if_not_found_coords' to contain exactly two entries.FrrIrXrpz>Expected if_not_found_coords to be None, tuple, list, or dict.) isinstancerlistrPAIRrKdict)rmsgrSrSrTvalidate_if_not_found_coordss  rz float | Noneztuple[float, float] | None)position distance_map thresholdrrGcCsT|\}}|||f}|s,|dk r,||kr,dS|rD|dk rD||krDdSt|t|fS)zADetermine if a valid keypoint can be found at the given position.N)rw)rrrrrprXr{rSrSrT find_keypoint.s r) distance_mapsrrrrGcCs|jtkr(d|jd|jd}t||j\}}}t|\}} } |rbtj||||dd} ntj||||dd} t | ||f\} } t | | f t }|dk r|r|| | t |f|k}n|| | t |f|k}|s| | g||<n||S|S)a~ Convert distance maps back to keypoints coordinates. This function is the inverse of `to_distance_maps`. It takes distance maps generated for a set of keypoints and reconstructs the original keypoint coordinates. The function supports both regular and inverted distance maps, and can handle cases where keypoints are not found or fall outside a specified threshold. Args: distance_maps (np.ndarray): A 3D numpy array of shape (height, width, nb_keypoints) containing distance maps for each keypoint. Each channel represents the distance map for one keypoint. inverted (bool): If True, treats the distance maps as inverted (where higher values indicate closer proximity to keypoints). If False, treats them as regular distance maps (where lower values indicate closer proximity). if_not_found_coords (Sequence[int] | dict[str, Any] | None, optional): Coordinates to use for keypoints that are not found or fall outside the threshold. Can be: - None: Drop keypoints that are not found. - Sequence of two integers: Use these as (x, y) coordinates for not found keypoints. - Dict with 'x' and 'y' keys: Use these values for not found keypoints. Defaults to None. threshold (float | None, optional): A threshold value to determine valid keypoints. For inverted maps, values >= threshold are considered valid. For regular maps, values <= threshold are considered valid. If None, all keypoints are considered valid. Defaults to None. Returns: np.ndarray: A 2D numpy array of shape (nb_keypoints, 2) containing the (x, y) coordinates of the reconstructed keypoints. If `drop_if_not_found` is True (derived from if_not_found_coords), the output may have fewer rows than input keypoints. Raises: ValueError: If the input `distance_maps` is not a 3D array. Notes: - The function uses vectorized operations for improved performance, especially with large numbers of keypoints. - When `threshold` is None, all keypoints are considered valid, and `if_not_found_coords` is not used. - The function assumes that the input distance maps are properly normalized and scaled according to the original image dimensions. Example: >>> distance_maps = np.random.rand(100, 100, 3) # 3 keypoints >>> inverted = True >>> if_not_found_coords = [0, 0] >>> threshold = 0.5 >>> keypoints = from_distance_maps(distance_maps, inverted, if_not_found_coords, threshold) >>> print(keypoints.shape) (3, 2) z&Expected three-dimensional input, got z dimensions and shape .rrN)rrrrKrrjZargmaxrZargminZ unravel_indexrrirwr)rrrrrrmrnZ nb_keypointsZdrop_if_not_foundZif_not_found_xZif_not_found_yZ hitidx_flatZhitidx_yZhitidx_xrgZ valid_maskrSrSrTr/>s$3  )rgr~rhkeypoints_thresholdrGc Cs|dkr |S|dddf|dddf}}t|ddddf|d}t||ddd}t|dddd|}t|||g}|jdtkrt||ddtdfgS|S) NrArBTrrrrXrprI)r.r-r/rjrrr) rgr~rhras dist_mapsZtransformed_xyrrSrSrTkeypoints_piecewise_affines"r z*skimage.transform.PiecewiseAffineTransform)rEr~rhrrGc Cs|dkr |S|dd\}}t||}t|ddddgf|ddddgf|ddddgf|ddddgfg}|ddddd}t||d}t||ddd}t|dddd|} | dd d} | dddddfdk| dddddf|k@| dddddfdk@| dddddf|k@} t|} t t |D]} | | | | } t | dkr| dddf | | df<| dddf | | df<| dddf | | df<| dddf | | df<n || | | <qJt | |S) NrArrIrBrTrr r)rrjrr0rr.r-r/ zeros_likerangerrrr)rEr~rhrrmrnZ denorm_bboxesrgr rmask new_bboxesiZ valid_pointsrSrSrTbboxes_piecewise_affinesD   r)rxrUrGc CsPddddddddtddttd}||kr>|||Std|d S) aApplies a `D_4` symmetry group transformation to an image array. This function manipulates an image using transformations such as rotations and flips, corresponding to the `D_4` dihedral group symmetry operations. Each transformation is identified by a unique group member code. Parameters: - img (np.ndarray): The input image array to transform. - group_member (D4Type): A string identifier indicating the specific transformation to apply. Valid codes include: - 'e': Identity (no transformation). - 'r90': Rotate 90 degrees counterclockwise. - 'r180': Rotate 180 degrees. - 'r270': Rotate 270 degrees counterclockwise. - 'v': Vertical flip. - 'hvt': Transpose over second diagonal - 'h': Horizontal flip. - 't': Transpose (reflect over the main diagonal). Returns: - np.ndarray: The transformed image array. Raises: - ValueError: If an invalid group member is specified. Examples: - Rotating an image by 90 degrees: `transformed_image = d4(original_image, 'r90')` - Applying a horizontal flip to an image: `transformed_image = d4(original_image, 'h')` cSs|SrVrSrWrSrSrTrYrZzd4..cSs t|dSr[rot90rWrSrSrTrYrZcSs t|dSr]rrWrSrSrTrYrZcSs t|dSr^rrWrSrSrTrYrZcSstt|dSr])r0rrWrSrSrTrYrZr_rdN)rr r0rK)rxrUrfrSrSrTr1s   )rxcoderGcCs t||SrV)rZflip)rxrrSrSrT random_flip%sr)rxrGcCs(tt|j}d\|d<|d<||S)zTransposes the first two dimensions of an array of any dimensionality. Retains the order of any additional dimensions. Args: img (np.ndarray): Input array. Returns: np.ndarray: Transposed array. rrrI)rrrr0)rxZnew_axesrSrSrTr0*s )rxrFrGcCs t||SrV)rjr)rxrFrSrSrTr<sr)rErGcCsL|}d|dddf|dddf<d|dddf|dddf<|S)aWFlip bounding boxes vertically around the x-axis. Args: bboxes: A numpy array of bounding boxes with shape (num_bboxes, 4+). Each row represents a bounding box (x_min, y_min, x_max, y_max, ...). Returns: np.ndarray: A numpy array of vertically flipped bounding boxes with the same shape as input. rINrBrLrEflipped_bboxesrSrSrTr:@s   cCsL|}d|dddf|dddf<d|dddf|dddf<|S)a[Flip bounding boxes horizontally around the y-axis. Args: bboxes: A numpy array of bounding boxes with shape (num_bboxes, 4+). Each row represents a bounding box (x_min, y_min, x_max, y_max, ...). Returns: np.ndarray: A numpy array of horizontally flipped bounding boxes with the same shape as input. rINrArrrrSrSrTr<Rs   )rEdrGcCsL|dkrt|S|dkr t|S|dkr8t|}t|Std|ddS)aFlip a bounding box either vertically, horizontally or both depending on the value of `d`. Args: bboxes: A numpy array of bounding boxes with shape (num_bboxes, 4+). Each row represents a bounding box (x_min, y_min, x_max, y_max, ...). d: dimension. 0 for vertical flip, 1 for horizontal, -1 for transpose Returns: A bounding box `(x_min, y_min, x_max, y_max)`. Raises: ValueError: if value of `d` is not -1, 0 or 1. rrIrInvalid d value . Valid values are -1, 0 and 1N)r:r<rK)rErrSrSrT bboxes_flipdsrcCs8|}|ddddddgf|ddddddgf<|S)aWTranspose bounding boxes by swapping x and y coordinates. Args: bboxes: A numpy array of bounding boxes with shape (num_bboxes, 4+). Each row represents a bounding box (x_min, y_min, x_max, y_max, ...). Returns: np.ndarray: A numpy array of transposed bounding boxes with the same shape as input. NrIrrBrAr)rEZtransposed_bboxesrSrSrTr8s ,)rgrurGcCsV|tj}|d|dddf|dddf<|dddf |dddf<|S)a,Flip keypoints vertically around the x-axis. Args: keypoints: A numpy array of shape (N, 4+) where each row represents a keypoint (x, y, angle, scale, ...). rows: Image height. Returns: np.ndarray: An array of flipped keypoints with the same shape as the input. rINrA)rLrirjrk)rgruflipped_keypointsrSrSrTr;s $)rgrvrGcCsZ|tj}|d|dddf|dddf<tj|dddf|dddf<|S)a-Flip keypoints horizontally around the y-axis. Args: keypoints: A numpy array of shape (N, 4+) where each row represents a keypoint (x, y, angle, scale, ...). cols: Image width. Returns: np.ndarray: An array of flipped keypoints with the same shape as the input. rINrrA)rLrirjrkrl)rgrvrrSrSrTr=s $")rgrrhrGcCsd|dd\}}|dkr"t||S|dkr4t||S|dkrPt||}t||Std|ddS)aFlip a keypoint either vertically, horizontally or both depending on the value of `d`. Args: keypoints: A keypoints `(x, y, angle, scale)`. d: Number of flip. Must be -1, 0 or 1: * 0 - vertical flip, * 1 - horizontal flip, * -1 - vertical and horizontal flip. image_shape: A tuple of image shape `(height, width, channels)`. Returns: A keypoint `(x, y, angle, scale)`. Raises: ValueError: if value of `d` is not -1, 0 or 1. NrArrIrrr)r;r=rK)rgrrhrurvrSrSrTkeypoints_flips    r )rgrGcCsx|}|ddddgf|ddddgf<|dddf}t|tjktjd|dtjd||dddf<|S)aTransposes keypoints along the main diagonal. Args: keypoints: A numpy array of shape (N, 4+) where each row represents a keypoint (x, y, angle, scale, ...). Returns: np.ndarray: An array of transposed keypoints with the same shape as the input. NrIrrArB)rLrjrrl)rgZtransposed_keypointsrrSrSrTr9s $8)rx min_height min_widthrzr{rGc Cs|jdd\}}||kr8t||d}|||}nd}d}||krft||d} ||| } nd} d} t|||| | ||}|jddt||t||fkrtd|jdddt||t||f|S)NrAg@rzInvalid result shape. Got: z . Expected: )rrDr"r RuntimeError) rxr!r"rzr{rmrn h_pad_top h_pad_bottom w_pad_left w_pad_rightrSrSrTr!s""(zSequence[ScalarType])r{rrGcCst|ttfr|g|S|SrV)rrDrw)r{rrSrSrTrsr)rxtopbottomleftrightrzr{rGc Cs*t|}t||}tj|||||||dS)N)Z borderTyper{)r rrZcopyMakeBorder) rxr(r)r*r+rzr{rrrSrSrT%copy_make_border_with_value_extensions  r,)rxr$r%r&r'rzr{rGc Cstt||||||d}||S)N)r(r)r*r+rzr{)r r,)rxr$r%r&r'rzr{Zpad_fnrSrSrTr"3s  )rxmap_xmap_yryrzr{rGcCstj||||||dS)Nrr)rremap)rxr-r.ryrzr{rSrSrTrJs )rgr-r.rhrGcCs |dd\}}t|ddj|dd}t|ddj|dd}|dddf|dddf}} t|d|d}t| d|d} |t| t} } || | f||| | f} || | f| || | f} t| d|d} t| d|d} t| | |ddddfgS)NrArIrrr)rjrrrepeatcliprirDr)rgr-r.rhrmrnZx_invZy_invrXrpZx_idxZy_idxZnew_xZnew_yrSrSrTrVs")rEr-r.rhrzrGcCst|}tt||d}tj|||tj|dd}|jtkrLtj |dd}n t|d}t ||ddddf<|S)N)rIrArrr/r)rArrIr) rLrjr0rrr0 INTER_NEARESTrrZ expand_dimsr)rEr-r.rhrzresultmaskstransformed_masksrSrSrTr ys  znp.random.RandomStateztuple[np.ndarray, np.ndarray])rhalphasigma same_dxdy kernel_size random_staterGc Cs|dd\}}|||tjdd}tj||||d||9}|rP|} n6|||tjdd} tj| ||| d| |9} || fS)z3Generate displacement fields for elastic transform.NrArI)dst)ZrandrirjrkrZ GaussianBlur) rhr7r8r9r:r;rmrndxdyrSrSrTgenerate_displacement_fieldss r?)rErrrrrzrhrGcCs|tkr$t||||g}t||St|||||}t|||}|d\} } |dd\} } | | |} | | |}t| | | | g}t||}||| }||| }t|||fS)Noriginal_positionrA)rrjr shift_bboxesrrr)rErrrrrzrh shift_vectorr original_row original_colZ image_heightZ image_widthZ left_shiftZ top_shiftrrrSrSrT pad_bboxess         rE)rErhrGc Cs||dd\}}|dddf|dddf|dddf|dddff\}}}}|dk|dk@||k@||k@}||S)aRValidate bounding boxes and remove invalid ones. Args: bboxes (np.ndarray): Array of bounding boxes with shape (n, 4) where each row is [x_min, y_min, x_max, y_max]. image_shape (tuple[int, int]): Shape of the image as (height, width). Returns: np.ndarray: Array of valid bounding boxes, potentially with fewer boxes than the input. Example: >>> bboxes = np.array([[10, 20, 30, 40], [-10, -10, 5, 5], [100, 100, 120, 120]]) >>> valid_bboxes = validate_bboxes(bboxes, (100, 100)) >>> print(valid_bboxes) [[10 20 30 40]] NrArrIrBrS) rErhrurvrOrPrQrR valid_indicesrSrSrTrsD r)rErBrGcCs(|}|ddddf|7<|S)aShift bounding boxes by a given vector. Args: bboxes (np.ndarray): Array of bounding boxes with shape (n, m) where n is the number of bboxes and m >= 4. The first 4 columns are [x_min, y_min, x_max, y_max]. shift_vector (np.ndarray): Vector to shift the bounding boxes by, with shape (4,) for [shift_x, shift_y, shift_x, shift_y]. Returns: np.ndarray: Shifted bounding boxes with the same shape as input. Nrr)rErBshifted_bboxesrSrSrTrAs rAzdict[str, tuple[int, int]])rrrrrhrGc Cs~|dd\}}dt||t||}dt||t||}t||} t||} ||f| | fdS)a-Calculate the dimensions of the grid needed for reflection padding and the position of the original image. Args: pad_top (int): Number of pixels to pad above the image. pad_bottom (int): Number of pixels to pad below the image. pad_left (int): Number of pixels to pad to the left of the image. pad_right (int): Number of pixels to pad to the right of the image. image_shape (tuple[int, int]): Shape of the original image as (height, width). Returns: dict[str, tuple[int, int]]: A dictionary containing: - 'grid_shape': A tuple (grid_rows, grid_cols) where: - grid_rows (int): Number of times the image needs to be repeated vertically. - grid_cols (int): Number of times the image needs to be repeated horizontally. - 'original_position': A tuple (original_row, original_col) where: - original_row (int): Row index of the original image in the grid. - original_col (int): Column index of the original image in the grid. NrArI) grid_shaper@)rr) rrrrrhrurv grid_rows grid_colsrCrDrSrSrTrs   r)rE grid_dimsrhrrGc Cs||dd\}}|d\}}|d\}} t|d|d} t|d|d} t|dd|d} t| |||| |||g} t|| }t| | } t| | } t| | } g}t|D]}t|D]}||dd kr|| dd kr|}n2||dd kr| }n|| dd kr| }n| }t|| |||||| ||||g}t||}||qqt|}|rxt|| S|S) aGenerate reflected bounding boxes for the entire reflection grid. Args: bboxes (np.ndarray): Original bounding boxes. grid_dims (dict[str, tuple[int, int]]): Grid dimensions and original position. image_shape (tuple[int, int]): Shape of the original image as (height, width). center_in_origin (bool): If True, center the grid at the origin. Default is False. Returns: np.ndarray: Array of reflected and shifted bounding boxes for the entire grid. NrArHr@Tflip_horizontalrh flip_verticalrhrMrOrhr) flip_bboxesrjrrArappendr)rErKrhrrurvrIrJrCrDZbboxes_hflippedZbboxes_vflippedZbboxes_hvflippedrBrgrid_rowgrid_colZcurrent_bboxes cell_shiftrGr4rSrSrTrs@  "             rr)rErMrOrhrGcCst|dd\}}|}|rD||ddddgf|ddddgf<|rp||ddddgf|ddddgf<|S)aFlip bounding boxes horizontally and/or vertically. Args: bboxes (np.ndarray): Array of bounding boxes with shape (n, m) where each row is [x_min, y_min, x_max, y_max, ...]. flip_horizontal (bool): Whether to flip horizontally. flip_vertical (bool): Whether to flip vertically. image_shape (tuple[int, int]): Shape of the image as (height, width). Returns: np.ndarray: Flipped bounding boxes. NrArrBrIr)rErMrOrhrurvrrSrSrTrQ`s((rQ)rgenerated_meshryrGcCst|}|D]}|dd\}}}}|dddd} tj||g||g||g||ggtjd} t| | } tj|| |jd|jdf|d} tj |jddtj d} t | t | dt | | |}q|S) aApply perspective distortion to an image based on a generated mesh. This function applies a perspective transformation to each cell of the image defined by the generated mesh. The distortion is applied using OpenCV's perspective transformation and blending techniques. Args: image (np.ndarray): The input image to be distorted. Can be a 2D grayscale image or a 3D color image. generated_mesh (np.ndarray): A 2D array where each row represents a quadrilateral cell as [x1, y1, x2, y2, dst_x1, dst_y1, dst_x2, dst_y2, dst_x3, dst_y3, dst_x4, dst_y4]. The first four values define the source rectangle, and the last eight values define the destination quadrilateral. interpolation (int): Interpolation method to be used in the perspective transformation. Should be one of the OpenCV interpolation flags (e.g., cv2.INTER_LINEAR). Returns: np.ndarray: The distorted image with the same shape and dtype as the input image. Note: - The function preserves the channel dimension of the input image. - Each cell of the generated mesh is transformed independently and then blended into the output image. - The distortion is applied using perspective transformation, which allows for more complex distortions compared to affine transformations. Example: >>> image = np.random.randint(0, 255, (100, 100, 3), dtype=np.uint8) >>> mesh = np.array([[0, 0, 50, 50, 5, 5, 45, 5, 45, 45, 5, 45]]) >>> distorted = distort_image(image, mesh, cv2.INTER_LINEAR) >>> distorted.shape (100, 100, 3) NrrArrIr)r)rjrrrrkrgetPerspectiveTransformrrruint8ZfillConvexPolyZint32ZcopyTo)rrVryZdistorted_imagemeshx1y1x2y2dst_quadsrc_quadperspective_matrrrSrSrT distort_image|s$"  "rb)rErVrhrGc s|}tjt|f|tjd}t|ddddftD]&\}\}}}}d||||||f<q@tfdd|D} t | |ddddf<|S)NrrrIcsg|]}t|tjqSrS)rbrr3)rrrVrSrTrsz&bbox_distort_image..) rLrjrrrY enumeraterirDrr) rErVrhr5rrOrPrQrRr6rSrcrTbbox_distort_images.re)rgrVrhrGcCs|}|dd\}}|D]}|dd\}}} } |dddd} tj||g| |g| | g|| ggtjd} t| | } |dddf|k|dddf| k@|dddf|k@|dddf| k@}||}t|dkr|ddddftjddd}t || dd}|||ddf<qt |dddfd|d|dddf<t |dddfd|d|dddf<|S)NrArrrrIr) rLrrjrrkrrXrrirr2)rgrVrhZdistorted_keypointsrmrnrZr[r\r]r^r_r`rarZcell_keypointsZpoints_float32rrSrSrTdistort_image_keypointss.  P &**rf) dimensions magnituderGc Cs|jdd\}}||}tj|dftjd}|ddddddgf|ddddf<|ddddddgf|ddddf<|dddddd gf|dddd f<|dddddd gf|ddd df<|d|d}}tj| |d||dfd tj}td|D]} td|D]} || d| df\} } || d|| ddd f| | g7<|| d|| d df| | g7<|| || dddf| | g7<|| || ddf| | g7<q,q|S) aGenerate distorted grid polygons based on input dimensions and magnitude. This function creates a grid of polygons and applies random distortions to the internal vertices, while keeping the boundary vertices fixed. The distortion is applied consistently across shared vertices to avoid gaps or overlaps in the resulting grid. Args: dimensions (np.ndarray): A 3D array of shape (grid_height, grid_width, 4) where each element is [x_min, y_min, x_max, y_max] representing the dimensions of a grid cell. magnitude (int): Maximum pixel-wise displacement for distortion. The actual displacement will be randomly chosen in the range [-magnitude, magnitude]. Returns: np.ndarray: A 2D array of shape (total_cells, 8) where each row represents a distorted polygon as [x1, y1, x2, y1, x2, y2, x1, y2]. The total_cells is equal to grid_height * grid_width. Note: - Only internal grid points are distorted; boundary points remain fixed. - The function ensures consistent distortion across shared vertices of adjacent cells. - The distortion is applied to the following points of each internal cell: * Bottom-right of the cell above and to the left * Bottom-left of the cell above * Top-right of the cell to the left * Top-left of the current cell - Each square represents a cell, and the X marks indicate the coordinates where displacement occurs. +--+--+--+--+ | | | | | +--X--X--X--+ | | | | | +--X--X--X--+ | | | | | +--X--X--X--+ | | | | | +--+--+--+--+ - For each X, the coordinates of the left, right, top, and bottom edges in the four adjacent cells are displaced. Example: >>> dimensions = np.array([[[0, 0, 50, 50], [50, 0, 100, 50]], ... [[0, 50, 50, 100], [50, 50, 100, 100]]]) >>> distorted = generate_distorted_grid_polygons(dimensions, magnitude=10) >>> distorted.shape (4, 8) NrArrrrrIrB)size) rrjrrkrrrandintrir) rgrhZ grid_heightZ grid_widthZ total_cellsZpolygonsZinternal_points_heightZinternal_points_widthZ displacementsrjr=r>rSrSrT generate_distorted_grid_polygonss.0,,,,,((,rn)rgrrrrrzrhrGcCs|tjtjhkr(t||g}t||St|||||}t|||}|dd\} } |d\} } |dddf| | |8<|dddf| | |8<||| } ||| }t|| |fS)NrAr@rrI) rZBORDER_REFLECT_101ZBORDER_REFLECT101rjrshift_keypointsrrvalidate_keypoints)rgrrrrrzrhrBrrurvrCrDrrrSrSrT pad_keypointsWs        rq)rgrhrGcCsZ|dd\}}|dddf|dddf}}|dk||k@|dk@||k@}||S)aValidate keypoints and remove those that fall outside the image boundaries. Args: keypoints (np.ndarray): Array of keypoints with shape (N, M) where N is the number of keypoints and M >= 2. The first two columns represent x and y coordinates. image_shape (tuple[int, int]): Shape of the image as (height, width). Returns: np.ndarray: Array of valid keypoints that fall within the image boundaries. Note: This function only checks the x and y coordinates (first two columns) of the keypoints. Any additional columns (e.g., angle, scale) are preserved for valid keypoints. NrArrIrS)rgrhrurvrXrprFrSrSrTrpxs" rp)rgrBrGcCs0|}|ddddf|dd7<|Sr]r)rgrBshifted_keypointsrSrSrTros$ro)rgrKrhrrGcCsd|d\}}|d\}}t|d|d}t|d|d} t|dd|d} |dd\} } t|| || d d g} t|| }t|| }t| | } t| | } g}t|D]}t|D]}||dd kr||dd kr|}n2||dd kr|}n||dd kr| }n| }t||| ||| d d g}t||}||qqt|}|r`t|| S|S) aGenerate reflected keypoints for the entire reflection grid. This function creates a grid of keypoints by reflecting and shifting the original keypoints. It handles both centered and non-centered grids based on the `center_in_origin` parameter. Args: keypoints (np.ndarray): Original keypoints array of shape (N, 4+), where N is the number of keypoints, and each keypoint is represented by at least 4 values (x, y, angle, scale, ...). grid_dims (dict[str, tuple[int, int]]): A dictionary containing grid dimensions and original position. It should have the following keys: - "grid_shape": tuple[int, int] representing (grid_rows, grid_cols) - "original_position": tuple[int, int] representing (original_row, original_col) image_shape (tuple[int, int]): Shape of the original image as (height, width). center_in_origin (bool, optional): If True, center the grid at the origin. Default is False. Returns: np.ndarray: Array of reflected and shifted keypoints for the entire grid. The shape is (N * grid_rows * grid_cols, 4+), where N is the number of original keypoints. Note: - The function handles keypoint flipping and shifting to create a grid of reflected keypoints. - It preserves the angle and scale information of the keypoints during transformations. - The resulting grid can be either centered at the origin or positioned based on the original grid. rHr@TrLrNrPNrAr)flip_keypointsrjrrorrRr)rgrKrhrrIrJrCrDZkeypoints_hflippedZkeypoints_vflippedZkeypoints_hvflippedrurvrBZ new_keypointsrSrTZcurrent_keypointsrUrrr4rSrSrTrs4         "  r)rgrMrOrhrGcCs|dd\}}|}|rZ||dddf|dddf<|dddf |dddf<|r||dddf|dddf<|dddf |dddf<|S)NrArrIr)rgrMrOrhrurvrrSrSrTrss  rsc@seZdZUded<ded<dS) TranslateDictrwrXrpN__name__ __module__ __qualname____annotations__rSrSrSrTrts rtc@seZdZUded<ded<dS) ShearDictrwrXrpNrurSrSrSrTrzs rzc@seZdZUded<ded<dS) ScaleDictrwrXrpNrurSrSrSrTr{s r{ztuple[float, float]) translateshearr%r#shiftrGcCsvtjj|d|dgd}tjj|d|dft|t|dt|df|d|dfd}|j}|||S)aCreate an affine transformation matrix combining translation, shear, scale, and rotation. This function creates a complex affine transformation by combining multiple transformations in a specific order. The transformations are applied as follows: 1. Shift to top-left: Moves the center of transformation to (0, 0) 2. Apply main transformations: scale, rotation, shear, and translation 3. Shift back to center: Moves the center of transformation back to its original position The order of these transformations is crucial as matrix multiplications are not commutative. Args: translate (TranslateDict): Translation in x and y directions. Keys: 'x', 'y'. Values: translation amounts in pixels. shear (ShearDict): Shear in x and y directions. Keys: 'x', 'y'. Values: shear angles in degrees. scale (ScaleDict): Scale factors for x and y directions. Keys: 'x', 'y'. Values: scale factors (1.0 means no scaling). rotate (float): Rotation angle in degrees. Positive values rotate counter-clockwise. shift (tuple[float, float]): Shift to apply before and after transformations. Typically the image center (width/2, height/2). Returns: skimage.transform.ProjectiveTransform: The resulting affine transformation matrix. Note: - All angle inputs (rotate, shear) are in degrees and are converted to radians internally. - The order of transformations in the AffineTransform is: scale, rotation, shear, translation. - The resulting transformation can be applied to coordinates using the __call__ method. rrI translationrXrp)r%Zrotationr}r)rrSimilarityTransformZAffineTransformrjrr)r|r}r%r#r~Zmatrix_to_topleftZmatrix_transformsZmatrix_to_centerrSrSrT#create_affine_transformation_matrixs& rcCsr|dd\}}tddg|dg||gd|gg}||}t|jddt}t|jddt}||fS)aCompute the bounds of an image after applying an affine transformation. Args: matrix (skimage.transform.ProjectiveTransform): The affine transformation matrix. image_shape (tuple[int, int]): The shape of the image as (height, width). Returns: tuple[np.ndarray, np.ndarray]: A tuple containing: - min_coords: An array with the minimum x and y coordinates. - max_coords: An array with the maximum x and y coordinates. NrArr)rjrfloorrrirDrr)r~rhrmrnrr min_coords max_coordsrSrSrT compute_transformed_image_bounds= s "rztuple[int, ...]z=tuple[skimage.transform.ProjectiveTransform, tuple[int, int]])r~ input_shaperGcCs|dd\}}|dks |dkr>|ttttf|ddfSt|||f\}}|\}}|\}} | |d} ||d} t|tkrt| | |df} nt| | f} tdd| D} | | f}t j j |d}||7}|ttttf| fS)NrArrIcss|]}t|VqdSrV)rD)rrarSrSrTrp sz3compute_affine_warp_output_shape..r) r rrDrrrrjrrtolistrrr)r~rrmrnrrZmincZminrZmaxcZmaxrZ out_heightZ out_widthrZoutput_shape_tuplerZ matrix_to_fitrSrSrT compute_affine_warp_output_shape[ s     r)rhrGcCs(|dd\}}|dd|ddfS)zCalculate the center coordinates if image. Used by images, masks and keypoints. Args: image_shape (tuple[int, int]): The shape of the image. Returns: tuple[float, float]: The center coordinates. NrArrSrhrmrnrSrSrTr>x s cCs |dd\}}|d|dfS)zCalculate the center coordinates for of image for bounding boxes. Args: image_shape (tuple[int, int]): The shape of the image. Returns: tuple[float, float]: The center coordinates. NrArSrrSrSrTr? s z list[float])rhsteps_xsteps_y num_stepsrGcCs |dd\}}||}t|tj}d}t|D]T\} } | |} t| } tt| ||} ||| }t||| | || | <|}q2||}t|tj}d}t|D]T\} } | |}t|} tt|||} ||| }t||| | || | <|}qt||S)aYGenerate a distorted grid for image transformation based on given step sizes. This function creates two 2D arrays (map_x and map_y) that represent a distorted version of the original image grid. These arrays can be used with OpenCV's remap function to apply grid distortion to an image. Args: image_shape (tuple[int, int]): The shape of the image as (height, width). steps_x (list[float]): List of step sizes for the x-axis distortion. The length should be num_steps + 1. Each value represents the relative step size for a segment of the grid in the x direction. steps_y (list[float]): List of step sizes for the y-axis distortion. The length should be num_steps + 1. Each value represents the relative step size for a segment of the grid in the y direction. num_steps (int): The number of steps to divide each axis into. This determines the granularity of the distortion grid. Returns: tuple[np.ndarray, np.ndarray]: A tuple containing two 2D numpy arrays: - map_x: A 2D array of float32 values representing the x-coordinates of the distorted grid. - map_y: A 2D array of float32 values representing the y-coordinates of the distorted grid. Note: - The function generates a grid where each cell can be distorted independently. - The distortion is controlled by the steps_x and steps_y parameters, which determine how much each grid line is shifted. - The resulting map_x and map_y can be used directly with cv2.remap() to apply the distortion to an image. - The distortion is applied smoothly across each grid cell using linear interpolation. Example: >>> image_shape = (100, 100) >>> steps_x = [1.1, 0.9, 1.0, 1.2, 0.95, 1.05] >>> steps_y = [0.9, 1.1, 1.0, 1.1, 0.9, 1.0] >>> num_steps = 5 >>> map_x, map_y = generate_grid(image_shape, steps_x, steps_y, num_steps) >>> distorted_image = cv2.remap(image, map_x, map_y, cv2.INTER_LINEAR) NrAg)rjrrkrdrDrZlinspaceZmeshgrid)rhrrrrmrnx_steprprevidxsteprXstartendcury_steprrprSrSrTr@ s,/  zdict[str, np.ndarray])rhrx_stepsy_stepsrGc Cs|\}}||}t||d|||}|d||9<||}t||d|||} |d| |9<|t||} |t||} t|| t|}t|| t|}||dS)NrIr)rr)rrrrjrsum) rhrrrrmrnrZ last_x_steprZ last_y_stepZtxtyrSrSrTnormalize_grid_distortion_steps sr)npartsrGcs,t||\tfddt|DS)aGenerates an array of nearly equal integer intervals that sum up to `n`. This function divides the number `n` into `parts` nearly equal parts. It ensures that the sum of all parts equals `n`, and the difference between any two parts is at most one. This is useful for distributing a total amount into nearly equal discrete parts. Args: n (int): The total value to be split. parts (int): The number of parts to split into. Returns: np.ndarray: An array of integers where each integer represents the size of a part. Example: >>> almost_equal_intervals(20, 3) array([7, 7, 6]) # Splits 20 into three parts: 7, 7, and 6 >>> almost_equal_intervals(16, 4) array([4, 4, 4, 4]) # Splits 16 into four equal parts cs g|]}|krdnqSrIrS)rrZ part_size remainderrSrTr sz*almost_equal_intervals..)divmodrjrr)rrrSrrTalmost_equal_intervals srznp.random.RandomState | None)rk divisionsr;rGcCs,t||}tj||d}tt|ddS)aGenerate shuffled splits for a given dimension size and number of divisions. Args: size (int): Total size of the dimension (height or width). divisions (int): Number of divisions (rows or columns). random_state (Optional[np.random.RandomState]): Seed for the random number generator for reproducibility. Returns: np.ndarray: Cumulative edges of the shuffled intervals. r;r)rrshufflerjinsertZcumsum)rkrr;Z intervalsrSrSrTgenerate_shuffled_splits s r)rhgridr;rGcsZ|\}t|d|d|t|d|d|fddt|D}tj|tjdS)aSplits an image shape into a uniform grid specified by the grid dimensions. Args: image_shape (tuple[int, int]): The shape of the image as (height, width). grid (tuple[int, int]): The grid size as (rows, columns). random_state (Optional[np.random.RandomState]): The random state to use for shuffling the splits. If None, the splits are not shuffled. Returns: np.ndarray: An array containing the tiles' coordinates in the format (start_y, start_x, end_y, end_x). Note: The function uses `generate_shuffled_splits` to generate the splits for the height and width of the image. The splits are then used to calculate the coordinates of the tiles. rrIc s>g|]6}tD](}|||d|dfqqSr)r)rrrmZ height_splitsZn_colsZ width_splitsrSrTr< s z&split_uniform_grid..r)rrrjrZint16)rhrr;Zn_rowsZtilesrSrrTsplit_uniform_grid" sr)rhr%r;rGcCs|dd\}}tjd|d|d}tt|d}d|d|d<d|d|d<d|d|d<|dddf|9<|ddd f|9<|S) NrAr)rrArg{Gz?r|r)rBrIrI)rnormalrjmodabs)rhr%r;rmrnrrSrSrTgenerate_perspective_pointsE sr)ptsrGcCstt|ddd}|dd}|dd}|dd|ddkrP|\}}n|\}}|dd|ddkrz|\}}n|\}}tj||||gtjdS)NcSs|dS)NrrSrWrSrSrTrY] rZzorder_points..)keyrArrIr)rjrsortedrk)rr*r+tlbltrbrrSrSrT order_points\ s    rztuple[np.ndarray, int, int])rrGc Cs|\}}}}d ddddddd}t||||||}t||||||}t|t|}}tjddg|dg||gd|ggtjd }t||} | ||fS) NrArCrDrw)dim1dim2min_sizerGcSstt||d}||kr||d}|||k|7<|||k|8<|||k|8<|||k|7<|}|Sr])rjrr)rrrrkZ step_sizerSrSrTadjust_dimensionq s z4compute_perspective_params..adjust_dimensionrr)rA)rrDrjrrkrrX) rZtop_leftZ top_rightZ bottom_rightZ bottom_leftrrrr<r~rSrSrTcompute_perspective_paramsn s  ( r)r~rrGc Cs|dd\}}tjddg|dg||gd|ggtjd}tt|g|d}||jddd8}tj|dd}t||}|jdd\}}|t |t |fS)NrArrT)rZkeepdims)Zdecimalsr) rjrrkrrrZaroundrXrrD) r~rrmrnZrectr<Zmatrix_expandedrrrSrSrTexpand_transform s( r)N)F)NN)N)F)FFr)F)FFr)N)N)N) __future__rrtypingrrrrrrr rZnumpyrjZskimage.transformrZalbucorer r r r rrZalbumentationsrZ"albumentations.augmentations.utilsrrZalbumentations.core.bbox_utilsrrrrZalbumentations.core.typesrrrrrrr__all__rrMrNr6r4r7r5r#r2r3r$r%rr&r'r(r)rr*rr+rr,rrrrrr-r.rrr/r rr1rr0rr:r<rr8r;r=r r9r!rr,r"rrr r?rErrArrrQrbrerfrnrqrprorrsrtrzr{rrrr>r?r@rrrrrrrrrSrSrSrTs $  $ '*--05( !  N 6H(7O72W =1! "$'AC*V  H>  I"&