Operation tier list

The tiers hold the different operations that are available in CLIc. These operations are grouped by their complexity, following the rules that a function in tier N implement a function from tier N-1.

tier1

namespace tier1

Namespace container for all functions of tier 1 category Tier 1 functions are advanced functions that may rely on previous tier functions.

absolute

Computes the absolute value of every individual pixel x in a given image.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image to be processed. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto absolute_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

add_images_weighted

Calculates the sum of pairs of pixels x and y from images X and Y weighted with factors a and b.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to add. [const Array::Pointer &]
param src1:: Second image to add. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]
param factor1:: Multiplication factor of each pixel of src0 before adding it. [float ( = 1 )]
param factor2:: Multiplication factor of each pixel of src1 before adding it. [float ( = 1 )]

return:: Array::Pointer

auto add_images_weighted_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst, float factor1, float factor2) -> Array::Pointer

add_image_and_scalar

Adds a scalar value s to all pixels x of a given image X.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param scalar:: Scalar number to add to all pixels. [float ( = 1 )]

return:: Array::Pointer

auto add_image_and_scalar_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

binary_and

Computes a binary image (containing pixel values 0 and 1) from two images X and Y by connecting pairs of pixels x and y with the binary AND operator &. All pixel values except 0 in the input images are interpreted as 1.

Note

‘combine’, ‘binary processing’, ‘in assistant’, ‘combine labels’, ‘label processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First binary input image to be processed. [const Array::Pointer &]
param src1:: Second binary input image to be processed. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_and_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

binary_edge_detection

Determines pixels/voxels which are on the surface of binary objects and sets only them to 1 in the destination image. All other pixels are set to 0.

Note

‘binary processing’, ‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Binary input image where edges will be searched. [const Array::Pointer &]
param dst:: Output image where edge pixels will be 1. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_edge_detection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

binary_not

Computes a binary image (containing pixel values 0 and 1) from an image X by negating its pixel values x using the binary NOT operator ! All pixel values except 0 in the input image are interpreted as 1.

Note

‘binary processing’, ‘filter’, ‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Binary input image to be inverted. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_not_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

binary_or

Computes a binary image (containing pixel values 0 and 1) from two images X and Y by connecting pairs of pixels x and y with the binary OR operator |. All pixel values except 0 in the input images are interpreted as 1.

Note

‘combine’, ‘binary processing’, ‘in assistant’, ‘combine labels’, ‘label processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First binary input image to be processed. [const Array::Pointer &]
param src1:: Second binary input image to be processed. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_or_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

binary_subtract

Subtracts one binary image from another.

Note

‘combine’, ‘binary processing’, ‘in assistant’, ‘combine labels’, ‘label processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First binary input image to be processed. [const Array::Pointer &]
param src1:: Second binary input image to be subtracted from the first. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_subtract_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

binary_xor

Computes a binary image (containing pixel values 0 and 1) from two images X and Y by connecting pairs of pixels x and y with the binary operators AND &, OR | and NOT ! implementing the XOR operator. All pixel values except 0 in the input images are interpreted as 1.

Note

‘combine’, ‘binary processing’, ‘in assistant’, ‘combine labels’, ‘label processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First binary input image to be processed. [const Array::Pointer &]
param src1:: Second binary input image to be processed. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_xor_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

binary_supinf

Compute the maximum of the erosion with plannar structuring elements. Warning: This operation is only supported BINARY data type images.

Note

‘filter’, ‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The binary input image to be processed. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_supinf_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

binary_infsup

Compute the minimum of the dilation with plannar structuring elements. Warning: This operation is only supported BINARY data type images.

Note

‘filter’, ‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The binary input image to be processed. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto binary_infsup_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

block_enumerate

Enumerates pixels with value 1 in a onedimensional image For example handing over the image [0, 1, 1, 0, 1, 0, 1, 1] would be processed to an image [0, 1, 2, 0, 3, 0, 4, 5] This functionality is important in connected component neccessary (see also sum_reduction_x). In the above example, with blocksize 4, that would be the sum array: [2, 3] labeling. Processing is accelerated by paralellization in blocks. Therefore, handing over precomputed block sums is Note that the block size when calling this function and sum_reduction must be identical

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: input binary vector image [const Array::Pointer &]
param src1:: precomputed sums of blocks [const Array::Pointer &]
param dst:: output enumerated vector image [Array::Pointer ( = None )]
param blocksize:: blocksize; must correspond correctly to how the [int ( = 256 )]

return:: Array::Pointer

auto block_enumerate_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst, int blocksize) -> Array::Pointer

convolve

Convolve the image with a given kernel image. It is recommended that the kernel image has an odd size in X, Y and Z.

Note

‘filter’, ‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto convolve_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

copy

Copies an image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to copy. [const Array::Pointer &]
param dst:: Output copy image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto copy_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

copy_slice

This method has two purposes: It copies a 2D image to a given slice_index z position in a 3D image stack or It copies a given slice_index at position z in an image stack to a 2D image. The first case is only available via ImageJ macro. If you are using it, it is recommended that the target 3D image already preexists in GPU memory before calling this method. Otherwise, CLIJ create the image stack with z planes.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to copy from. [const Array::Pointer &]
param dst:: Output copy image slice_index. [Array::Pointer ( = None )]
param slice_index:: Index of the slice to copy. [int ( = 0 )]

return:: Array::Pointer

auto copy_slice_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int slice_index) -> Array::Pointer

copy_horizontal_slice

This method has two purposes: It copies a 2D image to a given slice_index y position in a 3D image stack or It copies a given slice_index at position y in an image stack to a 2D image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to copy from. [const Array::Pointer &]
param dst:: Output copy image slice_index. [Array::Pointer ( = None )]
param slice_index:: Index of the slice to copy. [int ( = 0 )]

return:: Array::Pointer

auto copy_horizontal_slice_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int slice_index) -> Array::Pointer

copy_vertical_slice

This method has two purposes: It copies a 2D image to a given slice_index x position in a 3D image stack or It copies a given slice_index at position x in an image stack to a 2D image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to copy from. [const Array::Pointer &]
param dst:: Output copy image slice_index. [Array::Pointer ( = None )]
param slice_index:: Index of the slice to copy. [int ( = 0 )]

return:: Array::Pointer

auto copy_vertical_slice_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int slice_index) -> Array::Pointer

crop

Crops a given substack out of a given image stack. Note: If the destination image preexists already, it will be overwritten and keep it’s dimensions.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param start_x:: Starting index coordicante x. [int ( = 0 )]
param start_y:: Starting index coordicante y. [int ( = 0 )]
param start_z:: Starting index coordicante z. [int ( = 0 )]
param width:: Width size of the region to crop. [int ( = 1 )]
param height:: Height size of the region to crop. [int ( = 1 )]
param depth:: Depth size of the region to crop. [int ( = 1 )]

return:: Array::Pointer

auto crop_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int start_x, int start_y, int start_z, int width, int height, int depth) -> Array::Pointer

cubic_root

Computes the cubic root of each pixel.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto cubic_root_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

detect_label_edges

Takes a labelmap and returns an image where all pixels on label edges are set to 1 and all other pixels to 0.

Note

‘binarize’, ‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto detect_label_edges_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

dilation

Computes the dilation operation between an image and a structuring element. The operation is applied in grayscale if the image is in grayscale. The structuring element is a binary image with pixel values 0 and 1, and must have the same dimensionality as the image (3D is the image is 3D, 2D if the image is 2D).

Deprecated:: This function is deprecated. Consider using erode() instead.

Note

‘binary processing’ ‘filter’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param footprint:: Structuring element to use for the operation. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto dilation_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &footprint, Array::Pointer dst) -> Array::Pointer

dilate_box

Computes a binary image with pixel values 0 and 1 containing the binary dilation of a given input image. The dilation takes the Moore neighborhood (8 pixels in 2D and 26 pixels in 3d) into account. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1. This method is comparable to the ‘Dilate’ menu in ImageJ in case it is applied to a 2D image. The only difference is that the output image contains values 0 and 1 instead of 0 and 255.

Deprecated:: This function is deprecated. Consider using dilate() instead.

Note

‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. Input image to process. [const Array::Pointer &]
param dst:: Output result image. Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto dilate_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

dilate_sphere

Computes a binary image with pixel values 0 and 1 containing the binary dilation of a given input image. The dilation takes the von Neumann neighborhood (4 pixels in 2D and 6 pixels in 3d) into account. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1.

Deprecated:: This function is deprecated. Consider using dilate() instead.

Note

‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. Input image to process. [const Array::Pointer &]
param dst:: Output result image. Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto dilate_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

binary_dilate

Computes a binary image with pixel values 0 and 1 containing the binary dilation of a given input image. The dilation apply the Moore neighborhood (8 pixels in 2D and 26 pixels in 3d) for the “box” connectivity and the von Neumann neighborhood (4 pixels in 2D and 6 pixels in 3d) for a “sphere” connectivity. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1.

For a more flexible dilation with arbitrary shapes, use dilation() instead.

Note

‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. Input image to process. [const Array::Pointer &]
param dst:: Output result image. Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius of sphere or box structuring element in X. [float ( = 1 )]
param radius_y:: Radius of sphere or box structuring element in Y. [float ( = 1 )]
param radius_z:: Radius of sphere or box structuring element in Z. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere”. [std::string ( = “box” )]

return:: Array::Pointer

auto binary_dilate_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

divide_images

Divides two images X and Y by each other pixel wise.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param dividend:: Input image to process. [const Array::Pointer &]
param divisor:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto divide_images_func(const Device::Pointer &device, const Array::Pointer &dividend, const Array::Pointer &divisor, Array::Pointer dst) -> Array::Pointer

divide_scalar_by_image

Divides a scalar by an image pixel by pixel.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar value to divide the image with. [float ( = 0 )]

return:: Array::Pointer

auto divide_scalar_by_image_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

equal

Determines if two images A and B equal pixel wise.

Note

‘combine’, ‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First image to be compared with. [const Array::Pointer &]
param src1:: Second image to be compared with the first. [const Array::Pointer &]
param dst:: Output binary image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto equal_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

equal_constant

Determines if an image A and a constant b are equal.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input omage where every pixel is compared to the constant. [const Array::Pointer &]
param dst:: Output binary image. [Array::Pointer ( = None )]
param scalar:: Scalar value to compare pixel with. [float ( = 0 )]

return:: Array::Pointer

auto equal_constant_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

erosion

Computes the erosion operation between an image and a structuring element. The operation is applied in grayscale if the image is in grayscale. The structuring element is a binary image with pixel values 0 and 1, and must have the same dimensionality as the image (3D is the image is 3D, 2D if the image is 2D).

Note

‘binary processing’ ‘filter’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param footprint:: Structuring element to use for the operation. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto erosion_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &footprint, Array::Pointer dst) -> Array::Pointer

erode_box

Computes a binary image with pixel values 0 and 1 containing the binary erosion of a given input image. The erosion takes the Moore neighborhood (8 pixels in 2D and 26 pixels in 3d) into account. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1. This method is comparable to the ‘Erode’ menu in ImageJ in case it is applied to a 2D image. The only difference is that the output image contains values 0 and 1 instead of 0 and 255.

Deprecated:: This function is deprecated. Consider using erode() instead.

Note

‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto erode_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

erode_sphere

Computes a binary image with pixel values 0 and 1 containing the binary erosion of a given input image. The erosion takes the von Neumann neighborhood (4 pixels in 2D and 6 pixels in 3d) into account. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1.

Deprecated:: This function is deprecated. Consider using erode() instead.

Note

‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto erode_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

binary_erode

Computes a binary image with pixel values 0 and 1 containing the binary erosion of a given input image. The erosion apply the Moore neighborhood (8 pixels in 2D and 26 pixels in 3d) for the “box” connectivity and the von Neumann neighborhood (4 pixels in 2D and 6 pixels in 3d) for a “sphere” connectivity. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1.

For a more flexible erosion with arbitrary shapes, use erosion() instead.

Note

‘binary processing’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius of the eroding sphere or box structuring element in X. [float ( = 1 )]
param radius_y:: Radius of the eroding sphere or box structuring element in Y. [float ( = 1 )]
param radius_z:: Radius of the eroding sphere or box structuring element in Z. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere”. [std::string ( = “box” )]

return:: Array::Pointer

auto binary_erode_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

exponential

Computes base exponential of all pixels values. f(x) = exp(x) Author(s): Peter Haub, Robert Haase

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto exponential_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

flip

Flips an image in X, Y and/or Z direction depending on boolean flags.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param flip_x:: Flip along the x axis if true. [bool ( = True )]
param flip_y:: Flip along the y axis if true. [bool ( = True )]
param flip_z:: Flip along the z axis if true. [bool ( = True )]

return:: Array::Pointer

auto flip_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, bool flip_x, bool flip_y, bool flip_z) -> Array::Pointer

gaussian_blur

Computes the Gaussian blurred image of an image given sigma values in X, Y and Z. Thus, the filter kernel can have nonisotropic shape. The implementation is done separable. In case a sigma equals zero, the direction is not blurred.

Note

‘filter’, ‘denoise’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param sigma_x:: Sigma value along the x axis. [float ( = 0 )]
param sigma_y:: Sigma value along the y axis. [float ( = 0 )]
param sigma_z:: Sigma value along the z axis. [float ( = 0 )]

return:: Array::Pointer

auto gaussian_blur_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float sigma_x, float sigma_y, float sigma_z) -> Array::Pointer

generate_distance_matrix

Computes the distance between all point coordinates given in two point lists. Takes two images containing pointlists (dimensionality n * d, n: number of points and d: dimensionality) and builds up a matrix containing the distances between these points. Convention: Given two point lists with dimensionality n * d and m * d, the distance matrix will be of size(n + 1) * (m + 1). The first row and column contain zeros. They represent the distance of the (see generateTouchMatrix). Thus, one can threshold a distance matrix to generate a touch matrix out of it for drawing objects to a theoretical background object. In that way, distance matrices are of the same size as touch matrices meshes.

param device:: Device to perform the operation on. [const Device::Pointer &]
param coordinate_list1:: First coordinate list to process. [const Array::Pointer &]
param coordinate_list2:: Second coordinate list to process. [const Array::Pointer &]
param distance_matrix_destination:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto generate_distance_matrix_func(const Device::Pointer &device, const Array::Pointer &coordinate_list1, const Array::Pointer &coordinate_list2, Array::Pointer distance_matrix_destination) -> Array::Pointer

gradient_x

Computes the gradient of gray values along X. Assuming a, b and c are three adjacent pixels in X direction. In the target image will be saved as:

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto gradient_x_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

gradient_y

Computes the gradient of gray values along Y. Assuming a, b and c are three adjacent pixels in Y direction. In the target image will be saved as:

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto gradient_y_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

gradient_z

Computes the gradient of gray values along Z. Assuming a, b and c are three adjacent pixels in Z direction. In the target image will be saved as:

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto gradient_z_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

greater

Determines if two images A and B greater pixel wise. f(a, b) = 1 if a > b; 0 otherwise.

Note

‘combine’, ‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto greater_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

greater_constant

Determines if two images A and B greater pixel wise. f(a, b) = 1 if a > b; 0 otherwise.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar value to compare pixel with. [float ( = 0 )]

return:: Array::Pointer

auto greater_constant_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

greater_or_equal

Determines if two images A and B greater or equal pixel wise. f(a, b) = 1 if a >= b; 0 otherwise.

Note

‘combine’, ‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto greater_or_equal_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

greater_or_equal_constant

Determines if two images A and B greater or equal pixel wise. f(a, b) = 1 if a >= b; 0 otherwise.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar value to compare pixel with. [float ( = 0 )]

return:: Array::Pointer

auto greater_or_equal_constant_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

hessian_eigenvalues

Computes the eigenvalues of the hessian matrix of a 2d or 3d image. Hessian matrix or 2D images: [Ixx, Ixy] [Ixy, Iyy] Hessian matrix for 3D images: [Ixx, Ixy, Ixz] [Ixy, Iyy, Iyz] [Ixz, Iyz, Izz] Ixx denotes the second derivative in x. Ixx and Iyy are calculated by convolving the image with the 1d kernel [1 2 1]. Ixy is calculated by a convolution with the 2d kernel: [ 0.25 0 0.25] [ 0 0 0] [0.25 0 0.25] Note: This is the only clesperanto function that returns multiple images. This API might be subject to change in the future. Consider using small_hessian_eigenvalue() and/or large_hessian_eigenvalue() instead which return only one image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param small_eigenvalue:: Output result image. [Array::Pointer ( = None )]
param middle_eigenvalue:: Output result image, null if input is 2D. [Array::Pointer ( = None )]
param large_eigenvalue:: Output result image. [Array::Pointer ( = None )]

return:: std::vector<Array::Pointer>

auto hessian_eigenvalues_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer small_eigenvalue, Array::Pointer middle_eigenvalue, Array::Pointer large_eigenvalue) -> std::vector<Array::Pointer>

laplace_box

Applies the Laplace operator (Box neighborhood) to an image.

Deprecated:: This function is deprecated. Consider using laplace() instead.

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto laplace_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

laplace_diamond

Applies the Laplace operator (Diamond neighborhood) to an image.

Deprecated:: This function is deprecated. Consider using laplace() instead.

Note

‘filter’, ‘edge detection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto laplace_diamond_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

laplace

Applies the Laplace operator with a “box” or a “sphere” neighborhood to an image.

Note

‘filter’, ‘edge detection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto laplace_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, std::string connectivity) -> Array::Pointer

local_cross_correlation

Compute the cross correlation of an image to a given kernel.

Note

‘filter’, ‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param kernel:: Input kernel. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto local_cross_correlation_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &kernel, Array::Pointer dst) -> Array::Pointer

logarithm

Computes base e logarithm of all pixels values. f(x) = log(x) Author(s): Peter Haub, Robert Haase

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto logarithm_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

mask

Computes a masked image by applying a binary mask to an image. All pixel values x of image X will be copied to the destination image in case pixel value m at the same position in the mask image is not equal to zero.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param mask:: Mask image to apply. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto mask_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &mask, Array::Pointer dst) -> Array::Pointer

mask_label

Computes a masked image by applying a label mask to an image. All pixel values x of image X will be copied to the destination image in case pixel value m at the same position in the label_map image has the right index value i.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: Input Intensity image. [const Array::Pointer &]
param src1:: Input Label image. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param label:: Label value to use. [float ( = 1 )]

return:: Array::Pointer

auto mask_label_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst, float label) -> Array::Pointer

maximum_image_and_scalar

Computes the maximum of a constant scalar s and each pixel value x in a given image X.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar value used in the comparison. [float ( = 0 )]

return:: Array::Pointer

auto maximum_image_and_scalar_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

maximum_images

Computes the maximum of a pair of pixel values x, y from two given images X and Y.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto maximum_images_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

maximum_box

Computes the local maximum of a pixels cube neighborhood. The cubes size is specified by its halfwidth, halfheight and halfdepth (radius).

Deprecated:: This function is deprecated. Consider using maximum_filter() instead.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto maximum_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

maximum_filter

Computes the local maximum of a pixels neighborhood (box or sphere). The neighborhood size is specified by its halfwidth, halfheight and halfdepth (radius).

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto maximum_filter_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

grayscale_dilate

Computes a grayscale image containing the grayscale dilation of a given input image. The erosion apply the Moore neighborhood (8 pixels in 2D and 26 pixels in 3d) for the “box” connectivity and the von Neumann neighborhood (4 pixels in 2D and 6 pixels in 3d) for a “sphere” connectivity. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto grayscale_dilate_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

maximum_x_projection

Determines the maximum intensity projection of an image along X.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto maximum_x_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

maximum_y_projection

Determines the maximum intensity projection of an image along X.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto maximum_y_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

maximum_z_projection

Determines the maximum intensity projection of an image along Z.

Note

‘projection’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto maximum_z_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

mean_box

Computes the local mean average of a pixels boxshaped neighborhood. The cubes size is specified by its halfwidth, halfheight and halfdepth (radius).

Deprecated:: This function is deprecated. Consider using mean() instead.

Note

‘filter’, ‘denoise’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto mean_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

mean_sphere

Computes the local mean average of a pixels spherical neighborhood. The spheres size is specified by its halfwidth, halfheight and halfdepth (radius).

Deprecated:: This function is deprecated. Consider using mean() instead.

Note

‘filter’, ‘denoise’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto mean_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

mean_filter

Computes the local mean average of a pixels neighborhood defined as a boxshaped or a sphereshaped. The shape size is specified by its halfwidth, halfheight and halfdepth (radius).

Note

‘filter’, ‘denoise’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto mean_filter_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

mean_x_projection

Determines the mean average intensity projection of an image along X.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto mean_x_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

mean_y_projection

Determines the mean average intensity projection of an image along Y.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto mean_y_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

mean_z_projection

Determines the mean average intensity projection of an image along Z.

Note

‘projection’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto mean_z_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

median_box

Computes the local median of a pixels box shaped neighborhood. The box is specified by its halfwidth and halfheight (radius). For technical reasons, the area of the box must have less than 1000 pixels.

Deprecated:: This function is deprecated. Consider using median() instead.

Note

‘filter’, ‘denoise’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto median_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

median_sphere

Computes the local median of a pixels sphere shaped neighborhood. The sphere is specified by its halfwidth and halfheight (radius). For technical reasons, the area of the box must have less than 1000 pixels.

Deprecated:: This function is deprecated. Consider using median() instead.

Note

‘filter’, ‘denoise’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto median_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

median

Computes the local median of a pixels neighborhood. The neighborhood is defined as a box or a sphere shape. Its size is specified by its halfwidth, halfheight, and halfdepth (radius). For technical reasons, the area of the shpae must have less than 1000 pixels.

Note

‘filter’, ‘denoise’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto median_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

minimum_box

Computes the local minimum of a pixels cube neighborhood. The cubes size is specified by its halfwidth, halfheight and halfdepth (radius).

Deprecated:: This function is deprecated. Consider using minimum_filter() instead.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto minimum_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

minimum_filter

Computes the local minimum of a pixels cube neighborhood. The cubes size is specified by its halfwidth, halfheight and halfdepth (radius).

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto minimum_filter_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

grayscale_erode

Computes a grayscale image containing the grayscale erosion of a given input image. The erosion apply the Mooreneighborhood (8 pixels in 2D and 26 pixels in 3d) for the “box” connectivity and the vonNeumannneighborhood (4 pixels in 2D and 6 pixels in 3d) for a “sphere” connectivity. The pixels in the input image with pixel value not equal to 0 will be interpreted as 1.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto grayscale_erode_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

minimum_image_and_scalar

Computes the minimum of a constant scalar s and each pixel value x in a given image X.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar value used in the comparison. [float ( = 0 )]

return:: Array::Pointer

auto minimum_image_and_scalar_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

minimum_images

Computes the minimum of a pair of pixel values x, y from two given images X and Y.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto minimum_images_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

minimum_x_projection

Determines the minimum intensity projection of an image along Y.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto minimum_x_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

minimum_y_projection

Determines the minimum intensity projection of an image along Y.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto minimum_y_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

minimum_z_projection

Determines the minimum intensity projection of an image along Z.

Note

‘projection’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto minimum_z_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

auto minimum_of_masked_pixels_reduction_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &mask, Array::Pointer reduced_src, Array::Pointer reduced_mask) -> Array::Pointer

mode_box

Computes the local mode of a pixels box shaped neighborhood. This can be used to postprocess and locally correct semantic segmentation results. The box is specified by its halfwidth and halfheight (radius). For technical reasons, the intensities must lie within a range from 0 to 255. In case multiple values have maximum frequency, the smallest one is returned.

Deprecated:: This function is deprecated. Consider using mode() instead.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto mode_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

mode_sphere

Computes the local mode of a pixels sphere shaped neighborhood. This can be used to postprocess and locally correct semantic segmentation results. The sphere is specified by its halfwidth and halfheight (radius). For technical reasons, the intensities must lie within a range from 0 to 255. In case multiple values have maximum frequency, the smallest one is returned.

Deprecated:: This function is deprecated. Consider using mode() instead.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto mode_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

mode

Computes the local mode of a pixels neighborhood. This neighborhood can be shaped as a box or a sphere. This can be used to postprocess and locally correct semantic segmentation results. The shape size is specified by its halfwidth, halfheight, and halfdepth (radius). For technical reasons, the intensities must lie within a range from 0 to 255 (uint8). In case multiple values have maximum frequency, the smallest one is returned.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto mode_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

modulo_images

Computes the remainder of a division of pairwise pixel values in two images

Note

‘combine’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto modulo_images_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

multiply_image_and_position

Multiplies all pixel intensities with the x, y or z coordinate, depending on specified dimension.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param dimension:: Dimension (0,1,2) to use in the operation. [int ( = 0 )]

return:: Array::Pointer

auto multiply_image_and_position_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int dimension) -> Array::Pointer

multiply_image_and_scalar

Multiplies all pixels value x in a given image X with a constant scalar s.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image to be multiplied with a constant. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]
param scalar:: The number with which every pixel will be multiplied with. [float ( = 0 )]

return:: Array::Pointer

auto multiply_image_and_scalar_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

multiply_images

Multiplies all pairs of pixel values x and y from two image X and Y.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to be multiplied. [const Array::Pointer &]
param src1:: Second image to be multiplied. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto multiply_images_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

nan_to_num

Copies all pixels instead those which are not a number (NaN), or positive/negative infinity which are replaced by a defined new value, default 0. This function aims to work similarly as its counterpart in numpy [1]. Default values for posinf and neginf may differ from numpy and even differ depending on compute hardware. It is recommended to specify those values.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]
param nan:: Value to replace nan with. [float ( = 0 )]
param posinf:: Value to replace +inf with. [float ( = np.nan_to_num(float(‘inf’)) )]
param neginf:: Value to replace -inf with. [float ( = np.nan_to_num(float(‘-inf’)) )]

return:: Array::Pointer

auto nan_to_num_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float nan = 0, float posinf = pINF, float neginf = nINF) -> Array::Pointer

nonzero_maximum_box

Apply a maximum filter (box shape) to the input image. The radius is fixed to 1 and pixels with value 0 are ignored. Note: Pixels with 0 value in the input image will not be overwritten in the output image. Thus, the result image should be initialized by copying the original image in advance.

Deprecated:: This function is deprecated. Consider using nonzero_maximum() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst0:: Output flag (0 or 1). [Array::Pointer]
param dst1:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto nonzero_maximum_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst0, Array::Pointer dst1) -> Array::Pointer

nonzero_maximum_diamond

Apply a maximum filter (diamond shape) to the input image. The radius is fixed to 1 and pixels with value 0 are ignored. Note: Pixels with 0 value in the input image will not be overwritten in the output image. Thus, the result image should be initialized by copying the original image in advance.

Deprecated:: This function is deprecated. Consider using nonzero_maximum() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst0:: Output flag (0 or 1). [Array::Pointer]
param dst1:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto nonzero_maximum_diamond_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst0, Array::Pointer dst1) -> Array::Pointer

nonzero_maximum

Apply a maximum filter of a neighborhood to the input image. The neighborhood shape can be a box or a sphere. The size is fixed to 1 and pixels with value 0 are ignored. Note: Pixels with 0 value in the input image will not be overwritten in the output image. Thus, the result image should be initialized by copying the original image in advance.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst0:: Output flag (0 or 1). [Array::Pointer]
param dst1:: Output image where results are written into. [Array::Pointer ( = None )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto nonzero_maximum_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst0, Array::Pointer dst1, std::string connectivity) -> Array::Pointer

nonzero_minimum_box

Apply a minimum filter (box shape) to the input image. The radius is fixed to 1 and pixels with value 0 are ignored. Note: Pixels with 0 value in the input image will not be overwritten in the output image. Thus, the result image should be initialized by copying the original image in advance.

Deprecated:: This function is deprecated. Consider using nonzero_minimum() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst0:: Output flag (0 or 1). [Array::Pointer]
param dst1:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto nonzero_minimum_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst0, Array::Pointer dst1) -> Array::Pointer

nonzero_minimum_diamond

Apply a minimum filter (diamond shape) to the input image. The radius is fixed to 1 and pixels with value 0 are ignored.Note: Pixels with 0 value in the input image will not be overwritten in the output image. Thus, the result image should be initialized by copying the original image in advance.

Deprecated:: This function is deprecated. Consider using nonzero_minimum() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst0:: Output flag (0 or 1). [Array::Pointer]
param dst1:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto nonzero_minimum_diamond_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst0, Array::Pointer dst1) -> Array::Pointer

nonzero_minimum

Apply a minimum filter of a neighborhood to the input image. The neighborhood shape can be a box or a sphere. The radius is fixed to 1 and pixels with value 0 are ignored.Note: Pixels with 0 value in the input image will not be overwritten in the output image. Thus, the result image should be initialized by copying the original image in advance.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst0:: Output flag (0 or 1). [Array::Pointer]
param dst1:: Output image where results are written into. [Array::Pointer ( = None )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto nonzero_minimum_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst0, Array::Pointer dst1, std::string connectivity) -> Array::Pointer

not_equal

Determines if two images A and B equal pixel wise. f(a, b) = 1 if a != b; 0 otherwise.

Note

‘combine’, ‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First image to be compared with. [const Array::Pointer &]
param src1:: Second image to be compared with the first. [const Array::Pointer &]
param dst:: The resulting binary image where pixels will be 1 only if source1 [Array::Pointer ( = None )]

return:: Array::Pointer

auto not_equal_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

not_equal_constant

Determines if two images A and B equal pixel wise. f(a, b) = 1 if a != b; 0 otherwise.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The image where every pixel is compared to the constant. [const Array::Pointer &]
param dst:: The resulting binary image where pixels will be 1 only if source1 [Array::Pointer ( = None )]
param scalar:: The constant where every pixel is compared to. [float ( = 0 )]

return:: Array::Pointer

auto not_equal_constant_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

paste

Pastes an image into another image at a given position.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param destination_x:: Origin pixel coodinate in x to paste. [int ( = 0 )]
param destination_y:: Origin pixel coodinate in y to paste. [int ( = 0 )]
param destination_z:: Origin pixel coodinate in z to paste. [int ( = 0 )]

return:: Array::Pointer

auto paste_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int destination_x, int destination_y, int destination_z) -> Array::Pointer

onlyzero_overwrite_maximum_box

Apply a local maximum filter to an image which only overwrites pixels with value 0.

Deprecated:: This function is deprecated. Consider using onlyzero_overwrite_maximum() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param flag:: Output flag value, 0 or 1. [Array::Pointer]
param dst:: Output image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto onlyzero_overwrite_maximum_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer flag, Array::Pointer dst) -> Array::Pointer

onlyzero_overwrite_maximum_diamond

Apply a local maximum filter to an image which only overwrites pixels with value 0.

Deprecated:: This function is deprecated. Consider using onlyzero_overwrite_maximum() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param flag:: Output flag value, 0 or 1. [Array::Pointer]
param dst:: Output image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto onlyzero_overwrite_maximum_diamond_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer flag, Array::Pointer dst) -> Array::Pointer

onlyzero_overwrite_maximum

Apply a local maximum filter to an image which only overwrites pixels with value 0.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param flag:: Output flag value, 0 or 1. [Array::Pointer]
param dst:: Output image. [Array::Pointer ( = None )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto onlyzero_overwrite_maximum_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer flag, Array::Pointer dst, std::string connectivity) -> Array::Pointer

power

Computes all pixels value x to the power of a given exponent a.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Power value. [float ( = 1 )]

return:: Array::Pointer

auto power_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

power_images

Calculates x to the power of y pixel wise of two images X and Y.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto power_images_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

range

Crops an image according to a defined range and step size.

Note

‘transform’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: First input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param start_x:: Range starting value in x [int ( = None )]
param stop_x:: Range stop value in x [int ( = None )]
param step_x:: Range step value in x [int ( = None )]
param start_y:: Range starting value in y [int ( = None )]
param stop_y:: Range stop value in y [int ( = None )]
param step_y:: Range step value in y [int ( = None )]
param start_z:: Range starting value in z [int ( = None )]
param stop_z:: Range stop value in z [int ( = None )]
param step_z:: Range step value in z [int ( = None )]

return:: Array::Pointer

auto range_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int start_x, int stop_x, int step_x, int start_y, int stop_y, int step_y, int start_z, int stop_z, int step_z) -> Array::Pointer

read_values_from_positions

Go to positions in a given image specified by a pointlist and read intensities of those pixels. The intensities are stored in a new vector. The positions are passed as a (x,y,z) coordinate per column.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param list:: List of coordinate, as a 2D matrix. [const Array::Pointer &]
param dst:: Output vector image of intensities. [Array::Pointer ( = None )]

return:: Array::Pointer

auto read_values_from_positions_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &list, Array::Pointer dst) -> Array::Pointer

replace_values

Replaces integer intensities specified in a vector image. The values are passed as a vector of values. The vector index represents the old intensity and the value at that position represents the new intensity.s

Note

‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: Input image to process. [const Array::Pointer &]
param src1:: List of intensities to replace, as a vector of values. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto replace_values_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

replace_value

Replaces a specific intensity in an image with a given new value.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param value_to_replace:: Old value. [float ( = 0 )]
param value_replacement:: New value. [float ( = 1 )]

return:: Array::Pointer

auto replace_value_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float value_to_replace, float value_replacement) -> Array::Pointer

replace_intensity

Replaces a specific intensity in an image with a given new value.

Deprecated:: This function is deprecated. Consider using replace_value() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param value_to_replace:: Old value. [float ( = 0 )]
param value_replacement:: New value. [float ( = 1 )]

return:: Array::Pointer

auto replace_intensity_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float value_to_replace, float value_replacement) -> Array::Pointer

replace_intensities

Replaces integer intensities specified in a vector image. The values are passed as a vector of values. The vector index represents the old intensity and the value at that position represents the new intensity.s

Deprecated:: This function is deprecated. Consider using replace_values() instead.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: Input image to process. [const Array::Pointer &]
param src1:: List of intensities to replace, as a vector of values. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto replace_intensities_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

maximum_sphere

Computes the local maximum of a pixels spherical neighborhood. The spheres size is specified by its halfwidth, halfheight and halfdepth (radius).

Deprecated:: This function is deprecated. Consider using maximum() instead.

Note

‘filter’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 0 )]

return:: Array::Pointer

auto maximum_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

minimum_sphere

Computes the local minimum of a pixels spherical neighborhood. The spheres size is specified by its halfwidth, halfheight and halfdepth (radius).

Deprecated:: This function is deprecated. Consider using minimum() instead.

Note

‘filter’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto minimum_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

multiply_matrix

Multiplies two matrices with each other. Shape of matrix1 should be equal to shape of matrix2 transposed.

param device:: Device to perform the operation on. [const Device::Pointer &]
param matrix1:: First matrix to process. [const Array::Pointer &]
param matrix2:: Second matrix to process. [const Array::Pointer &]
param matrix_destination:: Output result matrix. [Array::Pointer ( = None )]

return:: Array::Pointer

auto multiply_matrix_func(const Device::Pointer &device, const Array::Pointer &matrix1, const Array::Pointer &matrix2, Array::Pointer matrix_destination) -> Array::Pointer

reciprocal

Computes 1/x for every pixel value This function is supposed to work similarly to its counter part in numpy [1]

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto reciprocal_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

set

Sets all pixel values x of a given image X to a constant value v.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param scalar:: Value to set. [float ( = 0 )]

return:: Array::Pointer

auto set_func(const Device::Pointer &device, const Array::Pointer &src, float scalar) -> Array::Pointer

set_column

Sets all pixel values x of a given column in X to a constant value v.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param column_index:: Column index. [int ( = 0 )]
param value:: Value to set. [float ( = 0 )]

return:: Array::Pointer

auto set_column_func(const Device::Pointer &device, const Array::Pointer &src, int column_index, float value) -> Array::Pointer

set_image_borders

Sets all pixel values at the image border to a given value.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param value:: Value to set. [float ( = 0 )]

return:: Array::Pointer

auto set_image_borders_func(const Device::Pointer &device, const Array::Pointer &src, float value) -> Array::Pointer

set_plane

Sets all pixel values x of a given plane in X to a constant value v.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param plane_index:: Plane index. [int ( = 0 )]
param value:: Value to set. [float ( = 0 )]

return:: Array::Pointer

auto set_plane_func(const Device::Pointer &device, const Array::Pointer &src, int plane_index, float value) -> Array::Pointer

set_ramp_x

Sets all pixel values to their X coordinate.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]

return:: Array::Pointer

auto set_ramp_x_func(const Device::Pointer &device, const Array::Pointer &src) -> Array::Pointer

set_ramp_y

Sets all pixel values to their Y coordinate.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]

return:: Array::Pointer

auto set_ramp_y_func(const Device::Pointer &device, const Array::Pointer &src) -> Array::Pointer

set_ramp_z

Sets all pixel values to their Z coordinate.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]

return:: Array::Pointer

auto set_ramp_z_func(const Device::Pointer &device, const Array::Pointer &src) -> Array::Pointer

set_row

Sets all pixel values x of a given row in X to a constant value v.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param row_index:: [int ( = 0 )]
param value:: [float ( = 0 )]

return:: Array::Pointer

auto set_row_func(const Device::Pointer &device, const Array::Pointer &src, int row_index, float value) -> Array::Pointer

set_nonzero_pixels_to_pixelindex

Replaces all 0 value pixels in an image with the index of a pixel.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param offset:: Offset value to start the indexing. [int ( = 1 )]

return:: Array::Pointer

auto set_nonzero_pixels_to_pixelindex_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int offset) -> Array::Pointer

set_where_x_equals_y

Sets all pixel values a of a given image A to a constant value v in case its coordinates x == y. Otherwise the pixel is not overwritten. If you want to initialize an identity transfrom matrix, set all pixels to 0 first.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param value:: Value to set. [float ( = 0 )]

return:: Array::Pointer

auto set_where_x_equals_y_func(const Device::Pointer &device, const Array::Pointer &src, float value) -> Array::Pointer

set_where_x_greater_than_y

Sets all pixel values a of a given image A to a constant value v in case its coordinates x > y. Otherwise the pixel is not overwritten. If you want to initialize an identity transfrom matrix, set all pixels to 0 first.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param value:: Value to set. [float ( = 0 )]

return:: Array::Pointer

auto set_where_x_greater_than_y_func(const Device::Pointer &device, const Array::Pointer &src, float value) -> Array::Pointer

set_where_x_smaller_than_y

Sets all pixel values a of a given image A to a constant value v in case its coordinates x < y. Otherwise the pixel is not overwritten. If you want to initialize an identity transfrom matrix, set all pixels to 0 first.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param value:: Value to set. [float ( = 0 )]

return:: Array::Pointer

auto set_where_x_smaller_than_y_func(const Device::Pointer &device, const Array::Pointer &src, float value) -> Array::Pointer

sign

Extracts the sign of pixels. If a pixel value < 0, resulting pixel value will be 1. If it was > 0, it will be 1. Otherwise it will be 0. This function aims to work similarly as its counterpart in numpy [1].

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto sign_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

smaller

Determines if two images A and B smaller pixel wise. f(a, b) = 1 if a < b; 0 otherwise.

Note

‘combine’, ‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto smaller_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

smaller_constant

Determines if two images A and B smaller pixel wise. f(a, b) = 1 if a < b; 0 otherwise.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar used in the comparison. [float ( = 0 )]

return:: Array::Pointer

auto smaller_constant_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

smaller_or_equal

Determines if two images A and B smaller or equal pixel wise. f(a, b) = 1 if a <= b; 0 otherwise.

Note

‘combine’, ‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image to process. [const Array::Pointer &]
param src1:: Second input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto smaller_or_equal_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

smaller_or_equal_constant

Determines if two images A and B smaller or equal pixel wise. f(a, b) = 1 if a <= b; 0 otherwise.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar used in the comparison. [float ( = 0 )]

return:: Array::Pointer

auto smaller_or_equal_constant_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

sobel

Convolve the image with the Sobel kernel. Author(s): Ruth WhelanJeans, Robert Haase

Note

‘filter’, ‘edge detection’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto sobel_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

square_root

Computes the square root of each pixel.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto square_root_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

std_z_projection

Determines the standard deviation intensity projection of an image stack along Z.

Note

‘projection’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto std_z_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

subtract_image_from_scalar

Subtracts one image X from a scalar s pixel wise.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param scalar:: Scalar used in the subtraction. [float ( = 0 )]

return:: Array::Pointer

auto subtract_image_from_scalar_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float scalar) -> Array::Pointer

sum_reduction_x

Takes an image and reduces it in width by factor blocksize. The new pixels contain the sum of the reduced pixels. For example, given the following image and block size 4: [0, 1, 1, 0, 1, 0, 1, 1] would lead to an image [2, 3]

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param blocksize:: Blocksize value. [int ( = 256 )]

return:: Array::Pointer

auto sum_reduction_x_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int blocksize) -> Array::Pointer

sum_x_projection

Determines the sum intensity projection of an image along Z.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto sum_x_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

sum_y_projection

Determines the sum intensity projection of an image along Z.

Note

‘projection’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto sum_y_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

sum_z_projection

Determines the sum intensity projection of an image along Z.

Note

‘projection’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto sum_z_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

transpose_xy

Transpose X and Y axes of an image.

Note

‘transform’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto transpose_xy_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

transpose_xz

Transpose X and Z axes of an image.

Note

‘transform’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto transpose_xz_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

transpose_yz

Transpose Y and Z axes of an image.

Note

‘transform’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image. [const Array::Pointer &]
param dst:: Output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto transpose_yz_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

undefined_to_zero

Copies all pixels instead those which are not a number (NaN) or infinity (inf), which are replaced by 0.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto undefined_to_zero_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

variance_box

Computes the local variance of a pixels box neighborhood. The box size is specified by its halfwidth, halfheight and halfdepth (radius). If 2D images are given, radius_z will be ignored.

Deprecated:: This function is deprecated. Consider using variance() instead.

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto variance_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

variance_sphere

Computes the local variance of a pixels sphere neighborhood. The sphere size is specified by its halfwidth, halfheight and halfdepth (radius). If 2D images are given, radius_z will be ignored.

Deprecated:: This function is deprecated. Consider using variance() instead.

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]

return:: Array::Pointer

auto variance_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

variance_filter

Computes the local variance of a pixels neighborhood (box or sphere). The neighborhood size is specified by its halfwidth, halfheight and halfdepth (radius). If 2D images are given, radius_z will be ignored.

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius size along x axis. [float ( = 1 )]
param radius_y:: Radius size along y axis. [float ( = 1 )]
param radius_z:: Radius size along z axis. [float ( = 1 )]
param connectivity:: Filter neigborhood connectivity, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto variance_filter_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

write_values_to_positions

Takes an image with three/four rows (2D: height = 3; 3D: height = 4): x, y [, z] and v and target image. The value v will be written at position x/y[/z] in the target image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto write_values_to_positions_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

x_position_of_maximum_x_projection

Determines an Xposition of the maximum intensity along X and writes it into the resulting image. If there are multiple xslices with the same value, the smallest X will be chosen.

Note

‘projection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image stack [const Array::Pointer &]
param dst:: altitude map [Array::Pointer ( = None )]

return:: Array::Pointer

auto x_position_of_maximum_x_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

x_position_of_minimum_x_projection

Determines an Xposition of the minimum intensity along X and writes it into the resulting image. If there are multiple xslices with the same value, the smallest X will be chosen.

Note

‘projection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image stack [const Array::Pointer &]
param dst:: altitude map [Array::Pointer ( = None )]

return:: Array::Pointer

auto x_position_of_minimum_x_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

y_position_of_maximum_y_projection

Determines an Yposition of the maximum intensity along Y and writes it into the resulting image. If there are multiple yslices with the same value, the smallest Y will be chosen.

Note

‘projection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image stack [const Array::Pointer &]
param dst:: altitude map [Array::Pointer ( = None )]

return:: Array::Pointer

auto y_position_of_maximum_y_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

y_position_of_minimum_y_projection

Determines an Yposition of the minimum intensity along Y and writes it into the resulting image. If there are multiple yslices with the same value, the smallest Y will be chosen.

Note

‘projection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image stack [const Array::Pointer &]
param dst:: altitude map [Array::Pointer ( = None )]

return:: Array::Pointer

auto y_position_of_minimum_y_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

z_position_of_maximum_z_projection

Determines a Zposition of the maximum intensity along Z and writes it into the resulting image. If there are multiple zslices with the same value, the smallest Z will be chosen.

Note

‘projection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image stack [const Array::Pointer &]
param dst:: altitude map [Array::Pointer ( = None )]

return:: Array::Pointer

auto z_position_of_maximum_z_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

z_position_of_minimum_z_projection

Determines a Zposition of the minimum intensity along Z and writes it into the resulting image. If there are multiple zslices with the same value, the smallest Z will be chosen.

Note

‘projection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image stack [const Array::Pointer &]
param dst:: altitude map [Array::Pointer ( = None )]

return:: Array::Pointer

auto z_position_of_minimum_z_projection_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

tier2

namespace tier2

Namespace container for all functions of tier 2 category Tier 2 functions are advanced functions that may rely on previous tier functions.

absolute_difference

Determines the absolute difference pixel by pixel between two images.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: The input image to be subtracted from. [const Array::Pointer &]
param src1:: The input image which is subtracted. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto absolute_difference_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

add_images

Calculates the sum of pairs of pixels x and y of two images X and Y.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: The first input image to added. [const Array::Pointer &]
param src1:: The second image to be added. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]

return:: Array::Pointer

auto add_images_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

bottom_hat_box

Apply a bottomhat filter for background subtraction to the input image.

Deprecated:: This method is deprecated. Consider using bottom_hat() instead.

Note

‘filter’, ‘background removal’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image where the background is subtracted from. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]
param radius_x:: Radius of the background determination region in X. [float ( = 1 )]
param radius_y:: Radius of the background determination region in Y. [float ( = 1 )]
param radius_z:: Radius of the background determination region in Z. [float ( = 1 )]

return:: Array::Pointer

auto bottom_hat_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

bottom_hat_sphere

Applies a bottomhat filter for background subtraction to the input image.

Deprecated:: This method is deprecated. Consider using bottom_hat() instead.

Note

‘filter’, ‘background removal’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image where the background is subtracted from. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]
param radius_x:: Radius of the background determination region in X. [float ( = 1 )]
param radius_y:: Radius of the background determination region in Y. [float ( = 1 )]
param radius_z:: Radius of the background determination region in Z. [float ( = 1 )]

return:: Array::Pointer

auto bottom_hat_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

bottom_hat

Applies a bottomhat filter for background subtraction to the input image.

Note

‘filter’, ‘background removal’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image where the background is subtracted from. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]
param radius_x:: Radius of the background determination region in X. [float ( = 1 )]
param radius_y:: Radius of the background determination region in Y. [float ( = 1 )]
param radius_z:: Radius of the background determination region in Z. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto bottom_hat_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

clip

Limits the range of values in an image. This function is supposed to work similarly as its counter part in numpy [1].

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param min_intensity:: new, lower limit of the intensity range [float ( = None )]
param max_intensity:: new, upper limit of the intensity range [float ( = None )]

return:: Array::Pointer

auto clip_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float min_intensity, float max_intensity) -> Array::Pointer

closing_box

Closing operator, applies grayscale morphological closing to intensity images using a box shaped footprint. This operator also works with binary images.

Deprecated:: This method is deprecated. Consider using closing() instead.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [int ( = 1 )]
param radius_y:: Radius along the y axis. [int ( = 1 )]
param radius_z:: Radius along the z axis. [int ( = 1 )]

return:: Array::Pointer

auto closing_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

closing_sphere

Closing operator, applies grayscale morphological closing to intensity images using a sphere shaped footprint. This operator also works with binary images.

Deprecated:: This method is deprecated. Consider using closing() instead.

Note

‘filter’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]

return:: Array::Pointer

auto closing_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

grayscale_closing

Closing operator, applies grayscale morphological closing to intensity images using a sphere or box shaped footprint. This operator also works with binary images.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto grayscale_closing_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

closing

Closing operator, applies morphological closing to intensity images using a custom structuring element provided as input. This operator also works with binary images.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param footprint:: Structuring element for the operation. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto closing_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &footprint, Array::Pointer dst) -> Array::Pointer

binary_closing

Closing operator, applies binary morphological closing to intensity images using a sphere or box shaped footprint. This operator also works with binary images.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius of the sphere or box element along the x axis. [float ( = 1 )]
param radius_y:: Radius of the sphere or box element along the y axis. [float ( = 1 )]
param radius_z:: Radius of the sphere or box element along the z axis. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto binary_closing_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

concatenate_along_x

Concatenate two images or stacks along the X axis.

Note

‘combine’, ‘transform’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image. [const Array::Pointer &]
param src1:: Second input image. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto concatenate_along_x_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

concatenate_along_y

Concatenate two images or stacks along the Y axis.

Note

‘combine’, ‘transform’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image. [const Array::Pointer &]
param src1:: Second input image. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto concatenate_along_y_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

concatenate_along_z

Concatenate two images or stacks along the Z axis.

Note

‘combine’, ‘transform’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image. [const Array::Pointer &]
param src1:: Second input image. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto concatenate_along_z_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

count_touching_neighbors

Takes a touch matrix as input and delivers a vector with number of touching neighbors per label as a vector. Note: Background is considered as something that can touch. To ignore touches with background, hand over a touch matrix where the first column (index = 0) has been set to 0. Use set_column for that.

param device:: Device to perform the operation on. [const Device::Pointer &]
param touch_matrix:: Input touch matrix to process. [const Array::Pointer &]
param touching_neighbors_count_destination:: Output vector of touch count. [Array::Pointer ( = None )]
param ignore_background:: [bool ( = True )]

return:: Array::Pointer

auto count_touching_neighbors_func(const Device::Pointer &device, const Array::Pointer &touch_matrix, Array::Pointer touching_neighbors_count_destination, bool ignore_background) -> Array::Pointer

crop_border

Crops an image by removing the outer pixels, per default 1. Notes * To make sure the output image has the right size, provide destination_image=None.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param border_size:: Border size to crop. [int ( = 1 )]

return:: Array::Pointer

auto crop_border_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int border_size) -> Array::Pointer

divide_by_gaussian_background

Applies Gaussian blur to the input image and divides the original by the result.

Note

‘filter’, ‘background removal’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param sigma_x:: Gaussian sigma value along x. [float ( = 2 )]
param sigma_y:: Gaussian sigma value along y. [float ( = 2 )]
param sigma_z:: Gaussian sigma value along z. [float ( = 2 )]

return:: Array::Pointer

auto divide_by_gaussian_background_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float sigma_x, float sigma_y, float sigma_z) -> Array::Pointer

degrees_to_radians

Converts radians to degrees.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto degrees_to_radians_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

detect_maxima_box

Detects local maxima in a given square/cubic neighborhood. Pixels in the resulting image are set to 1 if there is no other pixel in a given radius which has a higher intensity, and to 0 otherwise.

Deprecated:: This method is deprecated. Consider using detect_maxima() instead.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 0 )]
param radius_y:: Radius along the y axis. [float ( = 0 )]
param radius_z:: Radius along the z axis. [float ( = 0 )]

return:: Array::Pointer

auto detect_maxima_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

detect_maxima

Detects local maxima in a given square/cubic neighborhood. Pixels in the resulting image are set to 1 if there is no other pixel in a given radius which has a higher intensity, and to 0 otherwise.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 0 )]
param radius_y:: Radius along the y axis. [float ( = 0 )]
param radius_z:: Radius along the z axis. [float ( = 0 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto detect_maxima_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

detect_minima_box

Detects local maxima in a given square/cubic neighborhood. Pixels in the resulting image are set to 1 if there is no other pixel in a given radius which has a lower intensity, and to 0 otherwise.

Deprecated:: This method is deprecated. Consider using detect_minima() instead.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 0 )]
param radius_y:: Radius along the y axis. [float ( = 0 )]
param radius_z:: Radius along the z axis. [float ( = 0 )]

return:: Array::Pointer

auto detect_minima_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

detect_minima

Detects local maxima in a given square/cubic neighborhood. Pixels in the resulting image are set to 1 if there is no other pixel in a given radius which has a lower intensity, and to 0 otherwise.

Note

‘binarize’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 0 )]
param radius_y:: Radius along the y axis. [float ( = 0 )]
param radius_z:: Radius along the z axis. [float ( = 0 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto detect_minima_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

difference_of_gaussian

Applies Gaussian blur to the input image twice with different sigma values resulting in two images which are then subtracted from each other. It is recommended to apply this operation to images of type Float (32 bit) as results might be negative.

Note

‘filter’, ‘background removal’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image to be processed. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]
param sigma1_x:: Sigma of the first Gaussian filter in x [float ( = 2 )]
param sigma1_y:: Sigma of the first Gaussian filter in y [float ( = 2 )]
param sigma1_z:: Sigma of the first Gaussian filter in z [float ( = 2 )]
param sigma2_x:: Sigma of the second Gaussian filter in x [float ( = 2 )]
param sigma2_y:: Sigma of the second Gaussian filter in y [float ( = 2 )]
param sigma2_z:: Sigma of the second Gaussian filter in z [float ( = 2 )]

return:: Array::Pointer

auto difference_of_gaussian_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float sigma1_x, float sigma1_y, float sigma1_z, float sigma2_x, float sigma2_y, float sigma2_z) -> Array::Pointer

extend_labeling_via_voronoi

Takes a label map image and dilates the regions using a octagon shape until they touch. The resulting label map is written to the output.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto extend_labeling_via_voronoi_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

invert

Computes the negative value of all pixels in a given image. It is recommended to convert images to 32bit float before applying this operation.

For binary images, use binaryNot.

Note

‘filter’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto invert_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

label_spots

Transforms a binary image with single pixles set to 1 to a labelled spots image. Transforms a spots image as resulting from maximum/minimum detection in an image of the same size where every spot has a number 1, 2,… n.

Note

‘label’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto label_spots_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

large_hessian_eigenvalue

Determines the Hessian eigenvalues and returns the large eigenvalue image.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto large_hessian_eigenvalue_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

maximum_of_all_pixels

Determines the maximum of all pixels in a given image. It will be stored in a new row of ImageJs Results table in the column ‘Max’.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]

return:: float

auto maximum_of_all_pixels_func(const Device::Pointer &device, const Array::Pointer &src) -> float

minimum_of_all_pixels

Determines the minimum of all pixels in a given image. It will be stored in a new row of ImageJs Results table in the column ‘Min’.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]

return:: float

auto minimum_of_all_pixels_func(const Device::Pointer &device, const Array::Pointer &src) -> float

minimum_of_masked_pixels

Determines the minimum intensity in a masked image. But only in pixels which have nonzero values in another mask image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param mask:: Input mask. [const Array::Pointer &]

return:: float

auto minimum_of_masked_pixels_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &mask) -> float

opening_box

Opening operator, applies morphological opening to intensity images using a boxshaped footprint. This operator also works with binary images.

Deprecated:: This method is deprecated. Consider using opening() instead.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]

return:: Array::Pointer

auto opening_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

opening_sphere

Opening operator, applies morphological opening to intensity images using a sphereshaped footprint. This operator also works with binary images.

Deprecated:: This method is deprecated. Consider using opening() instead.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]

return:: Array::Pointer

auto opening_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

grayscale_opening

Opening operator, Applies morphological opening to intensity images using a sphereshaped or boxshepd footprint. This operator also works with binary images.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto grayscale_opening_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

opening

Opening operator, applies morphological opening to intensity images using a custom structuring element provided as input. This operator also works with binary images.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param footprint:: Structuring element for the operation. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto opening_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &footprint, Array::Pointer dst) -> Array::Pointer

binary_opening

Closing operator, applies binary morphological opening to intensity images using a sphere or box shaped footprint. This operator also works with binary images.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius of the sphere or box element along the x axis. [float ( = 1 )]
param radius_y:: Radius of the sphere or box element along the y axis. [float ( = 1 )]
param radius_z:: Radius of the sphere or box element along the z axis. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto binary_opening_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

radians_to_degrees

Converts radians to degrees

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto radians_to_degrees_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

reduce_labels_to_label_edges

Takes a label map and reduces all labels to their edges. Label IDs stay and background will be zero.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto reduce_labels_to_label_edges_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

small_hessian_eigenvalue

Determines the Hessian eigenvalues and returns the small eigenvalue image.

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto small_hessian_eigenvalue_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

square

Return the elementwise square of the input. This function is supposed to be similar to its counterpart in numpy [1]

Note

‘filter’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto square_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

squared_difference

Determines the squared difference pixel by pixel between two images.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image. [const Array::Pointer &]
param src1:: Second input image. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto squared_difference_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

standard_deviation_box

Computes the local standard deviation of a pixels box neighborhood. The box size is specified by its halfwidth, halfheight and halfdepth (radius). If 2D images are given, radius_z will be ignored.

Deprecated:: This method is deprecated. Consider using standard_deviation() instead.

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]

return:: Array::Pointer

auto standard_deviation_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

standard_deviation_sphere

Computes the local standard deviation of a pixels sphere neighborhood. The box size is specified by its halfwidth, halfheight and halfdepth (radius). If 2D images are given, radius_z will be ignored.

Deprecated:: This method is deprecated. Consider using standard_deviation() instead.

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]

return:: Array::Pointer

auto standard_deviation_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

standard_deviation

Computes the local standard deviation of a pixels sphere neighborhood. The box size is specified by its halfwidth, halfheight and halfdepth (radius). If 2D images are given, radius_z will be ignored.

Note

‘filter’, ‘edge detection’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param radius_x:: Radius along the x axis. [float ( = 1 )]
param radius_y:: Radius along the y axis. [float ( = 1 )]
param radius_z:: Radius along the z axis. [float ( = 1 )]
param connectivity:: Neigborhood shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto standard_deviation_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

subtract_gaussian_background

Applies Gaussian blur to the input image and subtracts the result from the original.

Note

‘filter’, ‘background removal’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]
param sigma_x:: Radius along the x axis. [float ( = 2 )]
param sigma_y:: Radius along the y axis. [float ( = 2 )]
param sigma_z:: Radius along the z axis. [float ( = 2 )]

return:: Array::Pointer

auto subtract_gaussian_background_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float sigma_x, float sigma_y, float sigma_z) -> Array::Pointer

subtract_images

Subtracts one image X from another image Y pixel wise.

Note

‘combine’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input image. [const Array::Pointer &]
param src1:: Second input image. [const Array::Pointer &]
param dst:: Output result image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto subtract_images_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

sub_stack

Crop a volume into a new volume, along the z-axis.

Note

‘transform’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param start_z:: Start z coordinate of the crop. [int ( = 0 )]
param end_z:: End z coordinate of the crop. [int ( = 0 )]

return:: Array::Pointer

auto sub_stack_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int start_z, int end_z) -> Array::Pointer

reduce_stack

Reduces the number of z-slices in a stack by a given factor. With the offset you have control which slices stays: with a factor 3 and offset 0, slices 0,3,6, etc. are kept. with a factor 4 and offset 1, slices 1,5,9, etc. are kept.

Note

‘transform’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param reduction_factor:: Reduction factor. [int ( = 2 )]
param offset:: Offset. [int ( = 0 )]

return:: Array::Pointer

auto reduce_stack_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int reduction_factor, int offset) -> Array::Pointer

sum_of_all_pixels

Determines the sum of all pixels in a given image. It will be stored in a new row of ImageJs Results table in the column ‘Sum’.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer & ( = None )]

return:: float

auto sum_of_all_pixels_func(const Device::Pointer &device, const Array::Pointer &src) -> float

top_hat_box

Applies a tophat filter for background subtraction to the input image.

Deprecated:: This method is deprecated. Consider using top_hat() instead.

Note

‘filter’, ‘background removal’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image where the background is subtracted from. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]
param radius_x:: Radius of the background determination region in X. [float ( = 1 )]
param radius_y:: Radius of the background determination region in Y. [float ( = 1 )]
param radius_z:: Radius of the background determination region in Z. [float ( = 1 )]

return:: Array::Pointer

auto top_hat_box_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

top_hat_sphere

Applies a tophat filter for background subtraction to the input image.

Deprecated:: This method is deprecated. Consider using top_hat() instead.

Note

‘filter’, ‘background removal’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image where the background is subtracted from. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]
param radius_x:: Radius of the background determination region in X. [float ( = 1 )]
param radius_y:: Radius of the background determination region in Y. [float ( = 1 )]
param radius_z:: Radius of the background determination region in Z. [float ( = 1 )]

return:: Array::Pointer

auto top_hat_sphere_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z) -> Array::Pointer

top_hat

Applies a tophat filter for background subtraction to the input image.

Note

‘filter’, ‘background removal’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The input image where the background is subtracted from. [const Array::Pointer &]
param dst:: The output image where results are written into. [Array::Pointer ( = None )]
param radius_x:: Radius of the background determination region in X. [float ( = 1 )]
param radius_y:: Radius of the background determination region in Y. [float ( = 1 )]
param radius_z:: Radius of the background determination region in Z. [float ( = 1 )]
param connectivity:: Element shape, “box” or “sphere” [std::string ( = “box” )]

return:: Array::Pointer

auto top_hat_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float radius_x, float radius_y, float radius_z, std::string connectivity) -> Array::Pointer

tier3

namespace tier3

Namespace container for all functions of tier 3 category Tier 3 functions are advanced functions that may rely on previous tier functions.

bounding_box

Determines the bounding box of all nonzero pixels in a binary image. The positions are returned in an array of 6 values as follows: minX, minY, minZ, maxX, maxY, maxZ.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input binary image [const Array::Pointer &]

return:: std::vector<float>

auto bounding_box_func(const Device::Pointer &device, const Array::Pointer &src) -> std::vector<float>

center_of_mass

Determines the center of mass of an image or image stack. It writes the result in the results table in the columns MassX, MassY and MassZ.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image [const Array::Pointer &]

return:: std::vector<float>

auto center_of_mass_func(const Device::Pointer &device, const Array::Pointer &src) -> std::vector<float>

remove_labels

This operation removes labels from a labelmap and renumbers the remaining labels. Hand over a binary flag list vector starting with a flag for the background, continuing with label1, label2,… For example if you pass 0,1,0,0,1: Labels 1 and 4 will be removed (those with a 1 in the vector will be excluded). Labels 2 and 3 will be kept and renumbered to 1 and 2.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image [const Array::Pointer &]
param list:: Vector of 0 and 1 flagging labels to remove [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]

return:: Array::Pointer

auto remove_labels_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &list, Array::Pointer dst) -> Array::Pointer

exclude_labels

This operation removes labels from a labelmap and renumbers the remaining labels. Hand over a binary flag list vector starting with a flag for the background, continuing with label1, label2,… For example if you pass 0,1,0,0,1: Labels 1 and 4 will be removed (those with a 1 in the vector will be excluded). Labels 2 and 3 will be kept and renumbered to 1 and 2.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image [const Array::Pointer &]
param list:: Vector of 0 and 1 flagging labels to remove [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]

return:: Array::Pointer

auto exclude_labels_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &list, Array::Pointer dst) -> Array::Pointer

remove_labels_on_edges

Removes all labels from a label map which touch the edges of the image. Remaining label elements are renumbered afterwards.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer & ( = None )]
param src:: Input label image [const Array::Pointer &]
param dst:: Output label image[Array::Pointer ( = None )]
param exclude_x:: Exclude labels along min and max x [bool ( = True )]
param exclude_y:: Exclude labels along min and max y [bool ( = True )]
param exclude_z:: Exclude labels along min and max z [bool ( = True )]

return:: Array::Pointer

auto remove_labels_on_edges_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, bool exclude_x, bool exclude_y, bool exclude_z) -> Array::Pointer

exclude_labels_on_edges

Removes all labels from a label map which touch the edges of the image. Remaining label elements are renumbered afterwards.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer & ( = None )]
param src:: Input label image [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]
param exclude_x:: Exclude labels along min and max x [bool ( = True )]
param exclude_y:: Exclude labels along min and max y [bool ( = True )]
param exclude_z:: Exclude labels along min and max z [bool ( = True )]

return:: Array::Pointer

auto exclude_labels_on_edges_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, bool exclude_x, bool exclude_y, bool exclude_z) -> Array::Pointer

flag_existing_labels

Given a label map this function will generate a binary vector where all pixels are set to 1 if label with given xcoordinate in the vector exists. For example a label image such as 0 1 3 5 will produce a flag_vector like this: 1 1 0 1 0 1

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: a label image [const Array::Pointer &]
param dst:: binary vector, if given should have size 1*n with n = maximum label + 1 [Array::Pointer ( = None )]

return:: Array::Pointer

auto flag_existing_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

gamma_correction

Applies a gamma correction to an image. Therefore, all pixels x of the Image X are normalized and the power to gamma g is computed, before normlization is reversed (^ is the power operator):f(x) = (x / max(X)) ^ gamma * max(X)

Note

‘filter’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image [const Array::Pointer &]
param dst:: Output image [Array::Pointer ( = None )]
param gamma:: [float ( = 1 )]

return:: Array::Pointer

auto gamma_correction_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float gamma) -> Array::Pointer

generate_binary_overlap_matrix

Takes two labelmaps with n and m labels and generates a (n+1)*(m+1) matrix where all pixels are set to 0 exept those where labels overlap between the label maps. For example, if labels 3 in labelmap1 and 4 in labelmap2 are touching then the pixel (3,4) in the matrix will be set to 1.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First input label image [const Array::Pointer &]
param src1:: Second input label image [const Array::Pointer &]
param dst:: Output overlap matrix [Array::Pointer ( = None )]

return:: Array::Pointer

auto generate_binary_overlap_matrix_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

generate_touch_matrix

Takes a labelmap with n labels and generates a (n+1)*(n+1) matrix where all pixels are set to 0 exept those where labels are touching. Only half of the matrix is filled (with x < y). For example, if labels 3 and 4 are touching then the pixel (3,4) in the matrix will be set to 1. The touch matrix is a representation of a region adjacency graph

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image [const Array::Pointer &]
param dst:: Output touch matrix [Array::Pointer ( = None )]

return:: Array::Pointer

auto generate_touch_matrix_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

histogram

Determines the histogram of a given image. The histogram image is of dimensions number_of_bins/1/1; a 3D image with height=1 and depth=1. Histogram bins contain the number of pixels with intensity in this corresponding bin. The histogram bins are uniformly distributed between given minimum and maximum grey value intensity. If the flag determine_min_max is set, minimum and maximum intensity will be determined. When calling this operation many times, it is recommended to determine minimum and maximum intensity once at the beginning and handing over these values. Author(s): Robert Haase adapted work from Aaftab Munshi, Benedict Gaster, Timothy Mattson, James Fung, Dan Ginsburg License: adapted code from https://github.com/bgaster/openclbooksamples/blob/master/src/Chapter_14/histogram/histogram_image.cl

It was published unter BSD license according to https://code.google.com/archive/p/openclbooksamples/

Book: OpenCL(R) Programming Guide Authors: Aaftab Munshi, Benedict Gaster, Timothy Mattson, James Fung, Dan Ginsburg ISBN10: 0321749642 ISBN13: 9780321749642 Publisher: AddisonWesley Professional URLs: http://safari.informit.com/9780132488006/ http://www.openclprogrammingguide.com

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to derive histogram from [const Array::Pointer &]
param dst:: Output histogram [Array::Pointer ( = None )]
param num_bins:: [int ( = 256 )]
param minimum_intensity:: [float ( = None )]
param maximum_intensity:: [float ( = None )]

return:: Array::Pointer

auto histogram_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int num_bins, float minimum_intensity = NaN, float maximum_intensity = NaN) -> Array::Pointer

jaccard_index

Determines the overlap of two binary images using the Jaccard index. A value of 0 suggests no overlap, 1 means perfect overlap. The resulting Jaccard index is saved to the results table in the ‘Jaccard_Index’ column. Note that the SorensenDice coefficient can be calculated from the Jaccard index j using this formula:

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First binary image to compare [const Array::Pointer &]
param src1:: Second binary image to compare [const Array::Pointer &]

return:: float

auto jaccard_index_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1) -> float

labelled_spots_to_pointlist

Generates a coordinate list of points in a labelled spot image. Transforms a labelmap of spots (single pixels with values 1, 2,…, n for n spots) as resulting from connected components analysis in an image where every column contains d pixels (with d = dimensionality of the original image) with the coordinates of the maxima/minima.

param device:: Device to perform the operation on. [const Device::Pointer &]
param label:: Input label image [const Array::Pointer &]
param pointlist:: Output coordinate list [Array::Pointer ( = None )]

return:: Array::Pointer

auto labelled_spots_to_pointlist_func(const Device::Pointer &device, const Array::Pointer &label, Array::Pointer dspointlistt) -> Array::Pointer

maximum_position

Determines the position of the maximum of all pixels in a given image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The image of which the position of the maximum of all pixels will be determined. [const Array::Pointer &]

return:: std::vector<float>

auto maximum_position_func(const Device::Pointer &device, const Array::Pointer &src) -> std::vector<float>

mean_of_all_pixels

Determines the mean average of all pixels in a given image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The image of which the mean average of all pixels will be determined. [const Array::Pointer &]

return:: float

auto mean_of_all_pixels_func(const Device::Pointer &device, const Array::Pointer &src) -> float

minimum_position

Determines the position of the minimum of all pixels in a given image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: The image of which the position of the minimum of all pixels will be determined. [const Array::Pointer &]

return:: std::vector<float>

auto minimum_position_func(const Device::Pointer &device, const Array::Pointer &src) -> std::vector<float>

morphological_chan_vese

Compute an active contour model using the Chan-Vese morphological algorithm. The output image (dst) should also be initialisation of the contour. If not provided (nullptr), the function will use a checkboard pattern initialisation.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process. [const Array::Pointer &]
param dst:: Output contour, can also be use to provide initialisation. [Array::Pointer ( = None )]
param num_iter:: Number of iterations. [int ( = 100 )]
param smoothing:: Number of smoothing iterations. [int ( = 1 )]
param lambda1:: Lambda1. [float ( = 1 )]
param lambda2:: Lambda2. [float ( = 1 )]

return:: Array::Pointer

auto morphological_chan_vese_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int num_iter, int smoothing, float lambda1, float lambda2) -> Array::Pointer

statistics_of_labelled_pixels

Compute the bounding box, area (in pixels/voxels), minimum intensity, maximum intensity, average intensity, standard deviation of the intensity, and some shape descriptors of labelled objects in a label image and its corresponding intensity image.

The intensity image is equal to the label image if not provided. The label image is set to the entire image if not provided.

param device:: Device to perform the operation on. [const Device::Pointer &]
param intensity:: Intensity image. [Array::Pointer ( = None )]
param label:: Label image to compute the statistics. [Array::Pointer ( = None )]]

return:: StatisticsMap

auto statistics_of_labelled_pixels_func(const Device::Pointer &device, Array::Pointer intensity, Array::Pointer label) -> StatisticsMap

statistics_of_background_and_labelled_pixels

Compute, for the background and labels, the bounding box, area (in pixels/voxels), minimum intensity, maximum intensity, average intensity, standard deviation of the intensity, and some shape descriptors of labelled objects in a label image and its corresponding intensity image.

The intensity image is equal to the label image if not provided. The label image is set to the entire image if not provided.

param device:: Device to perform the operation on. [const Device::Pointer &]
param intensity:: Intensity image. [Array::Pointer ( = None )]
param label:: Label image to compute the statistics. [Array::Pointer ( = None )]]

return:: StatisticsMap

auto statistics_of_background_and_labelled_pixels_func(const Device::Pointer &device, Array::Pointer intensity, Array::Pointer label) -> StatisticsMap

tier4

namespace tier4

Namespace container for all functions of tier 4 category Tier 4 functions are advanced functions that may rely on previous tier functions.

label_bounding_box

Determines the bounding box of the specified label from a label image. The positions are returned in an array of 6 values as follows: minX, minY, minZ, maxX, maxY, maxZ.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image [const Array::Pointer &]
param label_id:: Identifier of label [int]

return:: std::vector<float>

auto label_bounding_box_func(const Device::Pointer &device, const Array::Pointer &src, int label_id) -> std::vector<float>

mean_squared_error

Determines the mean squared error (MSE) between two images. The MSE will be stored in a new row of ImageJs Results table in the column ‘MSE’.

Note

‘in assistant’, ‘combine’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First image to compare [const Array::Pointer &]
param src1:: Second image to compare [const Array::Pointer &]

return:: float

auto mean_squared_error_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1) -> float

spots_to_pointlist

Transforms a spots image as resulting from maximum/minimum detection in an image where every column contains d pixels (with d = dimensionality of the original image) with the coordinates of the maxima/minima.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input binary image of spots [const Array::Pointer &]
param dst:: Output coordinate list of spots [Array::Pointer ( = None )]

return:: Array::Pointer

auto spots_to_pointlist_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

relabel_sequential

Analyses a label map and if there are gaps in the indexing (e.g. label 5 is not present) all subsequent labels will be relabelled. Thus, afterwards number of labels and maximum label index are equal. This operation is mostly performed on the CPU.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param blocksize:: Renumbering is done in blocks for performance reasons. [int ( = 4096 )]

return:: Array::Pointer

auto relabel_sequential_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int blocksize) -> Array::Pointer

threshold_otsu

Binarizes an image using Otsu’s threshold method [3] implemented in scikit-image[2] using a histogram determined on the GPU to create binary images.

Note

‘binarize’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to threshold. [const Array::Pointer &]
param dst:: Output binary image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto threshold_otsu_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

mean_intensity_map

Takes an image and a corresponding label map, determines the mean intensity per label and replaces every label with the that number.

This results in a parametric image expressing mean object intensity.

Note

‘label measurement’, ‘map’, ‘in assistant’, ‘combine’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: intensity image [const Array::Pointer &]
param labels:: label image [const Array::Pointer &]
param dst:: Parametric image computed[Array::Pointer ( = None )]

return:: Array::Pointer

auto mean_intensity_map_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &labels, Array::Pointer dst) -> Array::Pointer

pixel_count_map

Takes a label map, determines the number of pixels per label and replaces every label with the that number. This results in a parametric image expressing area or volume.

Note

‘label measurement’, ‘map’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image to measure [const Array::Pointer &]
param dst:: Parametric image computed[Array::Pointer ( = None )]

return:: Array::Pointer

auto pixel_count_map_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

label_pixel_count_map

Takes a label map, determines the number of pixels per label and replaces every label with the that number. This results in a parametric image expressing area or volume.

Deprecated:: This function is deprecated. Use pixel_count_map_func instead.

Note

‘label measurement’, ‘map’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image to measure [const Array::Pointer &]
param dst:: Parametric image computed[Array::Pointer ( = None )]

return:: Array::Pointer

auto label_pixel_count_map_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

centroids_of_labels

Determines the centroids of all labels in a label image or image stack. It writes the resulting coordinates in point list image of dimensions n * d where n is the number of labels and d=3 the dimensionality (x,y,z) of the original image.

param device:: Device to perform the operation on. [const Device::Pointer &]
param label_image:: Label image where the centroids will be determined from. [const Array::Pointer &]
param centroids_coordinates:: Output list of coordinates where the centroids will be written to. [Array::Pointer ( = None )]
param include_background:: Determines if the background label should be included. [bool ( = False )]

return:: Array::Pointer

auto centroids_of_labels_func(const Device::Pointer &device, const Array::Pointer &label_image, Array::Pointer centroids_coordinates, bool include_background) -> Array::Pointer

remove_labels_with_map_values_out_of_range

Remove labels with values outside a given value range based on a vector of values associated with the labels.

Note

‘label processing’, ‘combine’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image where labels will be filtered. [const Array::Pointer &]
param values:: Vector of values associated with the labels. [const Array::Pointer &]
param dst:: Output image where labels will be written to. [Array::Pointer ( = None )]
param min_value:: Minimum value to keep. [float ( = 0 )]
param max_value:: Maximum value to keep. [float ( = 100 )]

return:: Array::Pointer

auto remove_labels_with_map_values_out_of_range_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &values, Array::Pointer dst, float min_value, float max_value) -> Array::Pointer

remove_labels_with_map_values_within_range

Remove labels with values inside a given value range based on a vector of values associated with the labels.

Note

‘label processing’, ‘combine’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image where labels will be filtered. [const Array::Pointer &]
param values:: Vector of values associated with the labels. [const Array::Pointer &]
param dst:: Output image where labels will be written to. [Array::Pointer ( = None )]
param min_value:: Minimum value to keep. [float ( = 0 )]
param max_value:: Maximum value to keep. [float ( = 100 )]

return:: Array::Pointer

auto remove_labels_with_map_values_within_range_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &values, Array::Pointer dst, float min_value, float max_value) -> Array::Pointer

exclude_labels_with_map_values_out_of_range

Exclude labels with values outside a given value range based on a vector of values associated with the labels.

Deprecated:: This function is deprecated. Use remove_labels_with_map_values_out_of_range_func instead.

Note

‘label processing’, ‘combine’

param device:: Device to perform the operation on. [const Device::Pointer &]
param values_map:: Vector of values associated with the labels. [const Array::Pointer &]
param label_map_input:: Input image where labels will be filtered. [const Array::Pointer &]
param dst:: Output image where labels will be written to. [Array::Pointer ( = None )]
param minimum_value_range:: Minimum value to keep. [float ( = 0 )]
param maximum_value_range:: Maximum value to keep. [float ( = 100 )]

return:: Array::Pointer

auto exclude_labels_with_map_values_out_of_range_func(const Device::Pointer &device, const Array::Pointer &values_map, const Array::Pointer &label_map_input, Array::Pointer dst, float minimum_value_range, float maximum_value_range) -> Array::Pointer

exclude_labels_with_map_values_within_range

Exclude labels with values inside a given value range based on a vector of values associated with the labels.

Deprecated:: This function is deprecated. Use remove_labels_with_values_within_range_func instead.

Note

‘label processing’, ‘combine’

param device:: Device to perform the operation on. [const Device::Pointer &]
param values_map:: Vector of values associated with the labels. [const Array::Pointer &]
param label_map_input:: Input image where labels will be filtered. [const Array::Pointer &]
param dst:: Output image where labels will be written to. [Array::Pointer ( = None )]
param minimum_value_range:: Minimum value to keep. [float ( = 0 )]
param maximum_value_range:: Maximum value to keep. [float ( = 100 )]

return:: Array::Pointer

auto exclude_labels_with_map_values_within_range_func(const Device::Pointer &device, const Array::Pointer &values_map, const Array::Pointer &label_map_input, Array::Pointer dst, float minimum_value_range, float maximum_value_range) -> Array::Pointer

extension_ratio_map

Determines the ratio of the extension for every label in a label map and returns it as a parametric map.

The extension ration is defined as the maximum distance of any pixel in the label to the label’s centroid divided by the average distance of all pixels in the label to the centroid.

Note

‘label processing’, ‘in assistant’, ‘map’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image. [const Array::Pointer &]
param dst:: Output parametric image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto extension_ratio_map_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

tier5

namespace tier5

Namespace container for all functions of tier 5 category Tier 5 functions are advanced functions that may rely on previous tier functions.

array_equal

Compares if all pixels of two images are identical. If shape of the images or any pixel are different, returns False. True otherwise This function is supposed to work similarly like its counterpart in numpy [1].

Note

‘combine’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: First array to compare [const Array::Pointer &]
param src1:: Second array to compare [const Array::Pointer &]

return:: bool

auto array_equal_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1) -> bool

combine_labels

Combines two label images by adding labels of a given label image to another. Labels in the second image overwrite labels in the first passed image. Afterwards, labels are relabeled sequentially.

Note

‘label processing’, ‘combine labels’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: label image to add labels to. [const Array::Pointer &]
param src1:: label image to add labels from. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]

return:: Array::Pointer

auto combine_labels_func(const Device::Pointer &device, const Array::Pointer &src0, const Array::Pointer &src1, Array::Pointer dst) -> Array::Pointer

connected_components_labeling

Performs connected components analysis inspecting the box neighborhood of every pixel to a binary image and generates a label map.

Deprecated:: This method is deprecated. Consider using connected_component_labeling() instead.

Note

‘label’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Binary image to label. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param connectivity:: Defines pixel neighborhood relationship, “box” or “sphere”. [const std::string & ( = ‘box’ )]

return:: Array::Pointer

auto connected_components_labeling_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, const std::string &connectivity) -> Array::Pointer

connected_component_labeling

Performs connected components analysis inspecting the box neighborhood of every pixel to a binary image and generates a label map.

Note

‘label’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Binary image to label. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param connectivity:: Defines pixel neighborhood relationship, “box” or “sphere”. [const std::string & ( = ‘box’ )]

return:: Array::Pointer

auto connected_component_labeling_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, const std::string &connectivity) -> Array::Pointer

reduce_labels_to_centroids

Take a label map and reduce each label to its centroid.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image to reduce. [const Array::Pointer &]
param dst:: Output label image with centroids. [Array::Pointer ( = None )]

return:: Array::Pointer

auto reduce_labels_to_centroids_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst) -> Array::Pointer

filter_label_by_size

Filter labelled objects outside of the min/max size range value.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param minimum_size:: Minimum size of labels to keep. [float ( = 0 )]
param maximum_size:: Maximum size of labels to keep. [float ( = 100 )]

return:: Array::Pointer

auto filter_label_by_size_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float minimum_size, float maximum_size) -> Array::Pointer

exclude_labels_outside_size_range

Filter labelled objects outside of the min/max size range value.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param minimum_size:: Minimum size of labels to keep. [float ( = 0 )]
param maximum_size:: Maximum size of labels to keep. [float ( = 100 )]

return:: Array::Pointer

auto exclude_labels_outside_size_range_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float minimum_size, float maximum_size) -> Array::Pointer

tier6

namespace tier6

Namespace container for all functions of tier 6 category Tier 6 functions are advanced functions that may rely on previous tier functions.

dilate_labels

Dilates labels to a larger size. No label overwrites another label. Similar to the implementation in scikitimage [2] and MorpholibJ[3] Notes * This operation assumes input images are isotropic.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image to erode [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]
param radius:: [int ( = 2 )]

return:: Array::Pointer

auto dilate_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int radius) -> Array::Pointer

erode_labels

Erodes labels to a smaller size. Note: Depending on the label image and the radius, labels may disappear and labels may split into multiple islands. Thus, overlapping labels of input and output may not have the same identifier. Notes * This operation assumes input images are isotropic.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]
param radius:: [int ( = 1 )]
param relabel:: Relabel the image, e.g. if object disappear or split. [bool ( = False )]

return:: Array::Pointer

auto erode_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int radius, bool relabel) -> Array::Pointer

gauss_otsu_labeling

Labels objects directly from grey-value images.

The outline_sigma parameter allows tuning the segmentation result. Under the hood, this filter applies a Gaussian blur, Otsu-thresholding [1] and connected component labeling [2]. The thresholded binary image is flooded using the Voronoi tesselation approach starting from the found local maxima.

Note

‘label’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src0:: Intensity image to segment [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param outline_sigma:: Gaussian blur sigma along all axes [float ( = 0 )]

return:: Array::Pointer

auto gauss_otsu_labeling_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float outline_sigma) -> Array::Pointer

masked_voronoi_labeling

Takes a binary image, labels connected components and dilates the regions using a octagon shape until they touch. The region growing is limited to a masked area. The resulting label map is written to the output.

Note

‘label’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input binary image [const Array::Pointer &]
param mask:: Input mask [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]

return:: Array::Pointer

auto masked_voronoi_labeling_func(const Device::Pointer &device, const Array::Pointer &src, const Array::Pointer &mask, Array::Pointer dst) -> Array::Pointer

voronoi_labeling

Takes a binary image, labels connected components and dilates the regions using a octagon shape until they touch. The resulting label map is written to the output.

Note

‘label’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param input_binary:: Input binary image [const Array::Pointer &]
param output_labels:: Output label image [Array::Pointer ( = None )]

return:: Array::Pointer

auto voronoi_labeling_func(const Device::Pointer &device, const Array::Pointer &input_binary, Array::Pointer output_labels) -> Array::Pointer

remove_small_labels

Removes labelled objects small than a given size (in pixels) from a label map.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image to filter. [const Array::Pointer &]
param dst:: Output label image filtered. [Array::Pointer ( = None )]
param minimum_size:: Smallest size object allowed. [float ( = 100 )]

return:: Array::Pointer

auto remove_small_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float minimum_size) -> Array::Pointer

exclude_small_labels

Removes labels from a label map which are below a given maximum size.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image to filter. [const Array::Pointer &]
param dst:: Output label image filtered. [Array::Pointer ( = None )]
param maximum_size:: Largest size object to exclude. [float ( = 100 )]

return:: Array::Pointer

auto exclude_small_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float maximum_size) -> Array::Pointer

remove_large_labels

Removes labeled objects bigger than a given size (in pixels) from a label map.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image to filter. [const Array::Pointer &]
param dst:: Output label image filtered. [Array::Pointer ( = None )]
param maximum_size:: Biggest size object allowed. [float ( = 100 )]

return:: Array::Pointer

auto remove_large_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float maximum_size) -> Array::Pointer

exclude_large_labels

Removes labels from a label map which are higher a given minimum size.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Label image to filter. [const Array::Pointer &]
param dst:: Output label image filtered. [Array::Pointer ( = None )]
param minimum_size:: Smallest size object to keep. [float ( = 100 )]

return:: Array::Pointer

auto exclude_large_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float minimum_size) -> Array::Pointer

tier7

namespace tier7

Namespace container for all functions of tier 7 category Tier 7 functions are advanced functions that may rely on previous tier functions.

affine_transform

Apply an affine transformation matrix to an array and return the result. The transformation matrix must be 3x3 or 4x4 stored as a 1D array. The matrix should be row-major, i.e. the first 3 elements are the first row of the matrix. If no matrix is given, the identity matrix will be used.

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to be transformed. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param transform_matrix:: Affine transformation matrix (3x3 or 4x4). [std::vector<float> * ( = None )]
param interpolate:: If true, bi/trilinear interpolation will be applied, if hardware allows. [bool ( = False )]
param resize:: Automatically determines the size of the output depending on the rotation angles. [bool ( = False )]

return:: Array::Pointer

auto affine_transform_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, std::vector<float> *transform_matrix, bool interpolate, bool resize) -> Array::Pointer

eroded_otsu_labeling

Segments and labels an image using blurring, Otsu-thresholding, binary erosion and masked Voronoi-labeling.

After bluring and Otsu-thresholding the image, iterative binary erosion is applied. Objects in the eroded image are labeled and the labels are extended to fit again into the initial binary image using masked-Voronoi labeling.

This function is similar to voronoi_otsu_labeling. It is intended to deal better in case labels of objects swapping into each other if objects are dense. Like when using Voronoi-Otsu-labeling, small objects may disappear when applying this operation.

This function is inspired by a similar implementation in Java by Jan Brocher (Biovoxxel) [0] [1]

Note

‘label’, ‘in assistant’

See also

https://github.com/biovoxxel/bv3dbox (BV_LabelSplitter.java::L83)

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to be transformed. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param number_of_erosions:: Number of iteration of erosion. [int ( = 5 )]
param outline_sigma:: Gaussian blur sigma applied before Otsu thresholding. [float ( = 2 )]

return:: Array::Pointer

auto eroded_otsu_labeling_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int number_of_erosions, float outline_sigma) -> Array::Pointer

rigid_transform

Translate the image by a given vector and rotate it by given angles. Angles are given in degrees. To convert radians to degrees, use this formula: angle_in_degrees = angle_in_radians / numpy.pi * 180.0

Note

‘transform’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to be transformed. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param translate_x:: Translation along x axis in pixels. [float ( = 0 )]
param translate_y:: Translation along y axis in pixels. [float ( = 0 )]
param translate_z:: Translation along z axis in pixels. [float ( = 0 )]
param angle_x:: Rotation around x axis in radians. [float ( = 0 )]
param angle_y:: Rotation around y axis in radians. [float ( = 0 )]
param angle_z:: Rotation around z axis in radians. [float ( = 0 )]
param centered:: If true, rotate image around center, else around the origin. [bool ( = True )]
param interpolate:: If true, bi/trilinear interpolation will be applied, if hardware allows. [bool ( = False )]
param resize:: Automatically determines the size of the output depending on the rotation angles. [bool ( = False )]

return:: Array::Pointer

auto rigid_transform_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float translate_x, float translate_y, float translate_z, float angle_x, float angle_y, float angle_z, bool centered, bool interpolate, bool resize) -> Array::Pointer

rotate

Rotate the image by given angles. Angles are given in degrees. To convert radians to degrees, use this formula: angle_in_degrees = angle_in_radians / numpy.pi * 180.0

Note

‘transform’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to be rotated. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param angle_x:: Rotation around x axis in degrees. [float ( = 0 )]
param angle_y:: Rotation around y axis in degrees. [float ( = 0 )]
param angle_z:: Rotation around z axis in degrees. [float ( = 0 )]
param centered:: If true, rotate image around center, else around the origin. [bool ( = True )]
param interpolate:: If true, bi/trilinear interpolation will be applied, if hardware allows. [bool ( = False )]
param resize:: Automatically determines the size of the output depending on the rotation angles. [bool ( = False )]

return:: Array::Pointer

auto rotate_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float angle_x, float angle_y, float angle_z, bool centered, bool interpolate, bool resize) -> Array::Pointer

scale

Scale the image by given factors.

Note

‘transform’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to be scaled. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param factor_x:: Scaling along x axis. [float ( = 1 )]
param factor_y:: Scaling along y axis. [float ( = 1 )]
param factor_z:: Scaling along z axis. [float ( = 1 )]
param centered:: If true, the image will be scaled to the center of the image. [bool ( = True )]
param interpolate:: If true, bi/trilinear interplation will be applied. [bool ( = False )]
param resize:: Automatically determines output size image. [bool ( = False )]

return:: Array::Pointer

auto scale_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float factor_x, float factor_y, float factor_z, bool centered, bool interpolate, bool resize) -> Array::Pointer

translate

Translate the image by a given vector.

Note

‘transform’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to be translated. [const Array::Pointer &]
param dst:: Output image. [Array::Pointer ( = None )]
param translate_x:: Translation along x axis in pixels. [float ( = 0 )]
param translate_y:: Translation along y axis in pixels. [float ( = 0 )]
param translate_z:: Translation along z axis in pixels. [float ( = 0 )]
param interpolate:: If true, bi/trilinear interplation will be applied. [bool ( = False )]

return:: Array::Pointer

auto translate_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float translate_x, float translate_y, float translate_z, bool interpolate) -> Array::Pointer

closing_labels

Apply a morphological closing operation to a label image. The operation consists of iterative dilation and erosion of the labels. With every iteration, box and diamond/sphere structuring elements are used and thus, the operation has an octagon as structuring element. Notes * This operation assumes input images are isotropic.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param radius:: Radius size for the closing. [int ( = 0 )]

return:: Array::Pointer

auto closing_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int radius) -> Array::Pointer

erode_connected_labels

Erodes labels to a smaller size. Note: Depending on the label image and the radius, labels may disappear and labels may split into multiple islands. Thus, overlapping labels of input and output may not have the same identifier.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input image to process [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]
param radius:: [int ( = 1 )]

return:: Array::Pointer

auto erode_connected_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int radius) -> Array::Pointer

opening_labels

Apply a morphological opening operation to a label image. The operation consists of iterative erosion and dilation of the labels. With every iteration, box and diamond/sphere structuring elements are used and thus, the operation has an octagon as structuring element. Notes * This operation assumes input images are isotropic.

Note

‘label processing’, ‘in assistant’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param radius:: Radius size for the opening. [int ( = 0 )]

return:: Array::Pointer

auto opening_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int radius) -> Array::Pointer

voronoi_otsu_labeling

Labels objects directly from greyvalue images. The two sigma parameters allow tuning the segmentation result. Under the hood, this filter applies two Gaussian blurs, spot detection, Otsuthresholding [2] and Voronoilabeling [3]. The thresholded binary image is flooded using the Voronoi tesselation approach starting from the found local maxima. Notes * This operation assumes input images are isotropic.

Note

‘label’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input intensity image. [const Array::Pointer &]
param dst:: Output label image. [Array::Pointer ( = None )]
param spot_sigma:: Controls how close detected cells can be. [float ( = 2 )]
param outline_sigma:: Controls how precise segmented objects are outlined. [float ( = 2 )]

return:: Array::Pointer

auto voronoi_otsu_labeling_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, float spot_sigma, float outline_sigma) -> Array::Pointer

tier8

namespace tier8

Namespace container for all functions of tier 8 category Tier 8 functions are advanced functions that may rely on previous tier functions.

smooth_labels

Apply a morphological opening operation to a label image and afterwards fills gaps between the labels using voronoi-labeling. Finally, the result label image is masked so that all background pixels remain background pixels.

Note: It is recommended to process isotropic label images.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]
param radius:: Smoothing radius.[int ( = 0 )]

return:: Array::Pointer

auto smooth_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int radius) -> Array::Pointer

smooth_connected_labels

Apply a morphological erosion and dilation of the label image with respect to the connectivity of the labels.

Note: It is recommended to process isotropic label images.

Note

‘label processing’, ‘in assistant’, ‘bia-bob-suggestion’

param device:: Device to perform the operation on. [const Device::Pointer &]
param src:: Input label image [const Array::Pointer &]
param dst:: Output label image [Array::Pointer ( = None )]
param radius:: Smoothing radius. [int ( = 0 )]

return:: Array::Pointer

auto smooth_connected_labels_func(const Device::Pointer &device, const Array::Pointer &src, Array::Pointer dst, int radius) -> Array::Pointer