albumentations.augmentations.geometric.functional

Adjust padding values based on desired position.

Parameters

Generates 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.

Parameters

Returns

• np.ndarray: An array of integers where each integer represents the size of a part.

Examples

>>> 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

Apply affine transformation to a set of points. This function handles potential division by zero by replacing zero values in the homogeneous coordinate with a small epsilon value.

Parameters

Returns

• np.ndarray: Transformed points with shape (N, 2).

Distort bounding boxes based on a generated mesh. This function applies a perspective transformation to each bounding box based on the provided generated mesh. It ensures that the bounding boxes are clipped to the image boundaries after transformation.

Parameters

Returns

• np.ndarray: The distorted bounding boxes.

Apply 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.

Parameters

Returns

• np.ndarray: Transformed and normalized bounding boxes

Apply 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.

Parameters

Returns

• np.ndarray: An array of transformed bounding boxes with the same shape as the input.

Notes

- 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.

Apply 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.

Parameters

Returns

• np.ndarray: An array of transformed bounding boxes with the same shape as the input.

Examples

>>> bboxes = np.array([[10, 10, 20, 20, 1], [30, 30, 40, 40, 2]])  # Two boxes with class labels
>>> matrix = np.array([[2, 0, 5], [0, 2, 5], [0, 0, 1]])  # Scale by 2 and translate by (5, 5)
>>> transformed_bboxes = bboxes_affine_largest_box(bboxes, matrix)
>>> print(transformed_bboxes)
[[ 25.  25.  45.  45.   1.]
 [ 65.  65.  85.  85.   2.]]

Notes

- 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.

Applies a `D_4` symmetry group transformation to a bounding box. The function transforms a bounding box according to the specified group member from the `D_4` group. These transformations include rotations and reflections, specified to work on an image's bounding box given its dimensions. Args: bboxes (np.ndarray): 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, ...). group_member (Literal["e", "r90", "r180", "r270", "v", "hvt", "h", "t"]): A string identifier for the `D_4` group transformation to apply. Returns: BoxInternalType: The transformed bounding box. Raises: ValueError: If an invalid group member is specified.

Parameters

Returns

• BoxInternalType: The transformed bounding box.

Shuffle bounding boxes according to grid mapping.

Parameters

Returns

• np.ndarray: Shuffled bounding boxes

Flip bounding boxes horizontally.

Parameters

Returns

• np.ndarray: Horizontally flipped bounding boxes

Apply morphology to bounding boxes. This function applies morphology to bounding boxes by first converting the bounding boxes to a mask and then applying the morphology to the mask.

Parameters

Returns

• np.ndarray: The morphology applied to the bounding boxes.

Apply a piecewise affine transformation to bounding boxes. This function applies a piecewise affine transformation to the bounding boxes of an image. It first converts the bounding boxes to masks, then applies the transformation, and finally converts the transformed masks back to bounding boxes.

Parameters

Returns

• np.ndarray: The transformed bounding boxes.

Rotates bounding boxes by 90 degrees CCW (see np.rot90)

Parameters

Returns

• np.ndarray: Rotated bounding boxes

Transpose bounding boxes along the main diagonal.

Parameters

Returns

• np.ndarray: Transposed bounding boxes

Flip bounding boxes vertically.

Parameters

Returns

• np.ndarray: Vertically flipped bounding boxes

Calculate the necessary padding for an affine transformation to avoid empty spaces.

Parameters

Calculate the center coordinates if image. Used by images, masks and keypoints.

Parameters

Returns

• tuple[float, float]: center_x, center_y

Calculate the center coordinates for of image for bounding boxes.

Parameters

Returns

• tuple[float, float]: center_x, center_y

Compute the output shape of an affine warp. This function computes the output shape of an affine warp based on the input matrix and input shape. It calculates the transformed image bounds and then determines the output shape based on the input shape.

Parameters

Returns

• tuple[np.ndarray, tuple[int, int]]: A tuple containing:

Compute pairwise distances between two sets of points.

Parameters

Returns

• np.ndarray: Matrix of pairwise distances with shape (N, M)

Compute perspective transformation parameters. This function computes the perspective transformation parameters for a given set of points. It adjusts the points to ensure that the transformed image retains its original dimensions.

Parameters

Returns

• tuple[np.ndarray, int, int]: The perspective transformation parameters and the maximum

Compute Thin Plate Spline weights.

Parameters

Returns

• tuple[np.ndarray, np.ndarray]: Tuple of (nonlinear_weights, affine_weights)

Compute the bounds of an image after applying an affine transformation.

Parameters

Returns

• tuple[np.ndarray, np.ndarray]: A tuple containing:

Copy and make border with value extension. This function copies and makes border with value extension. It is used to pad an image with a given value.

Parameters

Returns

• np.ndarray: The padded image.

Create an affine transformation matrix combining translation, shear, scale, and rotation.

Parameters

Returns

• np.ndarray: The resulting 3x3 affine transformation matrix.

Create maps for piecewise affine transformation using OpenCV's remap function. This function creates maps for piecewise affine transformation using OpenCV's remap function. It generates the control points for the transformation, then uses the remap function to create the transformation maps.

Parameters

Returns

• tuple[np.ndarray | None, np.ndarray | None]: The transformation maps.

Groups tiles by their shape and stores the indices for each shape.

Parameters

Applies 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

Returns

• np.ndarray: The transformed image array.

Apply dilation to an image. This function applies dilation to an image using the cv2.dilate function.

Parameters

Returns

• np.ndarray: The dilated image.

Apply 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.

Parameters

Returns

• np.ndarray: The distorted image with the same shape and dtype as the input image.

Examples

>>> 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)

Notes

- 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.

Distort keypoints based on a generated mesh. This function applies a perspective transformation to each keypoint based on the provided generated mesh. It ensures that the keypoints are clipped to the image boundaries after transformation.

Parameters

Returns

• np.ndarray: The distorted keypoints.

Apply erosion to an image. This function applies erosion to an image using the cv2.erode function.

Parameters

Returns

• np.ndarray: The eroded image.

Expand a transformation matrix to include padding. This function expands a transformation matrix to include padding, ensuring that the transformed image retains its original dimensions. It first calculates the destination points of the transformed image, then adjusts the matrix to include padding, and finally returns the expanded matrix and the maximum dimensions of the transformed image.

Parameters

Returns

• tuple[np.ndarray, int, int]: The expanded matrix and the maximum dimensions of the transformed image.

Extend value to a sequence of floats. This function extends a value to a sequence of floats. It is used to pad an image with a given value.

Parameters

Returns

• Sequence[float]: The extended value.

Determine if a valid keypoint can be found at the given position.

Parameters

Flip bounding boxes horizontally and/or vertically.

Parameters

Returns

• np.ndarray: Flipped bounding boxes.

Flip keypoints horizontally or vertically. This function flips keypoints horizontally or vertically based on the provided parameters. It also flips the angle of the keypoints when flipping horizontally.

Parameters

Returns

• np.ndarray: The flipped keypoints.

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.

Parameters

Returns

• np.ndarray: A 2D numpy array of shape (nb_keypoints, 2) containing the (x, y) coordinates

Examples

>>> 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)

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.

Generate control points for TPS transformation.

Parameters

Returns

• np.ndarray: Control points with shape (N, 2)

Generate displacement fields for elastic transform. This function generates displacement fields for elastic transform based on the provided parameters. It generates noise either from a Gaussian or uniform distribution and normalizes it to the range [-1, 1].

Parameters

Returns

• tuple[np.ndarray, np.ndarray]: A tuple containing:

Generate 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.

Parameters

Returns

• np.ndarray: A 2D array of shape (total_cells, 8) where each row represents a distorted polygon

Examples

>>> 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)

Notes

- 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.

Generate 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.

Parameters

Returns

• tuple[np.ndarray, np.ndarray]: A tuple containing two 2D numpy arrays:

Examples

>>> 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)

Notes

- 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.

Generate inverse mapping for strong distortions.

Parameters

Generate perspective points for a given image shape and scale. This function generates perspective points for a given image shape and scale. It uses a normal distribution to generate the points, and then modulates them to be within the image bounds.

Parameters

Returns

• np.ndarray: The perspective points.

Generate reflected bounding boxes for the entire reflection grid.

Parameters

Returns

• np.ndarray: Array of reflected and shifted bounding boxes for the entire grid.

Generate 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.

Parameters

Returns

• np.ndarray: Array of reflected and shifted keypoints for the entire grid. The shape is

Notes

- 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.

Generate shuffled splits for a given dimension size and number of divisions.

Parameters

Returns

• np.ndarray: Cumulative edges of the shuffled intervals.

Generate distortion maps using camera matrix model.

Parameters

Returns

• tuple[np.ndarray, np.ndarray]: Tuple of (map_x, map_y) distortion maps

Calculate padding for a single dimension.

Parameters

Returns

• tuple[int, int]: (pad_before, pad_after)

Generate distortion maps using fisheye model.

Parameters

Returns

• tuple[np.ndarray, np.ndarray]: Tuple of (map_x, map_y) distortion maps

Calculate the dimensions of the grid needed for reflection padding and the position of the original image.

Parameters

Returns

• dict[str, tuple[int, int]]: A dictionary containing:

Calculate padding parameters based on target dimensions.

Parameters

Returns

• tuple[int, int, int, int]: (pad_top, pad_bottom, pad_left, pad_right)

Check if the given matrix is an identity matrix.

Parameters

Returns

• bool: True if the matrix is an identity matrix, False otherwise.

Validate if a component meets the minimum requirements.

Parameters

Apply 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.

Parameters

Returns

• np.ndarray: Transformed keypoints array with the same shape as input.

Examples

>>> keypoints = np.array([[100, 100, 0, 1]])
>>> matrix = np.array([[1.5, 0, 10], [0, 1.2, 20]])
>>> scale = {'x': 1.5, 'y': 1.2}
>>> transformed_keypoints = keypoints_affine(keypoints, matrix, (480, 640), scale, cv2.BORDER_REFLECT_101)

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.

Applies 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

Returns

• KeypointInternalType: The transformed keypoint.

Flip keypoints horizontally.

Parameters

Returns

• np.ndarray: Horizontally flipped keypoints

Rotate keypoints by 90 degrees counter-clockwise (CCW) a specified number of times.

Parameters

Returns

• np.ndarray: The rotated keypoints with the same shape as the input.

Scale keypoints by given factors.

Parameters

Returns

• np.ndarray: Scaled keypoints

Transpose keypoints along the main diagonal.

Parameters

Returns

• np.ndarray: Transposed keypoints

Flip keypoints vertically.

Parameters

Returns

• np.ndarray: Vertically flipped keypoints

Apply morphology to an image. This function applies morphology to an image using the cv2.morphologyEx function.

Parameters

Returns

• np.ndarray: The morphology applied to the image.

Normalize the grid distortion steps. This function normalizes the grid distortion steps, ensuring that the distortion never leaves the image bounds. It compensates for smaller last steps in the source image and normalizes the steps such that the distortion never leaves the image bounds.

Parameters

Returns

• dict[str, np.ndarray]: A dictionary containing the normalized step sizes for the x and y axes.

Order points in a clockwise manner. This function orders the points in a clockwise manner, ensuring that the points are in the correct order for perspective transformation.

Parameters

Returns

• np.ndarray: The ordered points.

Pad an image to ensure minimum dimensions. This function adds padding to an image if its dimensions are smaller than the specified minimum dimensions. Padding is added evenly on all sides.

Parameters

Returns

• np.ndarray: Padded image with dimensions at least (min_height, min_width).

Pad bounding boxes by a given amount. This function pads bounding boxes by a given amount. It handles both reflection and padding.

Parameters

Returns

• np.ndarray: The padded bounding boxes.

Pad a batch of images with explicitly defined padding on each side. This function adds specified amounts of padding to each side of the image for each image in the batch.

Parameters

Returns

• np.ndarray: Padded batch of images.

Pad keypoints by a given amount. This function pads keypoints by a given amount. It handles both reflection and padding.

Parameters

Returns

• np.ndarray: The padded keypoints.

Pad an image with explicitly defined padding on each side. This function adds specified amounts of padding to each side of the image.

Parameters

Returns

• np.ndarray: Padded image.

Apply perspective transformation to an image. This function warps an image according to a perspective transformation matrix. It can either maintain the original dimensions or use the specified max dimensions.

Parameters

Returns

• np.ndarray: Perspective-transformed image.

Applies 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.

Parameters

Returns

• np.ndarray: An array of transformed bounding boxes with the same shape as input.

Examples

>>> 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)

Notes

- 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.

Apply perspective transformation to keypoints.

Parameters

Returns

• np.ndarray: Transformed keypoints array with same shape as input

Remap an image according to given coordinate maps. This function applies a generic geometrical transformation using mapping functions that specify the position of each pixel in the output image.

Parameters

Returns

• np.ndarray: Remapped image with the same shape as the input image.

Remap bounding boxes using displacement maps.

Parameters

Transform keypoints using coordinate mapping functions. This function applies the inverse of the mapping defined by map_x and map_y to keypoint coordinates. The inverse mapping is necessary because the mapping functions define how pixels move from the source to the destination image, while keypoints need to be transformed from the destination back to the source.

Parameters

Returns

• np.ndarray: Transformed keypoints with the same shape as the input keypoints.

Remap keypoints using mask and cv2.remap method.

Parameters

Resize an image to the specified dimensions. This function resizes an input image to the target shape using the specified interpolation method. If the image is already the target size, it is returned unchanged.

Parameters

Returns

• np.ndarray: Resized image with shape target_shape + original channel dimensions.

Rotate an image 90 degrees counterclockwise.

Parameters

Returns

• np.ndarray: The rotated image.

Args: matrix (np.ndarray): Rotation matrix y_up (bool): is Y axis looks up or down

Parameters

Scale an image by a factor while preserving aspect ratio. This function scales both height and width dimensions of the image by the same factor.

Parameters

Returns

• np.ndarray: Scaled image.

Shift bounding boxes by a given vector.

Parameters

Returns

• np.ndarray: Shifted bounding boxes with the same shape as input.

Shift keypoints by a given shift vector. This function shifts the keypoints by a given shift vector. It only shifts the x, y and z coordinates of the keypoints.

Parameters

Returns

• np.ndarray: The shifted keypoints.

Shuffles indices within each group of similar shapes and creates a list where each index points to the index of the tile it should be mapped to.

Parameters

Returns

• list[int]: A list where each index is mapped to the new index of the tile after shuffling.

Splits an image shape into a uniform grid specified by the grid dimensions.

Parameters

Returns

• np.ndarray: An array containing the tiles' coordinates in the format (start_y, start_x, end_y, end_x).

Notes

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.

Swap tiles on the image according to the new format.

Parameters

Returns

• np.ndarray: Output image with tiles swapped according to the random shuffle.

Swap the positions of keypoints based on a tile mapping. This function takes a set of keypoints and repositions them according to a mapping of tile swaps. Keypoints are moved from their original tiles to new positions in the swapped tiles.

Parameters

Returns

• np.ndarray: A 2D numpy array of the same shape as the input keypoints, containing the new positions

Notes

- Keypoints that do not fall within any tile will remain unchanged. - The function assumes that the tiles do not overlap and cover the entire image space.

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.

Parameters

Returns

• np.ndarray: A float32 array of shape (H, W, N) containing ``N`` distance maps for ``N``

Apply TPS transformation with consistent types.

Parameters

Transposes the first two dimensions of an array of any dimensionality. Retains the order of any additional dimensions.

Parameters

Returns

• np.ndarray: Transposed array.

Validate bounding boxes and remove invalid ones.

Parameters

Returns

• np.ndarray: Array of valid bounding boxes, potentially with fewer boxes than the input.

Examples

>>> 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]]

Validate and process `if_not_found_coords` parameter.

Parameters

Validate keypoints and remove those that fall outside the image boundaries.

Parameters

Returns

• np.ndarray: Array of valid keypoints that fall within the image boundaries.

Notes

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.

Perform horizontal flip on a volume (numpy array). Flips the volume along the width axis (axis=2). Handles inputs with shapes (D, H, W) or (D, H, W, C).

Parameters

Returns

• np.ndarray: Horizontally flipped volume.

Rotate a volume 90 degrees counter-clockwise multiple times. Rotates the volume in the height-width plane (axes 1 and 2). Handles inputs with shapes (D, H, W) or (D, H, W, C).

Parameters

Returns

• np.ndarray: Rotated volume.

Perform vertical flip on a volume (numpy array). Flips the volume along the height axis (axis=1). Handles inputs with shapes (D, H, W) or (D, H, W, C).

Parameters

Returns

• np.ndarray: Vertically flipped volume.

Perform horizontal flip on a batch of volumes (numpy array). Flips the volumes along the width axis (axis=3). Handles inputs with shapes (B, D, H, W) or (B, D, H, W, C).

Parameters

Returns

• np.ndarray: Horizontally flipped batch of volumes.

Rotate a batch of volumes 90 degrees counter-clockwise multiple times. Rotates the volumes in the height-width plane (axes 2 and 3). Handles inputs with shapes (B, D, H, W) or (B, D, H, W, C).

Parameters

Returns

• np.ndarray: Rotated batch of volumes.

Perform vertical flip on a batch of volumes (numpy array). Flips the volumes along the height axis (axis=2). Handles inputs with shapes (B, D, H, W) or (B, D, H, W, C).

Parameters

Returns

• np.ndarray: Vertically flipped batch of volumes.

Apply an affine transformation to an image. This function transforms an image using the specified affine transformation matrix. If the transformation matrix is an identity matrix, the original image is returned.

Parameters

Returns

• np.ndarray: Affine-transformed image with dimensions specified by output_shape.

Warp affine with value extension. This function warps an image with a given affine transformation matrix. It also extends the value to a sequence of floats.

Parameters

Returns

• np.ndarray: The warped image.