From bfe7f32bd9341980e3e14375a1164ff7997f6c01 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Mon, 29 Apr 2024 17:38:55 +0200 Subject: [PATCH 1/3] remove functions from list of bia-bob suggestions --- .../generate_bia_bob_connector.ipynb | 358 +++--------------- pyclesperanto_prototype/_bia_bob_plugins.py | 288 +++----------- pyclesperanto_prototype/_tier1/_absolute.py | 2 +- pyclesperanto_prototype/_tier1/_binary_and.py | 2 +- pyclesperanto_prototype/_tier1/_binary_or.py | 2 +- .../_tier1/_binary_subtract.py | 2 +- pyclesperanto_prototype/_tier1/_binary_xor.py | 2 +- .../_tier1/_count_touching_neighbors.py | 2 +- .../_tier1/_dilate_sphere.py | 2 +- pyclesperanto_prototype/_tier1/_draw_box.py | 2 +- pyclesperanto_prototype/_tier1/_draw_line.py | 2 +- .../_tier1/_draw_sphere.py | 2 +- .../_tier1/_erode_sphere.py | 2 +- .../_tier1/_generate_distance_matrix.py | 2 +- .../_tier1/_generate_touch_matrix.py | 2 +- .../_tier1/_laplace_box.py | 2 +- .../_tier1/_laplace_diamond.py | 2 +- pyclesperanto_prototype/_tier1/_mask.py | 2 +- pyclesperanto_prototype/_tier1/_mask_label.py | 2 +- .../_tier1/_maximum_image_and_scalar.py | 2 +- .../_tier1/_maximum_images.py | 2 +- .../_tier1/_modulo_images.py | 2 +- .../_read_intensities_from_positions.py | 2 +- .../_standard_deviation_z_projection.py | 2 +- .../_tier1/_variance_sphere.py | 2 +- .../_tier2/_bottom_hat_sphere.py | 2 +- .../_tier2/_combine_horizontally.py | 2 +- .../_tier2/_combine_vertically.py | 2 +- .../_tier2/_concatenate_stacks.py | 2 +- .../_tier2/_label_spots.py | 2 +- .../_tier2/_opening_sphere.py | 2 +- .../_tier2/_pointlist_to_labelled_spots.py | 2 +- .../_tier2/_reduce_stack.py | 2 +- .../_tier2/_standard_deviation_sphere.py | 2 +- pyclesperanto_prototype/_tier2/_sub_stack.py | 2 +- .../_tier3/_absolute_difference.py | 2 +- .../_tier3/_divide_by_gaussian_background.py | 2 +- .../_exclude_labels_outside_size_range.py | 2 +- ...exclude_labels_with_values_out_of_range.py | 2 +- ...exclude_labels_with_values_within_range.py | 2 +- .../_tier3/_labelled_spots_to_pointlist.py | 2 +- .../_tier3/_squared_difference.py | 2 +- .../_tier4/_erode_connected_labels.py | 2 +- .../_tier4/_extend_labeling_via_voronoi.py | 2 +- ...nded_depth_of_focus_variance_projection.py | 2 +- .../_tier4/_mean_squared_error.py | 2 +- .../_tier4/_proximal_neighbor_count_map.py | 2 +- .../_tier4/_touching_neighbor_count_map.py | 2 +- .../_tier5/_closing_labels.py | 2 +- .../_tier5/_masked_voronoi_labeling.py | 2 +- .../_tier5/_opening_labels.py | 2 +- ...bels_with_border_intensity_within_range.py | 2 +- .../_tier8/_rigid_transform.py | 2 +- ...age_distance_of_n_nearest_neighbors_map.py | 2 +- .../_tier9/_average_neighbor_distance_map.py | 2 +- .../_tier9/_eroded_otsu_labeling.py | 2 +- .../_tier9/_gauss_otsu_labeling.py | 2 +- 57 files changed, 145 insertions(+), 611 deletions(-) diff --git a/demo/interoperability/generate_bia_bob_connector.ipynb b/demo/interoperability/generate_bia_bob_connector.ipynb index cb51e19b..00617cea 100644 --- a/demo/interoperability/generate_bia_bob_connector.ipynb +++ b/demo/interoperability/generate_bia_bob_connector.ipynb @@ -49,441 +49,175 @@ "name": "stdout", "output_type": "stream", "text": [ - "- Computes the absolute value of every individual pixel in a given image.\n", - "cle.absolute(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Determines the absolute difference pixel by pixel between two images.\n", - "cle.absolute_difference(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Replace label map with the average distance to the n closest neighboring labels, given a label map, distance map, and n.\n", - "cle.average_distance_of_n_nearest_neighbors_map(labels: ndarray, distance_map: ndarray = None, n: int = 1) -> ndarray\n", - "\n", - "\n", - "- Replaces every label in the label map with the average distance to the n closest neighboring labels\n", - "cle.average_distance_of_n_nearest_neighbors_map(labels: ndarray, distance_map: ndarray = None, n: int = 1) -> ndarray\n", - "\n", - "\n", - "- Replaces labels in a label map with the average distance to neighboring labels.\n", - "cle.average_neighbor_distance_map(labels: ndarray, distance_map: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Compute a binary image from two input images by connecting pairs of pixels with the binary AND operator &.\n", - "cle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Identify and set the surface pixels of binary objects to 1 in the destination image, while setting all other pixels to 0.\n", + "* Set only surface pixels to 1 in destination binary image\n", "cle.binary_edge_detection(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Compute a binary image by connecting corresponding pixels from two input images using the binary AND operator.\n", - "cle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Compute a binary image by negating the pixel values of an input image, interpreting all non-zero values as 1.\n", + "* Create a binary image by inverting pixel values in an input image, where all non-zero pixels become 0 and zeros become 1\n", "cle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Compute a binary image from two input images by connecting pairs of pixels with the binary OR operator.\n", - "cle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "Subtract one binary image from another.\n", - "cle.binary_subtract(minuend: ndarray, subtrahend: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Computes a binary image from two input images by connecting pairs of pixels with the binary OR operator.\n", - "cle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "* Connects pairs of pixels from two input images X and Y using binary operators (AND, OR, NOT, XOR) to compute a binary image\n", - "cle.binary_xor(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Applies a bottom-hat filter for background subtraction to the input image.\n", - "cle.bottom_hat_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\n", - "\n", - "\n", - "- Determines the centroids of all labels in a label image or image stack and writes the resulting coordinates in a pointlist image\n", + "* Determines centroids of all labels in an image and writes coordinates in a pointlist image\n", "cle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray\n", "\n", "\n", - "- This function analyzes a label map and relabels subsequent labels if there are gaps in the indexing.\n", + "- Analyses a label map to ensure that all labels are indexed without gaps before returning the relabeled map.\n", "cle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray\n", "\n", "\n", - "Apply a morphological closing operation to a label image.\n", - "cle.closing_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray\n", - "\n", - "\n", - "- Applies morphological closing to intensity or binary images using a sphere-shaped footprint.\n", + "* Apply morphological closing with a sphere-shaped footprint to intensity or binary images.\n", "cle.closing_sphere(input_image: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> ndarray\n", "\n", "\n", - "* combine two images or stacks in X where the output is a destination image.\n", - "cle.combine_horizontally(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Combine two label images by adding labels of one image to another\n", - "- Overwrite labels in the first image with labels from the second image\n", - "- Relabel the combined image sequentially\n", + "- Combines two label images by adding labels from one image to another and sequentially relabeling the result\n", "cle.combine_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Combine two images or stacks in the Y direction.\n", - "cle.combine_vertically(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "* concatenate two stacks in Z\n", - "cle.concatenate_stacks(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Performs connected components analysis on a binary image, generating a label map.\n", - "cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\n", - "\n", + "- Performs connected components analysis inspecting the box neighborhood of every pixel in a binary image, generating a label map\n", + "cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\n", "\n", - "- Computes the number of touching neighbors per label in a touch matrix\n", - "cle.count_touching_neighbors(touch_matrix: ndarray, touching_neighbors_count_destination: ndarray = None, ignore_background: bool = True) -> ndarray\n", "\n", - "\n", - "- Create an image where the pixels on label edges are set to 1 and all other pixels are set to 0, given a labelmap image\n", + "- Takes a labelmap and sets edge pixels to 1 and others to 0\n", "cle.detect_label_edges(label_source: ndarray, binary_destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Apply Gaussian blur to an input image twice with different sigma values and subtract the resulting images from each other\n", + "* Apply Gaussian blur to an input image twice with different sigma values, resulting in two images that are subtracted from each other. It is recommended to apply this operation to images of type Float (32 bit).\n", "cle.difference_of_gaussian(source: ndarray, destination: ndarray = None, sigma1_x: float = 2, sigma1_y: float = 2, sigma1_z: float = 2, sigma2_x: float = 2, sigma2_y: float = 2, sigma2_z: float = 2) -> ndarray\n", "\n", "\n", - "* Dilates labels to a larger size without overwriting another label, assuming input images are isotropic.\n", + "* Dilates label images to a larger size without overwriting other labels, assuming input images are isotropic.\n", "cle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray\n", "\n", "\n", - "- Computes the binary dilation of a given input image using the von-Neumann-neighborhood.\n", - "cle.dilate_sphere(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Applies Gaussian blur to an image and divides the original by the result\n", - "cle.divide_by_gaussian_background(source: ndarray, destination: ndarray = None, sigma_x: float = 2, sigma_y: float = 2, sigma_z: float = 2) -> ndarray\n", - "\n", - "\n", - "- Draws a box on an image at a specified position and size, leaving all other pixels untouched\n", - "cle.draw_box(destination: ndarray, x: int = 0, y: int = 0, z: int = 0, width: int = 1, height: int = 1, depth: int = 1, value: float = 1) -> ndarray\n", - "\n", - "\n", - "* Draw a line between two points with a given thickness\n", - "cle.draw_line(destination: ndarray, x1: float = 0, y1: float = 0, z1: float = 0, x2: float = 1, y2: float = 1, z2: float = 1, thickness: float = 1, value: float = 1) -> ndarray\n", - "\n", - "\n", - "- Draws a sphere around a given point with given radii in x, y, and z, if 3D, leaving all other pixels untouched.\n", - "cle.draw_sphere(destination: ndarray, x: float = 0, y: float = 0, z: float = 0, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1, value: float = 1) -> ndarray\n", - "\n", - "\n", - "- Erodes labels to a smaller size\n", - "cle.erode_connected_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 1) -> ndarray\n", - "\n", - "\n", - "- Compute a binary image representing the binary erosion of an input image\n", - "cle.erode_sphere(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Segments and labels an image using blurring, Otsu-thresholding, binary erosion, and masked Voronoi-labeling\n", - "cle.eroded_otsu_labeling(image: ndarray, labels_destination: ndarray = None, number_of_erosions: int = 5, outline_sigma: float = 2) -> ndarray\n", - "\n", - "\n", - "- Remove labels from a label map that touch the edges of the image, and renumber the remaining labels.\n", + "* Removes labels touching edges of the image in X, Y, and Z; renumbers remaining labels; allows exclusion along min and max X, Y, and Z axes\n", "cle.exclude_labels_on_edges(label_map_input: ndarray, label_map_destination: ndarray = None, exclude_in_x: bool = True, exclude_in_y: bool = True, exclude_in_z: bool = True, exlude_in_x: bool = None, exlude_in_y: bool = None, exlude_in_z: bool = None) -> ndarray\n", "\n", "\n", - "- Removes labels from a label map based on their size, specified by a minimum and maximum number of pixels or voxels per label.\n", - "cle.exclude_labels_outside_size_range(source: ndarray, destination: ndarray = None, minimum_size: float = 0, maximum_size: float = 100) -> ndarray\n", - "\n", - "\n", - "- Removes labels from a label map based on their size in terms of pixel or voxel count.\n", - "cle.exclude_labels_outside_size_range(source: ndarray, destination: ndarray = None, minimum_size: float = 0, maximum_size: float = 100) -> ndarray\n", - "\n", - "\n", - "- Remove labels from a labelmap and renumber the remaining labels\n", - "cle.exclude_labels_with_values_out_of_range(values_vector: ndarray, label_map_input: ndarray, label_map_destination: ndarray = None, minimum_value_range: float = 0, maximum_value_range: float = 100) -> ndarray\n", - "\n", - "\n", - "- Remove labels from a labelmap and renumber the remaining labels\n", - "cle.exclude_labels_with_values_within_range(values_vector: ndarray, label_map_input: ndarray, label_map_destination: ndarray = None, minimum_value_range: float = 0, maximum_value_range: float = 100) -> ndarray\n", - "\n", - "\n", - "* Removes labels from a label map based on their size\n", + "* Removes labels from a label map above a given maximum size \n", "cle.exclude_large_labels(source: ndarray, destination: ndarray = None, minimum_size: float = 100) -> ndarray\n", "\n", "\n", - "- Removes labels from a label map below a specified maximum size\n", + "* Removes labels from a label map below a specified maximum size by number of pixels or voxels.\n", "cle.exclude_small_labels(source: ndarray, destination: ndarray = None, maximum_size: float = 100) -> ndarray\n", "\n", "\n", - "Takes a label map image and dilates the regions until they touch, and then writes the resulting label map to the output.\n", - "cle.extend_labeling_via_voronoi(labeling_source: ndarray, labeling_destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "* Dilates labels to a larger size without label overwrite, assuming input images are isotropic.\n", + "* Dilates labels in an isotropic label image without overwriting other labels.\n", "cle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray\n", "\n", "\n", - "- Maximizes the local pixel intensity variance by projecting an extended depth of focus\n", - "cle.extended_depth_of_focus_variance_projection(source: ndarray, destination: ndarray = None, radius_x: int = 10, radius_y: int = 10, sigma: float = 5) -> ndarray\n", - "\n", - "\n", - "* compute the absolute value of every individual pixel in a given image\n", - "cle.absolute(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Segment objects in grey-value images by applying a Gaussian blur, Otsu-thresholding, and connected component labeling.\n", - "cle.gauss_otsu_labeling(source: ndarray, label_image_destination: ndarray = None, outline_sigma: float = 2) -> ndarray\n", - "\n", - "\n", - "- Compute the Gaussian blurred image of an image given sigma values in X, Y, and Z.\n", + "* Compute the Gaussian blurred image of an image given sigma values in X, Y, and Z with optional destination and sigma parameters.\n", "cle.gaussian_blur(source: ndarray, destination: ndarray = None, sigma_x: float = 0, sigma_y: float = 0, sigma_z: float = 0) -> ndarray\n", "\n", "\n", - "- Compute the distance between all point coordinates given in two point lists.\n", - "cle.generate_distance_matrix(coordinate_list1: ndarray, coordinate_list2: ndarray, distance_matrix_destination: ndarray = None) -> ndarray\n", + "* Performs connected components analysis on a binary image by inspecting each pixel's neighbors to generate a label map.\n", + "cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\n", "\n", "\n", - "- Generate a touch matrix that represents a region adjacency graph for a labelmap\n", - "cle.generate_touch_matrix(label_map: ndarray, touch_matrix_destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Performs connected components analysis on a binary image, generating a label map\n", - "cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\n", - "\n", - "\n", - "- Determines the centroids of all labels in a label image or image stack and writes the resulting coordinates in a pointlist image.\n", + "- Determines centroids of labels in a label image or image stack, writing resulting coordinates in a pointlist image: label image input, destination image of d*n size for d-dimensional label image with n labels, optional background centroid measurement\n", "cle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray\n", "\n", "\n", - "- Transforms a binary image with single pixels set to 1 to a labeled spots image, or transforms a spots image into an image with numbered spots.\n", - "cle.label_spots(input_spots: ndarray, labelled_spots_destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Generates a coordinate list of points in a labelled spot image.\n", - "cle.labelled_spots_to_pointlist(input_labelled_spots: ndarray, destination_pointlist: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Apply the Laplace operator (Box neighborhood) to an image.\n", - "cle.laplace_box(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Applies the Laplace operator (Diamond neighborhood) to an image.\n", - "cle.laplace_diamond(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Compute a binary image by connecting pairs of pixels from two input images using the binary AND operator.\n", - "cle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Compute a binary image by inverting the pixel values of an input image, interpreting all non-zero values as 1.\n", + "* Computes a binary image by inverting pixel values with the binary NOT operator, treating non-zero values as 1.\n", "cle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Compute a binary image by connecting pairs of pixels from two input images using the binary OR operator |.\n", - "cle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Create a binary image by connecting pairs of pixels from two input images using binary operators AND, OR, NOT, and XOR.\n", - "cle.binary_xor(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "Replaces integer intensities specified in a vector image by mapping them to new values.\n", + "* Replace integer intensities in a 3D vector image with specified values\n", "cle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Computes a masked image by applying a binary mask to an image.\n", - "cle.mask(source: ndarray, mask: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Copy pixel values from one image to another based on a label mask.\n", - "cle.mask_label(source: ndarray, label_map: ndarray, destination: ndarray = None, label_index: int = 1) -> ndarray\n", - "\n", - "\n", - "- Performs label map generation and dilation on a binary image using an octagon shape, within a specified masked area, resulting in a labeled output image.\n", - "cle.masked_voronoi_labeling(binary_source: ndarray, mask_image: ndarray, labeling_destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Compute the maximum pixel value between two images and store the result in a destination image\n", - "cle.maximum_images(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Compute the maximum of a constant scalar and each pixel value in an image.\n", - "cle.maximum_image_and_scalar(source: ndarray, destination: ndarray = None, scalar: float = 0) -> ndarray\n", - "\n", - "\n", - "- Compute the maximum pixel value between two given images and store the result in a destination image.\n", - "cle.maximum_images(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Computes the local maximum of a pixel's spherical neighborhood.\n", + "* Computes the local maximum of a pixel's spherical neighborhood specified by radius in three dimensions.\n", "cle.maximum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 0) -> ndarray\n", "\n", "\n", - "- Determines the maximum intensity projection of an image along the Z-axis.\n", + "* Maximum intensity projection of an image along Z\n", "cle.maximum_z_projection(source: ndarray, destination_max: ndarray = None) -> ndarray\n", "\n", "\n", - "- Computes the local mean average of a pixel's spherical neighborhood\n", + "* Compute the local mean average of a pixel's spherical neighborhood using specified radii dimensions in 3D space.\n", "cle.mean_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\n", "\n", "\n", - "- Determines the mean squared error between two images and stores the result in a new row of ImageJs Results table\n", - "cle.mean_squared_error(source1: ndarray, source2: ndarray) -> float\n", - "\n", - "\n", - "- Determines the mean average intensity projection of an image along the Z-axis.\n", + "* Calculates the mean average intensity projection of an image along Z.\n", "cle.mean_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Compute the mean intensity along borders between labels in an image, then merge labels within a specified intensity range.\n", - "cle.merge_labels_with_border_intensity_within_range(image: ndarray, labels: ndarray, labels_destination: ndarray = None, minimum_intensity: float = 0, maximum_intensity: float = 3.4028235e+38)\n", - "\n", - "\n", - "- Merge and renumber labels in a label image, producing a new label image.\n", + "* takes a label image, merges touching labels, renumbers them, and produces a new label image\n", "cle.merge_touching_labels(labels_input: ndarray, labels_destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Computes the local minimum of a pixels spherical neighborhood specified by its half-width, half-height, and half-depth.\n", + "- Computes the local minimum of a pixels spherical neighborhood with specified radius dimensions\n", "cle.minimum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\n", "\n", "\n", - "- Determine the minimum intensity projection of an image along the Z-axis.\n", + "* Calculates the minimum intensity projection of an image along the Z-axis\n", "cle.minimum_z_projection(source: ndarray, destination_min: ndarray = None) -> ndarray\n", "\n", "\n", - "- Computes the remainder of a division of pairwise pixel values in two images.\n", - "cle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Compute the local mode of a pixels sphere shaped neighborhood\n", + "* Compute the local mode of a pixels sphere shaped neighborhood to locally correct semantic segmentation results of an image, with specified half-width and half-height (radius) of the sphere, and intensities ranging from 0 to 255, returning the smallest value in case of multiple maximum frequency values.\n", "cle.mode_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray\n", "\n", "\n", - "- Compute the remainder of a division of pairwise pixel values in two images\n", - "cle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Apply a morphological opening operation to a label image with an octagon as the structuring element, using iterative erosion and dilation.\n", - "cle.opening_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray\n", - "\n", - "\n", - "- Apply morphological opening to intensity or binary images using a sphere-shaped footprint.\n", - "cle.opening_sphere(input_image: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> ndarray\n", - "\n", - "\n", - "Takes a pointlist with coordinates and labels corresponding pixels\n", - "cle.pointlist_to_labelled_spots(pointlist: ndarray, spots_destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Takes a label map and replaces each label with the number of neighboring labels within a given distance range\n", - "cle.proximal_neighbor_count_map(source: ndarray, destination: ndarray = None, min_distance: float = 0, max_distance: float = 3.4028235e+38) -> ndarray\n", - "\n", - "\n", - "- Read parametric values from label positions in a label image and a parametric image and store the intensity values in a vector\n", + "- Reads intensity values from labeled image positions and stores them in a new vector, taking into consideration certain constraints on label structure.\n", "cle.read_intensities_from_map(labels: ndarray, map_image: ndarray, values_destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Go to positions in an image specified by a pointlist, read intensities of those pixels, and store them in a new vector.\n", - "cle.read_intensities_from_positions(pointlist: ndarray, intensity_image: ndarray, values_destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Reduces label map by taking only the center spots and setting background to zero.\n", + "* Reduce all labels in a label map to their center spots, keeping label IDs intact and setting background to zero.\n", "cle.reduce_labels_to_centroids(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Reduces labels to their edges in a label map\n", + "* reduce all labels in a label map to their edges, maintaining label IDs and setting background to zero\n", "cle.reduce_labels_to_label_edges(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "* Reduce the number of slices in a stack by a factor and control which slices stay by specifying an offset.\n", - "cle.reduce_stack(source: ndarray, destination: ndarray = None, reduction_factor: int = 2, offset: int = 0) -> ndarray\n", - "\n", - "\n", - "- This function analyzes a label map and relabels subsequent labels if there are any gaps in the indexing, resulting in the number of labels and the maximum label index being equal.\n", + "- Analyses and renumbers a label map to fill in any gaps in indexing, ensuring that the number of labels matches the maximum label index\n", "cle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray\n", "\n", "\n", - "- Computes the remainder of a division of pairwise pixel values in two images\n", - "cle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Replaces integer intensities specified in a vector image.\n", + "* Replaces integer intensities specified in a vector image with new values\n", "cle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "Transform an image by translating and rotating it, with optional parameters for interpolation, auto-sizing, and specifying the center of rotation.\n", - "cle.rigid_transform(source: ndarray, destination: ndarray = None, translate_x: float = 0, translate_y: float = 0, translate_z: float = 0, angle_around_x_in_degrees: float = 0, angle_around_y_in_degrees: float = 0, angle_around_z_in_degrees: float = 0, rotate_around_center: bool = True, linear_interpolation: bool = False, auto_size: bool = False) -> ndarray\n", - "\n", - "\n", - "- Apply morphological opening operation and voronoi-labeling to a label image, then mask the result label image\n", + "* Apply morphological opening operation, fill label gaps with voronoi-labeling, and mask background pixels in label image.\n", "cle.smooth_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray\n", "\n", "\n", - "- Convolve an image with the Sobel kernel.\n", + "* Convolve image with Sobel kernel to detect edges in image\n", "cle.sobel(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Compute the squared difference pixel by pixel between two images\n", - "cle.squared_difference(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Computes the local standard deviation of a pixel's neighborhood given a specified box size. The box size is specified by its half-width, half-height, and half-depth (radius).\n", - "cle.standard_deviation_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray\n", - "\n", - "\n", - "- Determines the standard deviation intensity projection of an image stack along Z.\n", - "cle.standard_deviation_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Determines various properties of labelled objects in an image, including bounding box, area, intensity statistics, and shape descriptors.\n", + "* Determines bounding box, area, min, max, mean, standard deviation of intensity and shape descriptors of labelled objects in a label map and corresponding pixels in the original image.\n", "cle.statistics_of_labelled_pixels(intensity_image: ndarray = None, label_image: ndarray = None)\n", "\n", "\n", - "* Crop multiple Z-slices of a 3D stack into a new 3D stack.\n", - "cle.sub_stack(source: ndarray, destination: ndarray = None, start_z: int = 0, end_z: int = 0) -> ndarray\n", - "\n", - "\n", - "- Apply Gaussian blur to an input image and subtract the result from the original image\n", + "* Apply Gaussian blur to input image and subtract from original to create destination image.\n", "cle.subtract_gaussian_background(source: ndarray, destination: ndarray = None, sigma_x: float = 2, sigma_y: float = 2, sigma_z: float = 2) -> ndarray\n", "\n", "\n", - "- Combine two label images by removing labels from one image that also exist in the other image\n", + "Combine two label images by removing overlapping labels from one image that also exist in the other image.\n", "cle.subtract_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Determines the sum intensity projection of an image along Z.\n", + "* Determine the sum intensity projection of an image along Z\n", "cle.sum_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "Binarizes an image using Otsu's threshold method and creates binary images.\n", + "* Binarize an image using Otsu's threshold method implemented in scikit-image, utilizing a GPU-based histogram for binary image creation.\n", "cle.threshold_otsu(source: ndarray, destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Applies a top-hat filter for background subtraction to the input image\n", + "* Apply a top-hat filter for background subtraction to an input image.\n", "cle.top_hat_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\n", "\n", "\n", - "- Takes a label map and replaces each label with the number of neighboring labels it touches.\n", - "cle.touching_neighbor_count_map(source: ndarray, destination: ndarray = None) -> ndarray\n", - "\n", - "\n", - "- Computes the local variance of a pixel's sphere neighborhood, specified by its half-width, half-height, and half-depth (radius), ignoring radius_z if 2D images are given.\n", - "cle.variance_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray\n", - "\n", - "\n", - "* Label connected components in a binary image and dilate the regions until they touch\n", + "* Takes a binary image, labels connected components, dilates regions until they touch, and outputs a label map.\n", "cle.voronoi_labeling(binary_source: ndarray, labeling_destination: ndarray = None) -> ndarray\n", "\n", "\n", - "- Labels objects in grey-value images by applying two Gaussian blurs, spot detection, Otsu-thresholding, and Voronoi-labeling\n", + "- Labels objects in grey-value images using Gaussian blurs, spot detection, Otsu-thresholding, and Voronoi-labeling from isotropic input images.\n", "cle.voronoi_otsu_labeling(source: ndarray, label_image_destination: ndarray = None, spot_sigma: float = 2, outline_sigma: float = 2) -> ndarray\n", "\n", "\n", - "['- Computes the absolute value of every individual pixel in a given image.\\ncle.absolute(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Determines the absolute difference pixel by pixel between two images.\\ncle.absolute_difference(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Replace label map with the average distance to the n closest neighboring labels, given a label map, distance map, and n.\\ncle.average_distance_of_n_nearest_neighbors_map(labels: ndarray, distance_map: ndarray = None, n: int = 1) -> ndarray\\n\\n', '- Replaces every label in the label map with the average distance to the n closest neighboring labels\\ncle.average_distance_of_n_nearest_neighbors_map(labels: ndarray, distance_map: ndarray = None, n: int = 1) -> ndarray\\n\\n', '- Replaces labels in a label map with the average distance to neighboring labels.\\ncle.average_neighbor_distance_map(labels: ndarray, distance_map: ndarray = None) -> ndarray\\n\\n', '- Compute a binary image from two input images by connecting pairs of pixels with the binary AND operator &.\\ncle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Identify and set the surface pixels of binary objects to 1 in the destination image, while setting all other pixels to 0.\\ncle.binary_edge_detection(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute a binary image by connecting corresponding pixels from two input images using the binary AND operator.\\ncle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute a binary image by negating the pixel values of an input image, interpreting all non-zero values as 1.\\ncle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute a binary image from two input images by connecting pairs of pixels with the binary OR operator.\\ncle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', 'Subtract one binary image from another.\\ncle.binary_subtract(minuend: ndarray, subtrahend: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Computes a binary image from two input images by connecting pairs of pixels with the binary OR operator.\\ncle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* Connects pairs of pixels from two input images X and Y using binary operators (AND, OR, NOT, XOR) to compute a binary image\\ncle.binary_xor(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Applies a bottom-hat filter for background subtraction to the input image.\\ncle.bottom_hat_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\\n\\n', '- Determines the centroids of all labels in a label image or image stack and writes the resulting coordinates in a pointlist image\\ncle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray\\n\\n', '- This function analyzes a label map and relabels subsequent labels if there are gaps in the indexing.\\ncle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray\\n\\n', 'Apply a morphological closing operation to a label image.\\ncle.closing_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray\\n\\n', '- Applies morphological closing to intensity or binary images using a sphere-shaped footprint.\\ncle.closing_sphere(input_image: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> ndarray\\n\\n', '* combine two images or stacks in X where the output is a destination image.\\ncle.combine_horizontally(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Combine two label images by adding labels of one image to another\\n- Overwrite labels in the first image with labels from the second image\\n- Relabel the combined image sequentially\\ncle.combine_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray\\n\\n', '- Combine two images or stacks in the Y direction.\\ncle.combine_vertically(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* concatenate two stacks in Z\\ncle.concatenate_stacks(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Performs connected components analysis on a binary image, generating a label map.\\ncle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\\n\\n', '- Computes the number of touching neighbors per label in a touch matrix\\ncle.count_touching_neighbors(touch_matrix: ndarray, touching_neighbors_count_destination: ndarray = None, ignore_background: bool = True) -> ndarray\\n\\n', '- Create an image where the pixels on label edges are set to 1 and all other pixels are set to 0, given a labelmap image\\ncle.detect_label_edges(label_source: ndarray, binary_destination: ndarray = None) -> ndarray\\n\\n', '- Apply Gaussian blur to an input image twice with different sigma values and subtract the resulting images from each other\\ncle.difference_of_gaussian(source: ndarray, destination: ndarray = None, sigma1_x: float = 2, sigma1_y: float = 2, sigma1_z: float = 2, sigma2_x: float = 2, sigma2_y: float = 2, sigma2_z: float = 2) -> ndarray\\n\\n', '* Dilates labels to a larger size without overwriting another label, assuming input images are isotropic.\\ncle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray\\n\\n', '- Computes the binary dilation of a given input image using the von-Neumann-neighborhood.\\ncle.dilate_sphere(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Applies Gaussian blur to an image and divides the original by the result\\ncle.divide_by_gaussian_background(source: ndarray, destination: ndarray = None, sigma_x: float = 2, sigma_y: float = 2, sigma_z: float = 2) -> ndarray\\n\\n', '- Draws a box on an image at a specified position and size, leaving all other pixels untouched\\ncle.draw_box(destination: ndarray, x: int = 0, y: int = 0, z: int = 0, width: int = 1, height: int = 1, depth: int = 1, value: float = 1) -> ndarray\\n\\n', '* Draw a line between two points with a given thickness\\ncle.draw_line(destination: ndarray, x1: float = 0, y1: float = 0, z1: float = 0, x2: float = 1, y2: float = 1, z2: float = 1, thickness: float = 1, value: float = 1) -> ndarray\\n\\n', '- Draws a sphere around a given point with given radii in x, y, and z, if 3D, leaving all other pixels untouched.\\ncle.draw_sphere(destination: ndarray, x: float = 0, y: float = 0, z: float = 0, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1, value: float = 1) -> ndarray\\n\\n', '- Erodes labels to a smaller size\\ncle.erode_connected_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 1) -> ndarray\\n\\n', '- Compute a binary image representing the binary erosion of an input image\\ncle.erode_sphere(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Segments and labels an image using blurring, Otsu-thresholding, binary erosion, and masked Voronoi-labeling\\ncle.eroded_otsu_labeling(image: ndarray, labels_destination: ndarray = None, number_of_erosions: int = 5, outline_sigma: float = 2) -> ndarray\\n\\n', '- Remove labels from a label map that touch the edges of the image, and renumber the remaining labels.\\ncle.exclude_labels_on_edges(label_map_input: ndarray, label_map_destination: ndarray = None, exclude_in_x: bool = True, exclude_in_y: bool = True, exclude_in_z: bool = True, exlude_in_x: bool = None, exlude_in_y: bool = None, exlude_in_z: bool = None) -> ndarray\\n\\n', '- Removes labels from a label map based on their size, specified by a minimum and maximum number of pixels or voxels per label.\\ncle.exclude_labels_outside_size_range(source: ndarray, destination: ndarray = None, minimum_size: float = 0, maximum_size: float = 100) -> ndarray\\n\\n', '- Removes labels from a label map based on their size in terms of pixel or voxel count.\\ncle.exclude_labels_outside_size_range(source: ndarray, destination: ndarray = None, minimum_size: float = 0, maximum_size: float = 100) -> ndarray\\n\\n', '- Remove labels from a labelmap and renumber the remaining labels\\ncle.exclude_labels_with_values_out_of_range(values_vector: ndarray, label_map_input: ndarray, label_map_destination: ndarray = None, minimum_value_range: float = 0, maximum_value_range: float = 100) -> ndarray\\n\\n', '- Remove labels from a labelmap and renumber the remaining labels\\ncle.exclude_labels_with_values_within_range(values_vector: ndarray, label_map_input: ndarray, label_map_destination: ndarray = None, minimum_value_range: float = 0, maximum_value_range: float = 100) -> ndarray\\n\\n', '* Removes labels from a label map based on their size\\ncle.exclude_large_labels(source: ndarray, destination: ndarray = None, minimum_size: float = 100) -> ndarray\\n\\n', '- Removes labels from a label map below a specified maximum size\\ncle.exclude_small_labels(source: ndarray, destination: ndarray = None, maximum_size: float = 100) -> ndarray\\n\\n', 'Takes a label map image and dilates the regions until they touch, and then writes the resulting label map to the output.\\ncle.extend_labeling_via_voronoi(labeling_source: ndarray, labeling_destination: ndarray = None) -> ndarray\\n\\n', '* Dilates labels to a larger size without label overwrite, assuming input images are isotropic.\\ncle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray\\n\\n', '- Maximizes the local pixel intensity variance by projecting an extended depth of focus\\ncle.extended_depth_of_focus_variance_projection(source: ndarray, destination: ndarray = None, radius_x: int = 10, radius_y: int = 10, sigma: float = 5) -> ndarray\\n\\n', '* compute the absolute value of every individual pixel in a given image\\ncle.absolute(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Segment objects in grey-value images by applying a Gaussian blur, Otsu-thresholding, and connected component labeling.\\ncle.gauss_otsu_labeling(source: ndarray, label_image_destination: ndarray = None, outline_sigma: float = 2) -> ndarray\\n\\n', '- Compute the Gaussian blurred image of an image given sigma values in X, Y, and Z.\\ncle.gaussian_blur(source: ndarray, destination: ndarray = None, sigma_x: float = 0, sigma_y: float = 0, sigma_z: float = 0) -> ndarray\\n\\n', '- Compute the distance between all point coordinates given in two point lists.\\ncle.generate_distance_matrix(coordinate_list1: ndarray, coordinate_list2: ndarray, distance_matrix_destination: ndarray = None) -> ndarray\\n\\n', '- Generate a touch matrix that represents a region adjacency graph for a labelmap\\ncle.generate_touch_matrix(label_map: ndarray, touch_matrix_destination: ndarray = None) -> ndarray\\n\\n', '- Performs connected components analysis on a binary image, generating a label map\\ncle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\\n\\n', '- Determines the centroids of all labels in a label image or image stack and writes the resulting coordinates in a pointlist image.\\ncle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray\\n\\n', '- Transforms a binary image with single pixels set to 1 to a labeled spots image, or transforms a spots image into an image with numbered spots.\\ncle.label_spots(input_spots: ndarray, labelled_spots_destination: ndarray = None) -> ndarray\\n\\n', '- Generates a coordinate list of points in a labelled spot image.\\ncle.labelled_spots_to_pointlist(input_labelled_spots: ndarray, destination_pointlist: ndarray = None) -> ndarray\\n\\n', '- Apply the Laplace operator (Box neighborhood) to an image.\\ncle.laplace_box(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Applies the Laplace operator (Diamond neighborhood) to an image.\\ncle.laplace_diamond(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute a binary image by connecting pairs of pixels from two input images using the binary AND operator.\\ncle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute a binary image by inverting the pixel values of an input image, interpreting all non-zero values as 1.\\ncle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute a binary image by connecting pairs of pixels from two input images using the binary OR operator |.\\ncle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Create a binary image by connecting pairs of pixels from two input images using binary operators AND, OR, NOT, and XOR.\\ncle.binary_xor(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', 'Replaces integer intensities specified in a vector image by mapping them to new values.\\ncle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Computes a masked image by applying a binary mask to an image.\\ncle.mask(source: ndarray, mask: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Copy pixel values from one image to another based on a label mask.\\ncle.mask_label(source: ndarray, label_map: ndarray, destination: ndarray = None, label_index: int = 1) -> ndarray\\n\\n', '- Performs label map generation and dilation on a binary image using an octagon shape, within a specified masked area, resulting in a labeled output image.\\ncle.masked_voronoi_labeling(binary_source: ndarray, mask_image: ndarray, labeling_destination: ndarray = None) -> ndarray\\n\\n', '- Compute the maximum pixel value between two images and store the result in a destination image\\ncle.maximum_images(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute the maximum of a constant scalar and each pixel value in an image.\\ncle.maximum_image_and_scalar(source: ndarray, destination: ndarray = None, scalar: float = 0) -> ndarray\\n\\n', '- Compute the maximum pixel value between two given images and store the result in a destination image.\\ncle.maximum_images(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', \"- Computes the local maximum of a pixel's spherical neighborhood.\\ncle.maximum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 0) -> ndarray\\n\\n\", '- Determines the maximum intensity projection of an image along the Z-axis.\\ncle.maximum_z_projection(source: ndarray, destination_max: ndarray = None) -> ndarray\\n\\n', \"- Computes the local mean average of a pixel's spherical neighborhood\\ncle.mean_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\\n\\n\", '- Determines the mean squared error between two images and stores the result in a new row of ImageJs Results table\\ncle.mean_squared_error(source1: ndarray, source2: ndarray) -> float\\n\\n', '- Determines the mean average intensity projection of an image along the Z-axis.\\ncle.mean_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute the mean intensity along borders between labels in an image, then merge labels within a specified intensity range.\\ncle.merge_labels_with_border_intensity_within_range(image: ndarray, labels: ndarray, labels_destination: ndarray = None, minimum_intensity: float = 0, maximum_intensity: float = 3.4028235e+38)\\n\\n', '- Merge and renumber labels in a label image, producing a new label image.\\ncle.merge_touching_labels(labels_input: ndarray, labels_destination: ndarray = None) -> ndarray\\n\\n', '- Computes the local minimum of a pixels spherical neighborhood specified by its half-width, half-height, and half-depth.\\ncle.minimum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\\n\\n', '- Determine the minimum intensity projection of an image along the Z-axis.\\ncle.minimum_z_projection(source: ndarray, destination_min: ndarray = None) -> ndarray\\n\\n', '- Computes the remainder of a division of pairwise pixel values in two images.\\ncle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute the local mode of a pixels sphere shaped neighborhood\\ncle.mode_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray\\n\\n', '- Compute the remainder of a division of pairwise pixel values in two images\\ncle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Apply a morphological opening operation to a label image with an octagon as the structuring element, using iterative erosion and dilation.\\ncle.opening_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray\\n\\n', '- Apply morphological opening to intensity or binary images using a sphere-shaped footprint.\\ncle.opening_sphere(input_image: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> ndarray\\n\\n', 'Takes a pointlist with coordinates and labels corresponding pixels\\ncle.pointlist_to_labelled_spots(pointlist: ndarray, spots_destination: ndarray = None) -> ndarray\\n\\n', '- Takes a label map and replaces each label with the number of neighboring labels within a given distance range\\ncle.proximal_neighbor_count_map(source: ndarray, destination: ndarray = None, min_distance: float = 0, max_distance: float = 3.4028235e+38) -> ndarray\\n\\n', '- Read parametric values from label positions in a label image and a parametric image and store the intensity values in a vector\\ncle.read_intensities_from_map(labels: ndarray, map_image: ndarray, values_destination: ndarray = None) -> ndarray\\n\\n', '- Go to positions in an image specified by a pointlist, read intensities of those pixels, and store them in a new vector.\\ncle.read_intensities_from_positions(pointlist: ndarray, intensity_image: ndarray, values_destination: ndarray = None) -> ndarray\\n\\n', '- Reduces label map by taking only the center spots and setting background to zero.\\ncle.reduce_labels_to_centroids(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Reduces labels to their edges in a label map\\ncle.reduce_labels_to_label_edges(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* Reduce the number of slices in a stack by a factor and control which slices stay by specifying an offset.\\ncle.reduce_stack(source: ndarray, destination: ndarray = None, reduction_factor: int = 2, offset: int = 0) -> ndarray\\n\\n', '- This function analyzes a label map and relabels subsequent labels if there are any gaps in the indexing, resulting in the number of labels and the maximum label index being equal.\\ncle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray\\n\\n', '- Computes the remainder of a division of pairwise pixel values in two images\\ncle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Replaces integer intensities specified in a vector image.\\ncle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray\\n\\n', 'Transform an image by translating and rotating it, with optional parameters for interpolation, auto-sizing, and specifying the center of rotation.\\ncle.rigid_transform(source: ndarray, destination: ndarray = None, translate_x: float = 0, translate_y: float = 0, translate_z: float = 0, angle_around_x_in_degrees: float = 0, angle_around_y_in_degrees: float = 0, angle_around_z_in_degrees: float = 0, rotate_around_center: bool = True, linear_interpolation: bool = False, auto_size: bool = False) -> ndarray\\n\\n', '- Apply morphological opening operation and voronoi-labeling to a label image, then mask the result label image\\ncle.smooth_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray\\n\\n', '- Convolve an image with the Sobel kernel.\\ncle.sobel(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Compute the squared difference pixel by pixel between two images\\ncle.squared_difference(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray\\n\\n', \"- Computes the local standard deviation of a pixel's neighborhood given a specified box size. The box size is specified by its half-width, half-height, and half-depth (radius).\\ncle.standard_deviation_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray\\n\\n\", '- Determines the standard deviation intensity projection of an image stack along Z.\\ncle.standard_deviation_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Determines various properties of labelled objects in an image, including bounding box, area, intensity statistics, and shape descriptors.\\ncle.statistics_of_labelled_pixels(intensity_image: ndarray = None, label_image: ndarray = None)\\n\\n', '* Crop multiple Z-slices of a 3D stack into a new 3D stack.\\ncle.sub_stack(source: ndarray, destination: ndarray = None, start_z: int = 0, end_z: int = 0) -> ndarray\\n\\n', '- Apply Gaussian blur to an input image and subtract the result from the original image\\ncle.subtract_gaussian_background(source: ndarray, destination: ndarray = None, sigma_x: float = 2, sigma_y: float = 2, sigma_z: float = 2) -> ndarray\\n\\n', '- Combine two label images by removing labels from one image that also exist in the other image\\ncle.subtract_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray\\n\\n', '- Determines the sum intensity projection of an image along Z.\\ncle.sum_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', \"Binarizes an image using Otsu's threshold method and creates binary images.\\ncle.threshold_otsu(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n\", '- Applies a top-hat filter for background subtraction to the input image\\ncle.top_hat_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\\n\\n', '- Takes a label map and replaces each label with the number of neighboring labels it touches.\\ncle.touching_neighbor_count_map(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', \"- Computes the local variance of a pixel's sphere neighborhood, specified by its half-width, half-height, and half-depth (radius), ignoring radius_z if 2D images are given.\\ncle.variance_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray\\n\\n\", '* Label connected components in a binary image and dilate the regions until they touch\\ncle.voronoi_labeling(binary_source: ndarray, labeling_destination: ndarray = None) -> ndarray\\n\\n', '- Labels objects in grey-value images by applying two Gaussian blurs, spot detection, Otsu-thresholding, and Voronoi-labeling\\ncle.voronoi_otsu_labeling(source: ndarray, label_image_destination: ndarray = None, spot_sigma: float = 2, outline_sigma: float = 2) -> ndarray\\n\\n']\n" + "['* Set only surface pixels to 1 in destination binary image\\ncle.binary_edge_detection(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* Create a binary image by inverting pixel values in an input image, where all non-zero pixels become 0 and zeros become 1\\ncle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* Determines centroids of all labels in an image and writes coordinates in a pointlist image\\ncle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray\\n\\n', '- Analyses a label map to ensure that all labels are indexed without gaps before returning the relabeled map.\\ncle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray\\n\\n', '* Apply morphological closing with a sphere-shaped footprint to intensity or binary images.\\ncle.closing_sphere(input_image: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> ndarray\\n\\n', '- Combines two label images by adding labels from one image to another and sequentially relabeling the result\\ncle.combine_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray\\n\\n', '- Performs connected components analysis inspecting the box neighborhood of every pixel in a binary image, generating a label map\\ncle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\\n\\n', '- Takes a labelmap and sets edge pixels to 1 and others to 0\\ncle.detect_label_edges(label_source: ndarray, binary_destination: ndarray = None) -> ndarray\\n\\n', '* Apply Gaussian blur to an input image twice with different sigma values, resulting in two images that are subtracted from each other. It is recommended to apply this operation to images of type Float (32 bit).\\ncle.difference_of_gaussian(source: ndarray, destination: ndarray = None, sigma1_x: float = 2, sigma1_y: float = 2, sigma1_z: float = 2, sigma2_x: float = 2, sigma2_y: float = 2, sigma2_z: float = 2) -> ndarray\\n\\n', '* Dilates label images to a larger size without overwriting other labels, assuming input images are isotropic.\\ncle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray\\n\\n', '* Removes labels touching edges of the image in X, Y, and Z; renumbers remaining labels; allows exclusion along min and max X, Y, and Z axes\\ncle.exclude_labels_on_edges(label_map_input: ndarray, label_map_destination: ndarray = None, exclude_in_x: bool = True, exclude_in_y: bool = True, exclude_in_z: bool = True, exlude_in_x: bool = None, exlude_in_y: bool = None, exlude_in_z: bool = None) -> ndarray\\n\\n', '* Removes labels from a label map above a given maximum size \\ncle.exclude_large_labels(source: ndarray, destination: ndarray = None, minimum_size: float = 100) -> ndarray\\n\\n', '* Removes labels from a label map below a specified maximum size by number of pixels or voxels.\\ncle.exclude_small_labels(source: ndarray, destination: ndarray = None, maximum_size: float = 100) -> ndarray\\n\\n', '* Dilates labels in an isotropic label image without overwriting other labels.\\ncle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray\\n\\n', '* Compute the Gaussian blurred image of an image given sigma values in X, Y, and Z with optional destination and sigma parameters.\\ncle.gaussian_blur(source: ndarray, destination: ndarray = None, sigma_x: float = 0, sigma_y: float = 0, sigma_z: float = 0) -> ndarray\\n\\n', \"* Performs connected components analysis on a binary image by inspecting each pixel's neighbors to generate a label map.\\ncle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray\\n\\n\", '- Determines centroids of labels in a label image or image stack, writing resulting coordinates in a pointlist image: label image input, destination image of d*n size for d-dimensional label image with n labels, optional background centroid measurement\\ncle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray\\n\\n', '* Computes a binary image by inverting pixel values with the binary NOT operator, treating non-zero values as 1.\\ncle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* Replace integer intensities in a 3D vector image with specified values\\ncle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray\\n\\n', \"* Computes the local maximum of a pixel's spherical neighborhood specified by radius in three dimensions.\\ncle.maximum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 0) -> ndarray\\n\\n\", '* Maximum intensity projection of an image along Z\\ncle.maximum_z_projection(source: ndarray, destination_max: ndarray = None) -> ndarray\\n\\n', \"* Compute the local mean average of a pixel's spherical neighborhood using specified radii dimensions in 3D space.\\ncle.mean_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\\n\\n\", '* Calculates the mean average intensity projection of an image along Z.\\ncle.mean_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* takes a label image, merges touching labels, renumbers them, and produces a new label image\\ncle.merge_touching_labels(labels_input: ndarray, labels_destination: ndarray = None) -> ndarray\\n\\n', '- Computes the local minimum of a pixels spherical neighborhood with specified radius dimensions\\ncle.minimum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\\n\\n', '* Calculates the minimum intensity projection of an image along the Z-axis\\ncle.minimum_z_projection(source: ndarray, destination_min: ndarray = None) -> ndarray\\n\\n', '* Compute the local mode of a pixels sphere shaped neighborhood to locally correct semantic segmentation results of an image, with specified half-width and half-height (radius) of the sphere, and intensities ranging from 0 to 255, returning the smallest value in case of multiple maximum frequency values.\\ncle.mode_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray\\n\\n', '- Reads intensity values from labeled image positions and stores them in a new vector, taking into consideration certain constraints on label structure.\\ncle.read_intensities_from_map(labels: ndarray, map_image: ndarray, values_destination: ndarray = None) -> ndarray\\n\\n', '* Reduce all labels in a label map to their center spots, keeping label IDs intact and setting background to zero.\\ncle.reduce_labels_to_centroids(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* reduce all labels in a label map to their edges, maintaining label IDs and setting background to zero\\ncle.reduce_labels_to_label_edges(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '- Analyses and renumbers a label map to fill in any gaps in indexing, ensuring that the number of labels matches the maximum label index\\ncle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray\\n\\n', '* Replaces integer intensities specified in a vector image with new values\\ncle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* Apply morphological opening operation, fill label gaps with voronoi-labeling, and mask background pixels in label image.\\ncle.smooth_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray\\n\\n', '* Convolve image with Sobel kernel to detect edges in image\\ncle.sobel(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', '* Determines bounding box, area, min, max, mean, standard deviation of intensity and shape descriptors of labelled objects in a label map and corresponding pixels in the original image.\\ncle.statistics_of_labelled_pixels(intensity_image: ndarray = None, label_image: ndarray = None)\\n\\n', '* Apply Gaussian blur to input image and subtract from original to create destination image.\\ncle.subtract_gaussian_background(source: ndarray, destination: ndarray = None, sigma_x: float = 2, sigma_y: float = 2, sigma_z: float = 2) -> ndarray\\n\\n', 'Combine two label images by removing overlapping labels from one image that also exist in the other image.\\ncle.subtract_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray\\n\\n', '* Determine the sum intensity projection of an image along Z\\ncle.sum_z_projection(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n', \"* Binarize an image using Otsu's threshold method implemented in scikit-image, utilizing a GPU-based histogram for binary image creation.\\ncle.threshold_otsu(source: ndarray, destination: ndarray = None) -> ndarray\\n\\n\", '* Apply a top-hat filter for background subtraction to an input image.\\ncle.top_hat_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray\\n\\n', '* Takes a binary image, labels connected components, dilates regions until they touch, and outputs a label map.\\ncle.voronoi_labeling(binary_source: ndarray, labeling_destination: ndarray = None) -> ndarray\\n\\n', '- Labels objects in grey-value images using Gaussian blurs, spot detection, Otsu-thresholding, and Voronoi-labeling from isotropic input images.\\ncle.voronoi_otsu_labeling(source: ndarray, label_image_destination: ndarray = None, spot_sigma: float = 2, outline_sigma: float = 2) -> ndarray\\n\\n']\n" ] } ], @@ -587,7 +321,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.9.19" } }, "nbformat": 4, diff --git a/pyclesperanto_prototype/_bia_bob_plugins.py b/pyclesperanto_prototype/_bia_bob_plugins.py index 26112b41..82e6fb04 100644 --- a/pyclesperanto_prototype/_bia_bob_plugins.py +++ b/pyclesperanto_prototype/_bia_bob_plugins.py @@ -1,330 +1,130 @@ def list_bia_bob_plugins(): """List of function hints for bia_bob""" - return """ * Computes the absolute value of every individual pixel in a given image. - cle.absolute(source: ndarray, destination: ndarray = None) -> ndarray - - * Determines the absolute difference pixel by pixel between two images. - cle.absolute_difference(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray - - * Replace label map with the average distance to the n closest neighboring labels, given a label map, distance map, and n. - cle.average_distance_of_n_nearest_neighbors_map(labels: ndarray, distance_map: ndarray = None, n: int = 1) -> ndarray - - * Replaces every label in the label map with the average distance to the n closest neighboring labels - cle.average_distance_of_n_nearest_neighbors_map(labels: ndarray, distance_map: ndarray = None, n: int = 1) -> ndarray - - * Replaces labels in a label map with the average distance to neighboring labels. - cle.average_neighbor_distance_map(labels: ndarray, distance_map: ndarray = None) -> ndarray - - * Compute a binary image from two input images by connecting pairs of pixels with the binary AND operator &. - cle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Identify and set the surface pixels of binary objects to 1 in the destination image, while setting all other pixels to 0. + return """ * Set only surface pixels to 1 in destination binary image cle.binary_edge_detection(source: ndarray, destination: ndarray = None) -> ndarray - * Compute a binary image by connecting corresponding pixels from two input images using the binary AND operator. - cle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Compute a binary image by negating the pixel values of an input image, interpreting all non-zero values as 1. + * Create a binary image by inverting pixel values in an input image, where all non-zero pixels become 0 and zeros become 1 cle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray - * Compute a binary image from two input images by connecting pairs of pixels with the binary OR operator. - cle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Subtract one binary image from another. - cle.binary_subtract(minuend: ndarray, subtrahend: ndarray, destination: ndarray = None) -> ndarray - - * Computes a binary image from two input images by connecting pairs of pixels with the binary OR operator. - cle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Connects pairs of pixels from two input images X and Y using binary operators (AND, OR, NOT, XOR) to compute a binary image - cle.binary_xor(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Applies a bottom-hat filter for background subtraction to the input image. - cle.bottom_hat_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray - - * Determines the centroids of all labels in a label image or image stack and writes the resulting coordinates in a pointlist image + * Determines centroids of all labels in an image and writes coordinates in a pointlist image cle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray - * This function analyzes a label map and relabels subsequent labels if there are gaps in the indexing. + * Analyses a label map to ensure that all labels are indexed without gaps before returning the relabeled map. cle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray - * Apply a morphological closing operation to a label image. - cle.closing_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray - - * Applies morphological closing to intensity or binary images using a sphere-shaped footprint. + * Apply morphological closing with a sphere-shaped footprint to intensity or binary images. cle.closing_sphere(input_image: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> ndarray - * combine two images or stacks in X where the output is a destination image. - cle.combine_horizontally(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray - - * Combine two label images by adding labels of one image to another - - Overwrite labels in the first image with labels from the second image - - Relabel the combined image sequentially + * Combines two label images by adding labels from one image to another and sequentially relabeling the result cle.combine_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray - * Combine two images or stacks in the Y direction. - cle.combine_vertically(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray - - * concatenate two stacks in Z - cle.concatenate_stacks(stack1: ndarray, stack2: ndarray, destination: ndarray = None) -> ndarray - - * Performs connected components analysis on a binary image, generating a label map. - cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray - - * Computes the number of touching neighbors per label in a touch matrix - cle.count_touching_neighbors(touch_matrix: ndarray, touching_neighbors_count_destination: ndarray = None, ignore_background: bool = True) -> ndarray + * Performs connected components analysis inspecting the box neighborhood of every pixel in a binary image, generating a label map + cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray - * Create an image where the pixels on label edges are set to 1 and all other pixels are set to 0, given a labelmap image + * Takes a labelmap and sets edge pixels to 1 and others to 0 cle.detect_label_edges(label_source: ndarray, binary_destination: ndarray = None) -> ndarray - * Apply Gaussian blur to an input image twice with different sigma values and subtract the resulting images from each other + * Apply Gaussian blur to an input image twice with different sigma values, resulting in two images that are subtracted from each other. It is recommended to apply this operation to images of type Float (32 bit). cle.difference_of_gaussian(source: ndarray, destination: ndarray = None, sigma1_x: float = 2, sigma1_y: float = 2, sigma1_z: float = 2, sigma2_x: float = 2, sigma2_y: float = 2, sigma2_z: float = 2) -> ndarray - * Dilates labels to a larger size without overwriting another label, assuming input images are isotropic. + * Dilates label images to a larger size without overwriting other labels, assuming input images are isotropic. cle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray - * Computes the binary dilation of a given input image using the von-Neumann-neighborhood. - cle.dilate_sphere(source: ndarray, destination: ndarray = None) -> ndarray - - * Applies Gaussian blur to an image and divides the original by the result - cle.divide_by_gaussian_background(source: ndarray, destination: ndarray = None, sigma_x: float = 2, sigma_y: float = 2, sigma_z: float = 2) -> ndarray - - * Draws a box on an image at a specified position and size, leaving all other pixels untouched - cle.draw_box(destination: ndarray, x: int = 0, y: int = 0, z: int = 0, width: int = 1, height: int = 1, depth: int = 1, value: float = 1) -> ndarray - - * Draw a line between two points with a given thickness - cle.draw_line(destination: ndarray, x1: float = 0, y1: float = 0, z1: float = 0, x2: float = 1, y2: float = 1, z2: float = 1, thickness: float = 1, value: float = 1) -> ndarray - - * Draws a sphere around a given point with given radii in x, y, and z, if 3D, leaving all other pixels untouched. - cle.draw_sphere(destination: ndarray, x: float = 0, y: float = 0, z: float = 0, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1, value: float = 1) -> ndarray - - * Erodes labels to a smaller size - cle.erode_connected_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 1) -> ndarray - - * Compute a binary image representing the binary erosion of an input image - cle.erode_sphere(source: ndarray, destination: ndarray = None) -> ndarray - - * Segments and labels an image using blurring, Otsu-thresholding, binary erosion, and masked Voronoi-labeling - cle.eroded_otsu_labeling(image: ndarray, labels_destination: ndarray = None, number_of_erosions: int = 5, outline_sigma: float = 2) -> ndarray - - * Remove labels from a label map that touch the edges of the image, and renumber the remaining labels. + * Removes labels touching edges of the image in X, Y, and Z; renumbers remaining labels; allows exclusion along min and max X, Y, and Z axes cle.exclude_labels_on_edges(label_map_input: ndarray, label_map_destination: ndarray = None, exclude_in_x: bool = True, exclude_in_y: bool = True, exclude_in_z: bool = True, exlude_in_x: bool = None, exlude_in_y: bool = None, exlude_in_z: bool = None) -> ndarray - * Removes labels from a label map based on their size, specified by a minimum and maximum number of pixels or voxels per label. - cle.exclude_labels_outside_size_range(source: ndarray, destination: ndarray = None, minimum_size: float = 0, maximum_size: float = 100) -> ndarray - - * Removes labels from a label map based on their size in terms of pixel or voxel count. - cle.exclude_labels_outside_size_range(source: ndarray, destination: ndarray = None, minimum_size: float = 0, maximum_size: float = 100) -> ndarray - - * Remove labels from a labelmap and renumber the remaining labels - cle.exclude_labels_with_values_out_of_range(values_vector: ndarray, label_map_input: ndarray, label_map_destination: ndarray = None, minimum_value_range: float = 0, maximum_value_range: float = 100) -> ndarray - - * Remove labels from a labelmap and renumber the remaining labels - cle.exclude_labels_with_values_within_range(values_vector: ndarray, label_map_input: ndarray, label_map_destination: ndarray = None, minimum_value_range: float = 0, maximum_value_range: float = 100) -> ndarray - - * Removes labels from a label map based on their size + * Removes labels from a label map above a given maximum size cle.exclude_large_labels(source: ndarray, destination: ndarray = None, minimum_size: float = 100) -> ndarray - * Removes labels from a label map below a specified maximum size + * Removes labels from a label map below a specified maximum size by number of pixels or voxels. cle.exclude_small_labels(source: ndarray, destination: ndarray = None, maximum_size: float = 100) -> ndarray - * Takes a label map image and dilates the regions until they touch, and then writes the resulting label map to the output. - cle.extend_labeling_via_voronoi(labeling_source: ndarray, labeling_destination: ndarray = None) -> ndarray - - * Dilates labels to a larger size without label overwrite, assuming input images are isotropic. + * Dilates labels in an isotropic label image without overwriting other labels. cle.dilate_labels(labeling_source: ndarray, labeling_destination: ndarray = None, radius: int = 2) -> ndarray - * Maximizes the local pixel intensity variance by projecting an extended depth of focus - cle.extended_depth_of_focus_variance_projection(source: ndarray, destination: ndarray = None, radius_x: int = 10, radius_y: int = 10, sigma: float = 5) -> ndarray - - * compute the absolute value of every individual pixel in a given image - cle.absolute(source: ndarray, destination: ndarray = None) -> ndarray - - * Segment objects in grey-value images by applying a Gaussian blur, Otsu-thresholding, and connected component labeling. - cle.gauss_otsu_labeling(source: ndarray, label_image_destination: ndarray = None, outline_sigma: float = 2) -> ndarray - - * Compute the Gaussian blurred image of an image given sigma values in X, Y, and Z. + * Compute the Gaussian blurred image of an image given sigma values in X, Y, and Z with optional destination and sigma parameters. cle.gaussian_blur(source: ndarray, destination: ndarray = None, sigma_x: float = 0, sigma_y: float = 0, sigma_z: float = 0) -> ndarray - * Compute the distance between all point coordinates given in two point lists. - cle.generate_distance_matrix(coordinate_list1: ndarray, coordinate_list2: ndarray, distance_matrix_destination: ndarray = None) -> ndarray + * Performs connected components analysis on a binary image by inspecting each pixel's neighbors to generate a label map. + cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray - * Generate a touch matrix that represents a region adjacency graph for a labelmap - cle.generate_touch_matrix(label_map: ndarray, touch_matrix_destination: ndarray = None) -> ndarray - - * Performs connected components analysis on a binary image, generating a label map - cle.connected_components_labeling_box(binary_input: ndarray, labeling_destination: ndarray = None, flagged_nonzero_minimum_filter: = ) -> ndarray - - * Determines the centroids of all labels in a label image or image stack and writes the resulting coordinates in a pointlist image. + * Determines centroids of labels in a label image or image stack, writing resulting coordinates in a pointlist image: label image input, destination image of d*n size for d-dimensional label image with n labels, optional background centroid measurement cle.centroids_of_labels(labels: ndarray, pointlist_destination: ndarray = None, include_background: bool = False) -> ndarray - * Transforms a binary image with single pixels set to 1 to a labeled spots image, or transforms a spots image into an image with numbered spots. - cle.label_spots(input_spots: ndarray, labelled_spots_destination: ndarray = None) -> ndarray - - * Generates a coordinate list of points in a labelled spot image. - cle.labelled_spots_to_pointlist(input_labelled_spots: ndarray, destination_pointlist: ndarray = None) -> ndarray - - * Apply the Laplace operator (Box neighborhood) to an image. - cle.laplace_box(source: ndarray, destination: ndarray = None) -> ndarray - - * Applies the Laplace operator (Diamond neighborhood) to an image. - cle.laplace_diamond(source: ndarray, destination: ndarray = None) -> ndarray - - * Compute a binary image by connecting pairs of pixels from two input images using the binary AND operator. - cle.binary_and(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Compute a binary image by inverting the pixel values of an input image, interpreting all non-zero values as 1. + * Computes a binary image by inverting pixel values with the binary NOT operator, treating non-zero values as 1. cle.binary_not(source: ndarray, destination: ndarray = None) -> ndarray - * Compute a binary image by connecting pairs of pixels from two input images using the binary OR operator |. - cle.binary_or(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Create a binary image by connecting pairs of pixels from two input images using binary operators AND, OR, NOT, and XOR. - cle.binary_xor(operand1: ndarray, operand2: ndarray, destination: ndarray = None) -> ndarray - - * Replaces integer intensities specified in a vector image by mapping them to new values. + * Replace integer intensities in a 3D vector image with specified values cle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray - * Computes a masked image by applying a binary mask to an image. - cle.mask(source: ndarray, mask: ndarray, destination: ndarray = None) -> ndarray - - * Copy pixel values from one image to another based on a label mask. - cle.mask_label(source: ndarray, label_map: ndarray, destination: ndarray = None, label_index: int = 1) -> ndarray - - * Performs label map generation and dilation on a binary image using an octagon shape, within a specified masked area, resulting in a labeled output image. - cle.masked_voronoi_labeling(binary_source: ndarray, mask_image: ndarray, labeling_destination: ndarray = None) -> ndarray - - * Compute the maximum pixel value between two images and store the result in a destination image - cle.maximum_images(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray - - * Compute the maximum of a constant scalar and each pixel value in an image. - cle.maximum_image_and_scalar(source: ndarray, destination: ndarray = None, scalar: float = 0) -> ndarray - - * Compute the maximum pixel value between two given images and store the result in a destination image. - cle.maximum_images(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray - - * Computes the local maximum of a pixel's spherical neighborhood. + * Computes the local maximum of a pixel's spherical neighborhood specified by radius in three dimensions. cle.maximum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 0) -> ndarray - * Determines the maximum intensity projection of an image along the Z-axis. + * Maximum intensity projection of an image along Z cle.maximum_z_projection(source: ndarray, destination_max: ndarray = None) -> ndarray - * Computes the local mean average of a pixel's spherical neighborhood + * Compute the local mean average of a pixel's spherical neighborhood using specified radii dimensions in 3D space. cle.mean_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray - * Determines the mean squared error between two images and stores the result in a new row of ImageJs Results table - cle.mean_squared_error(source1: ndarray, source2: ndarray) -> float - - * Determines the mean average intensity projection of an image along the Z-axis. + * Calculates the mean average intensity projection of an image along Z. cle.mean_z_projection(source: ndarray, destination: ndarray = None) -> ndarray - * Compute the mean intensity along borders between labels in an image, then merge labels within a specified intensity range. - cle.merge_labels_with_border_intensity_within_range(image: ndarray, labels: ndarray, labels_destination: ndarray = None, minimum_intensity: float = 0, maximum_intensity: float = 3.4028235e+38) - - * Merge and renumber labels in a label image, producing a new label image. + * takes a label image, merges touching labels, renumbers them, and produces a new label image cle.merge_touching_labels(labels_input: ndarray, labels_destination: ndarray = None) -> ndarray - * Computes the local minimum of a pixels spherical neighborhood specified by its half-width, half-height, and half-depth. + * Computes the local minimum of a pixels spherical neighborhood with specified radius dimensions cle.minimum_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray - * Determine the minimum intensity projection of an image along the Z-axis. + * Calculates the minimum intensity projection of an image along the Z-axis cle.minimum_z_projection(source: ndarray, destination_min: ndarray = None) -> ndarray - * Computes the remainder of a division of pairwise pixel values in two images. - cle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray - - * Compute the local mode of a pixels sphere shaped neighborhood + * Compute the local mode of a pixels sphere shaped neighborhood to locally correct semantic segmentation results of an image, with specified half-width and half-height (radius) of the sphere, and intensities ranging from 0 to 255, returning the smallest value in case of multiple maximum frequency values. cle.mode_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray - * Compute the remainder of a division of pairwise pixel values in two images - cle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray - - * Apply a morphological opening operation to a label image with an octagon as the structuring element, using iterative erosion and dilation. - cle.opening_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray - - * Apply morphological opening to intensity or binary images using a sphere-shaped footprint. - cle.opening_sphere(input_image: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> ndarray - - * Takes a pointlist with coordinates and labels corresponding pixels - cle.pointlist_to_labelled_spots(pointlist: ndarray, spots_destination: ndarray = None) -> ndarray - - * Takes a label map and replaces each label with the number of neighboring labels within a given distance range - cle.proximal_neighbor_count_map(source: ndarray, destination: ndarray = None, min_distance: float = 0, max_distance: float = 3.4028235e+38) -> ndarray - - * Read parametric values from label positions in a label image and a parametric image and store the intensity values in a vector + * Reads intensity values from labeled image positions and stores them in a new vector, taking into consideration certain constraints on label structure. cle.read_intensities_from_map(labels: ndarray, map_image: ndarray, values_destination: ndarray = None) -> ndarray - * Go to positions in an image specified by a pointlist, read intensities of those pixels, and store them in a new vector. - cle.read_intensities_from_positions(pointlist: ndarray, intensity_image: ndarray, values_destination: ndarray = None) -> ndarray - - * Reduces label map by taking only the center spots and setting background to zero. + * Reduce all labels in a label map to their center spots, keeping label IDs intact and setting background to zero. cle.reduce_labels_to_centroids(source: ndarray, destination: ndarray = None) -> ndarray - * Reduces labels to their edges in a label map + * reduce all labels in a label map to their edges, maintaining label IDs and setting background to zero cle.reduce_labels_to_label_edges(source: ndarray, destination: ndarray = None) -> ndarray - * Reduce the number of slices in a stack by a factor and control which slices stay by specifying an offset. - cle.reduce_stack(source: ndarray, destination: ndarray = None, reduction_factor: int = 2, offset: int = 0) -> ndarray - - * This function analyzes a label map and relabels subsequent labels if there are any gaps in the indexing, resulting in the number of labels and the maximum label index being equal. + * Analyses and renumbers a label map to fill in any gaps in indexing, ensuring that the number of labels matches the maximum label index cle.relabel_sequential(source: ndarray, output: ndarray = None, blocksize: int = 4096) -> ndarray - * Computes the remainder of a division of pairwise pixel values in two images - cle.modulo_images(image1: ndarray, image2: ndarray, destination: ndarray = None) -> ndarray - - * Replaces integer intensities specified in a vector image. + * Replaces integer intensities specified in a vector image with new values cle.replace_intensities(source: ndarray, new_values_vector: ndarray, destination: ndarray = None) -> ndarray - * Transform an image by translating and rotating it, with optional parameters for interpolation, auto-sizing, and specifying the center of rotation. - cle.rigid_transform(source: ndarray, destination: ndarray = None, translate_x: float = 0, translate_y: float = 0, translate_z: float = 0, angle_around_x_in_degrees: float = 0, angle_around_y_in_degrees: float = 0, angle_around_z_in_degrees: float = 0, rotate_around_center: bool = True, linear_interpolation: bool = False, auto_size: bool = False) -> ndarray - - * Apply morphological opening operation and voronoi-labeling to a label image, then mask the result label image + * Apply morphological opening operation, fill label gaps with voronoi-labeling, and mask background pixels in label image. cle.smooth_labels(labels_input: ndarray, labels_destination: ndarray = None, radius: int = 0) -> ndarray - * Convolve an image with the Sobel kernel. + * Convolve image with Sobel kernel to detect edges in image cle.sobel(source: ndarray, destination: ndarray = None) -> ndarray - * Compute the squared difference pixel by pixel between two images - cle.squared_difference(source1: ndarray, source2: ndarray, destination: ndarray = None) -> ndarray - - * Computes the local standard deviation of a pixel's neighborhood given a specified box size. The box size is specified by its half-width, half-height, and half-depth (radius). - cle.standard_deviation_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray - - * Determines the standard deviation intensity projection of an image stack along Z. - cle.standard_deviation_z_projection(source: ndarray, destination: ndarray = None) -> ndarray - - * Determines various properties of labelled objects in an image, including bounding box, area, intensity statistics, and shape descriptors. + * Determines bounding box, area, min, max, mean, standard deviation of intensity and shape descriptors of labelled objects in a label map and corresponding pixels in the original image. cle.statistics_of_labelled_pixels(intensity_image: ndarray = None, label_image: ndarray = None) - * Crop multiple Z-slices of a 3D stack into a new 3D stack. - cle.sub_stack(source: ndarray, destination: ndarray = None, start_z: int = 0, end_z: int = 0) -> ndarray - - * Apply Gaussian blur to an input image and subtract the result from the original image + * Apply Gaussian blur to input image and subtract from original to create destination image. cle.subtract_gaussian_background(source: ndarray, destination: ndarray = None, sigma_x: float = 2, sigma_y: float = 2, sigma_z: float = 2) -> ndarray - * Combine two label images by removing labels from one image that also exist in the other image + * Combine two label images by removing overlapping labels from one image that also exist in the other image. cle.subtract_labels(labels_input1: ndarray, labels_input2: ndarray, labels_destination: ndarray = None) -> ndarray - * Determines the sum intensity projection of an image along Z. + * Determine the sum intensity projection of an image along Z cle.sum_z_projection(source: ndarray, destination: ndarray = None) -> ndarray - * Binarizes an image using Otsu's threshold method and creates binary images. + * Binarize an image using Otsu's threshold method implemented in scikit-image, utilizing a GPU-based histogram for binary image creation. cle.threshold_otsu(source: ndarray, destination: ndarray = None) -> ndarray - * Applies a top-hat filter for background subtraction to the input image + * Apply a top-hat filter for background subtraction to an input image. cle.top_hat_sphere(source: ndarray, destination: ndarray = None, radius_x: float = 1, radius_y: float = 1, radius_z: float = 1) -> ndarray - * Takes a label map and replaces each label with the number of neighboring labels it touches. - cle.touching_neighbor_count_map(source: ndarray, destination: ndarray = None) -> ndarray - - * Computes the local variance of a pixel's sphere neighborhood, specified by its half-width, half-height, and half-depth (radius), ignoring radius_z if 2D images are given. - cle.variance_sphere(source: ndarray, destination: ndarray = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 1) -> ndarray - - * Label connected components in a binary image and dilate the regions until they touch + * Takes a binary image, labels connected components, dilates regions until they touch, and outputs a label map. cle.voronoi_labeling(binary_source: ndarray, labeling_destination: ndarray = None) -> ndarray - * Labels objects in grey-value images by applying two Gaussian blurs, spot detection, Otsu-thresholding, and Voronoi-labeling + * Labels objects in grey-value images using Gaussian blurs, spot detection, Otsu-thresholding, and Voronoi-labeling from isotropic input images. cle.voronoi_otsu_labeling(source: ndarray, label_image_destination: ndarray = None, spot_sigma: float = 2, outline_sigma: float = 2) -> ndarray """ diff --git a/pyclesperanto_prototype/_tier1/_absolute.py b/pyclesperanto_prototype/_tier1/_absolute.py index 66b12599..f0959b77 100644 --- a/pyclesperanto_prototype/_tier1/_absolute.py +++ b/pyclesperanto_prototype/_tier1/_absolute.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['filter', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'in assistant']) def absolute(source : Image, destination : Image = None) -> Image: """Computes the absolute value of every individual pixel x in a given image. diff --git a/pyclesperanto_prototype/_tier1/_binary_and.py b/pyclesperanto_prototype/_tier1/_binary_and.py index 2f94d92f..02b906c2 100644 --- a/pyclesperanto_prototype/_tier1/_binary_and.py +++ b/pyclesperanto_prototype/_tier1/_binary_and.py @@ -3,7 +3,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing', 'bia-bob-suggestion'], priority=1, output_creator=create_binary_like) +@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing'], priority=1, output_creator=create_binary_like) def binary_and(operand1 : Image, operand2 : Image, destination : Image = None) -> Image: """Computes a binary image (containing pixel values 0 and 1) from two images X and Y by connecting pairs of diff --git a/pyclesperanto_prototype/_tier1/_binary_or.py b/pyclesperanto_prototype/_tier1/_binary_or.py index 36a10eab..5fb4cf73 100644 --- a/pyclesperanto_prototype/_tier1/_binary_or.py +++ b/pyclesperanto_prototype/_tier1/_binary_or.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing', 'bia-bob-suggestion'], output_creator=create_binary_like) +@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing'], output_creator=create_binary_like) def binary_or(operand1 : Image, operand2 : Image, destination : Image = None) -> Image: """Computes a binary image (containing pixel values 0 and 1) from two images X and Y by connecting pairs of diff --git a/pyclesperanto_prototype/_tier1/_binary_subtract.py b/pyclesperanto_prototype/_tier1/_binary_subtract.py index 466cda29..44516edf 100644 --- a/pyclesperanto_prototype/_tier1/_binary_subtract.py +++ b/pyclesperanto_prototype/_tier1/_binary_subtract.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing', 'bia-bob-suggestion'], output_creator=create_binary_like) +@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing'], output_creator=create_binary_like) def binary_subtract(minuend : Image, subtrahend : Image, destination : Image = None) -> Image: """Subtracts one binary image from another. diff --git a/pyclesperanto_prototype/_tier1/_binary_xor.py b/pyclesperanto_prototype/_tier1/_binary_xor.py index 3f0d3a47..c509d484 100644 --- a/pyclesperanto_prototype/_tier1/_binary_xor.py +++ b/pyclesperanto_prototype/_tier1/_binary_xor.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing', 'bia-bob-suggestion'], output_creator=create_binary_like) +@plugin_function(categories=['combine', 'binary processing', 'in assistant', 'combine labels', 'label processing'], output_creator=create_binary_like) def binary_xor(operand1 : Image, operand2 : Image, destination : Image = None) -> Image: """Computes a binary image (containing pixel values 0 and 1) from two images X and Y by connecting pairs of diff --git a/pyclesperanto_prototype/_tier1/_count_touching_neighbors.py b/pyclesperanto_prototype/_tier1/_count_touching_neighbors.py index 3e91e357..0da8b40b 100644 --- a/pyclesperanto_prototype/_tier1/_count_touching_neighbors.py +++ b/pyclesperanto_prototype/_tier1/_count_touching_neighbors.py @@ -3,7 +3,7 @@ from .._tier0 import Image from .._tier0 import create_vector_from_square_matrix -@plugin_function(output_creator=create_vector_from_square_matrix, categories=['bia-bob-suggestion']) +@plugin_function(output_creator=create_vector_from_square_matrix, categories=[]) def count_touching_neighbors(touch_matrix: Image, touching_neighbors_count_destination: Image = None, ignore_background:bool = True) -> Image: """Takes a touch matrix as input and delivers a vector with number of touching neighbors per label as a vector. diff --git a/pyclesperanto_prototype/_tier1/_dilate_sphere.py b/pyclesperanto_prototype/_tier1/_dilate_sphere.py index 543e3c15..563d6d49 100644 --- a/pyclesperanto_prototype/_tier1/_dilate_sphere.py +++ b/pyclesperanto_prototype/_tier1/_dilate_sphere.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['binary processing', 'bia-bob-suggestion'], output_creator=create_binary_like) +@plugin_function(categories=['binary processing'], output_creator=create_binary_like) def dilate_sphere(source : Image, destination : Image = None) -> Image: """Computes a binary image with pixel values 0 and 1 containing the binary dilation of a given input image. diff --git a/pyclesperanto_prototype/_tier1/_draw_box.py b/pyclesperanto_prototype/_tier1/_draw_box.py index 4b85a52a..e5f5d642 100644 --- a/pyclesperanto_prototype/_tier1/_draw_box.py +++ b/pyclesperanto_prototype/_tier1/_draw_box.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['bia-bob-suggestion']) +@plugin_function(categories=[]) def draw_box(destination: Image, x: int = 0, y: int = 0, z: int = 0, width: int = 1, height: int = 1, depth: int = 1, value : float = 1) -> Image: """Draws a box at a given start point with given size. All pixels other than in the box are untouched. Consider using `set(buffer, diff --git a/pyclesperanto_prototype/_tier1/_draw_line.py b/pyclesperanto_prototype/_tier1/_draw_line.py index 463d4ab6..13cfe235 100644 --- a/pyclesperanto_prototype/_tier1/_draw_line.py +++ b/pyclesperanto_prototype/_tier1/_draw_line.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['bia-bob-suggestion']) +@plugin_function(categories=[]) def draw_line(destination : Image, x1 : float = 0, y1 : float = 0, z1 : float = 0, x2 : float = 1, y2 : float = 1, z2 : float = 1, thickness : float = 1, value : float = 1) -> Image: """Draws a line between two points with a given thickness. diff --git a/pyclesperanto_prototype/_tier1/_draw_sphere.py b/pyclesperanto_prototype/_tier1/_draw_sphere.py index 6e3df611..04d8e593 100644 --- a/pyclesperanto_prototype/_tier1/_draw_sphere.py +++ b/pyclesperanto_prototype/_tier1/_draw_sphere.py @@ -4,7 +4,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['bia-bob-suggestion']) +@plugin_function(categories=[]) def draw_sphere(destination : Image, x : float = 0, y : float = 0, z : float = 0, radius_x : float = 1, radius_y : float = 1, radius_z : float = 1, value : float = 1) -> Image: """Draws a sphere around a given point with given radii in x, y and z (if 3D). diff --git a/pyclesperanto_prototype/_tier1/_erode_sphere.py b/pyclesperanto_prototype/_tier1/_erode_sphere.py index b23e971a..fce4dae5 100644 --- a/pyclesperanto_prototype/_tier1/_erode_sphere.py +++ b/pyclesperanto_prototype/_tier1/_erode_sphere.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['binary processing', 'bia-bob-suggestion'], output_creator=create_binary_like) +@plugin_function(categories=['binary processing'], output_creator=create_binary_like) def erode_sphere(source : Image, destination : Image = None) -> Image: """Computes a binary image with pixel values 0 and 1 containing the binary erosion of a given input image. diff --git a/pyclesperanto_prototype/_tier1/_generate_distance_matrix.py b/pyclesperanto_prototype/_tier1/_generate_distance_matrix.py index dd7be664..bf1d5377 100644 --- a/pyclesperanto_prototype/_tier1/_generate_distance_matrix.py +++ b/pyclesperanto_prototype/_tier1/_generate_distance_matrix.py @@ -3,7 +3,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(output_creator=create_matrix_from_pointlists, categories=['bia-bob-suggestion']) +@plugin_function(output_creator=create_matrix_from_pointlists, categories=[]) def generate_distance_matrix(coordinate_list1 :Image, coordinate_list2 :Image, distance_matrix_destination :Image = None) -> Image: """Computes the distance between all point coordinates given in two point lists. diff --git a/pyclesperanto_prototype/_tier1/_generate_touch_matrix.py b/pyclesperanto_prototype/_tier1/_generate_touch_matrix.py index 52ad2c7e..075f7ed7 100644 --- a/pyclesperanto_prototype/_tier1/_generate_touch_matrix.py +++ b/pyclesperanto_prototype/_tier1/_generate_touch_matrix.py @@ -3,7 +3,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(output_creator=create_square_matrix_from_labelmap, categories=['bia-bob-suggestion']) +@plugin_function(output_creator=create_square_matrix_from_labelmap, categories=[]) def generate_touch_matrix(label_map :Image, touch_matrix_destination :Image = None) -> Image: """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. diff --git a/pyclesperanto_prototype/_tier1/_laplace_box.py b/pyclesperanto_prototype/_tier1/_laplace_box.py index e5705450..301444bd 100644 --- a/pyclesperanto_prototype/_tier1/_laplace_box.py +++ b/pyclesperanto_prototype/_tier1/_laplace_box.py @@ -3,7 +3,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['filter', 'edge detection', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'edge detection', 'in assistant']) def laplace_box(source : Image, destination : Image = None) -> Image: """Applies the Laplace operator (Box neighborhood) to an image. diff --git a/pyclesperanto_prototype/_tier1/_laplace_diamond.py b/pyclesperanto_prototype/_tier1/_laplace_diamond.py index 30a7eb9d..19c6bdd8 100644 --- a/pyclesperanto_prototype/_tier1/_laplace_diamond.py +++ b/pyclesperanto_prototype/_tier1/_laplace_diamond.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['filter', 'edge detection', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'edge detection']) def laplace_diamond(source : Image, destination : Image = None) -> Image: """Applies the Laplace operator (Diamond neighborhood) to an image. diff --git a/pyclesperanto_prototype/_tier1/_mask.py b/pyclesperanto_prototype/_tier1/_mask.py index 4e2f5ddc..03592cfd 100644 --- a/pyclesperanto_prototype/_tier1/_mask.py +++ b/pyclesperanto_prototype/_tier1/_mask.py @@ -2,7 +2,7 @@ from .._tier0 import Image from .._tier0 import plugin_function -@plugin_function(categories=['bia-bob-suggestion']) +@plugin_function(categories=[]) def mask(source : Image, mask : Image, destination : Image = None) -> Image: """Computes a masked image by applying a binary mask to an image. diff --git a/pyclesperanto_prototype/_tier1/_mask_label.py b/pyclesperanto_prototype/_tier1/_mask_label.py index edf108ca..0561523a 100644 --- a/pyclesperanto_prototype/_tier1/_mask_label.py +++ b/pyclesperanto_prototype/_tier1/_mask_label.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['bia-bob-suggestion']) +@plugin_function(categories=[]) def mask_label(source : Image, label_map : Image, destination : Image = None, label_index : int = 1) -> Image: """Computes a masked image by applying a label mask to an image. diff --git a/pyclesperanto_prototype/_tier1/_maximum_image_and_scalar.py b/pyclesperanto_prototype/_tier1/_maximum_image_and_scalar.py index 8547abcd..054d77c6 100644 --- a/pyclesperanto_prototype/_tier1/_maximum_image_and_scalar.py +++ b/pyclesperanto_prototype/_tier1/_maximum_image_and_scalar.py @@ -3,7 +3,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['filter', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'in assistant']) def maximum_image_and_scalar(source : Image, destination : Image = None, scalar : float = 0) -> Image: """Computes the maximum of a constant scalar s and each pixel value x in a given image X. diff --git a/pyclesperanto_prototype/_tier1/_maximum_images.py b/pyclesperanto_prototype/_tier1/_maximum_images.py index f52239ea..946d20f5 100644 --- a/pyclesperanto_prototype/_tier1/_maximum_images.py +++ b/pyclesperanto_prototype/_tier1/_maximum_images.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['combine', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['combine', 'in assistant']) def maximum_images(source1 : Image, source2 : Image, destination : Image = None) -> Image: """Computes the maximum of a pair of pixel values x, y from two given images X and Y. diff --git a/pyclesperanto_prototype/_tier1/_modulo_images.py b/pyclesperanto_prototype/_tier1/_modulo_images.py index 2bf2d54a..7d434fd4 100644 --- a/pyclesperanto_prototype/_tier1/_modulo_images.py +++ b/pyclesperanto_prototype/_tier1/_modulo_images.py @@ -3,7 +3,7 @@ from .._tier0 import Image from .._tier0 import plugin_function -@plugin_function(categories=['combine', 'bia-bob-suggestion']) +@plugin_function(categories=['combine']) def modulo_images(image1 : Image, image2 : Image, destination : Image = None) -> Image: """Computes the remainder of a division of pairwise pixel values in two images diff --git a/pyclesperanto_prototype/_tier1/_read_intensities_from_positions.py b/pyclesperanto_prototype/_tier1/_read_intensities_from_positions.py index 56c71723..ffc73706 100644 --- a/pyclesperanto_prototype/_tier1/_read_intensities_from_positions.py +++ b/pyclesperanto_prototype/_tier1/_read_intensities_from_positions.py @@ -3,7 +3,7 @@ from pyclesperanto_prototype._tier0 import create_none from .._tier0 import plugin_function -@plugin_function(output_creator=create_none, categories=['bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=[]) def read_intensities_from_positions(pointlist : Image, intensity_image : Image, values_destination : Image = None) -> Image: """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. diff --git a/pyclesperanto_prototype/_tier1/_standard_deviation_z_projection.py b/pyclesperanto_prototype/_tier1/_standard_deviation_z_projection.py index 061703eb..a10e373d 100644 --- a/pyclesperanto_prototype/_tier1/_standard_deviation_z_projection.py +++ b/pyclesperanto_prototype/_tier1/_standard_deviation_z_projection.py @@ -3,7 +3,7 @@ from .._tier0 import Image from .._tier0 import create_2d_yx -@plugin_function(output_creator=create_2d_yx, categories=['projection', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_2d_yx, categories=['projection', 'in assistant']) def standard_deviation_z_projection(source : Image, destination : Image = None) -> Image: """Determines the standard deviation intensity projection of an image stack along Z. diff --git a/pyclesperanto_prototype/_tier1/_variance_sphere.py b/pyclesperanto_prototype/_tier1/_variance_sphere.py index 772e0b30..74ecb2a4 100644 --- a/pyclesperanto_prototype/_tier1/_variance_sphere.py +++ b/pyclesperanto_prototype/_tier1/_variance_sphere.py @@ -4,7 +4,7 @@ from pyclesperanto_prototype._tier0 import radius_to_kernel_size -@plugin_function(categories=['filter', 'edge detection', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'edge detection', 'in assistant']) def variance_sphere(source: Image, destination: Image = None, radius_x : int = 1, radius_y : int = 1, radius_z : int = 1) -> Image: """Computes the local variance of a pixels sphere neighborhood. The sphere size is specified by its half-width, half-height and half-depth (radius). If 2D images are given, radius_z will be ignored. diff --git a/pyclesperanto_prototype/_tier2/_bottom_hat_sphere.py b/pyclesperanto_prototype/_tier2/_bottom_hat_sphere.py index b9f61c0a..2cab4798 100644 --- a/pyclesperanto_prototype/_tier2/_bottom_hat_sphere.py +++ b/pyclesperanto_prototype/_tier2/_bottom_hat_sphere.py @@ -5,7 +5,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['filter', 'background removal', 'in assistant', 'bia-bob-suggestion'], priority=-1) +@plugin_function(categories=['filter', 'background removal', 'in assistant'], priority=-1) def bottom_hat_sphere(source : Image, destination : Image = None, radius_x : float = 1, radius_y : float = 1, radius_z : float = 1) -> Image: """Applies a bottom-hat filter for background subtraction to the input image. diff --git a/pyclesperanto_prototype/_tier2/_combine_horizontally.py b/pyclesperanto_prototype/_tier2/_combine_horizontally.py index 1cc9b6f9..cf8a964f 100644 --- a/pyclesperanto_prototype/_tier2/_combine_horizontally.py +++ b/pyclesperanto_prototype/_tier2/_combine_horizontally.py @@ -4,7 +4,7 @@ from .._tier0 import Image from .._tier1 import paste -@plugin_function(output_creator=create_none, categories=['combine', 'transform', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['combine', 'transform', 'in assistant']) def combine_horizontally(stack1 : Image, stack2 : Image, destination : Image = None) -> Image: """Combines two images or stacks in X. diff --git a/pyclesperanto_prototype/_tier2/_combine_vertically.py b/pyclesperanto_prototype/_tier2/_combine_vertically.py index 6f381b5e..71a0fff5 100644 --- a/pyclesperanto_prototype/_tier2/_combine_vertically.py +++ b/pyclesperanto_prototype/_tier2/_combine_vertically.py @@ -4,7 +4,7 @@ from .._tier0 import Image from .._tier1 import paste -@plugin_function(output_creator=create_none, categories=['combine', 'transform', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['combine', 'transform', 'in assistant']) def combine_vertically(stack1 : Image, stack2 : Image, destination : Image = None) -> Image: """Combines two images or stacks in Y. diff --git a/pyclesperanto_prototype/_tier2/_concatenate_stacks.py b/pyclesperanto_prototype/_tier2/_concatenate_stacks.py index c2c08951..85f5da23 100644 --- a/pyclesperanto_prototype/_tier2/_concatenate_stacks.py +++ b/pyclesperanto_prototype/_tier2/_concatenate_stacks.py @@ -4,7 +4,7 @@ from .._tier0 import Image from .._tier1 import paste -@plugin_function(output_creator=create_none, categories=['combine', 'transform', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['combine', 'transform', 'in assistant']) def concatenate_stacks(stack1 : Image, stack2 : Image, destination : Image = None) -> Image: """Concatenates two stacks in Z. diff --git a/pyclesperanto_prototype/_tier2/_label_spots.py b/pyclesperanto_prototype/_tier2/_label_spots.py index 242db10f..0ced644f 100644 --- a/pyclesperanto_prototype/_tier2/_label_spots.py +++ b/pyclesperanto_prototype/_tier2/_label_spots.py @@ -6,7 +6,7 @@ from .._tier1 import sum_x_projection from .._tier1 import sum_y_projection -@plugin_function(categories=['label', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label', 'in assistant'], output_creator=create_labels_like) def label_spots(input_spots : Image, labelled_spots_destination : Image = None) -> Image: """Transforms a binary image with single pixles set to 1 to a labelled spots image. diff --git a/pyclesperanto_prototype/_tier2/_opening_sphere.py b/pyclesperanto_prototype/_tier2/_opening_sphere.py index 600c7b15..885f4ca4 100644 --- a/pyclesperanto_prototype/_tier2/_opening_sphere.py +++ b/pyclesperanto_prototype/_tier2/_opening_sphere.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(categories=['filter', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'in assistant']) def opening_sphere(input_image: Image, destination: Image = None, radius_x: int = 1, radius_y: int = 1, radius_z: int = 0) -> Image: """Opening operator, sphere-shaped diff --git a/pyclesperanto_prototype/_tier2/_pointlist_to_labelled_spots.py b/pyclesperanto_prototype/_tier2/_pointlist_to_labelled_spots.py index 986c7a86..29b9a9b7 100644 --- a/pyclesperanto_prototype/_tier2/_pointlist_to_labelled_spots.py +++ b/pyclesperanto_prototype/_tier2/_pointlist_to_labelled_spots.py @@ -8,7 +8,7 @@ from .._tier1 import set_ramp_x from .._tier1 import add_image_and_scalar -@plugin_function(output_creator=create_from_pointlist, categories=['bia-bob-suggestion']) +@plugin_function(output_creator=create_from_pointlist, categories=[]) def pointlist_to_labelled_spots(pointlist : Image, spots_destination : Image = None) -> Image: """Takes a pointlist with dimensions n times d with n point coordinates in d dimensions and labels corresponding pixels. diff --git a/pyclesperanto_prototype/_tier2/_reduce_stack.py b/pyclesperanto_prototype/_tier2/_reduce_stack.py index f2892ea2..af6f1dac 100644 --- a/pyclesperanto_prototype/_tier2/_reduce_stack.py +++ b/pyclesperanto_prototype/_tier2/_reduce_stack.py @@ -6,7 +6,7 @@ from .._tier0 import create from .._tier1 import copy_slice -@plugin_function(output_creator=create_none, categories=['transform', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['transform', 'in assistant']) def reduce_stack(source : Image, destination : Image = None, reduction_factor : int = 2, offset : int = 0) -> Image: """Reduces the number of slices in a stack by a given factor. With the offset you have control which slices stay: diff --git a/pyclesperanto_prototype/_tier2/_standard_deviation_sphere.py b/pyclesperanto_prototype/_tier2/_standard_deviation_sphere.py index 347e96e3..c0a577f0 100644 --- a/pyclesperanto_prototype/_tier2/_standard_deviation_sphere.py +++ b/pyclesperanto_prototype/_tier2/_standard_deviation_sphere.py @@ -1,7 +1,7 @@ from pyclesperanto_prototype._tier0 import plugin_function from pyclesperanto_prototype._tier0 import Image -@plugin_function(categories=['filter', 'edge detection', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'edge detection', 'in assistant']) def standard_deviation_sphere(source: Image, destination: Image = None, radius_x : int = 1, radius_y : int = 1, radius_z : int = 1) -> Image: """Computes the local standard deviation of a pixels sphere neighborhood. The box size is specified by its half-width, half-height and half-depth (radius). If 2D images are given, radius_z will be ignored. diff --git a/pyclesperanto_prototype/_tier2/_sub_stack.py b/pyclesperanto_prototype/_tier2/_sub_stack.py index 25feac9a..0e66ab92 100644 --- a/pyclesperanto_prototype/_tier2/_sub_stack.py +++ b/pyclesperanto_prototype/_tier2/_sub_stack.py @@ -6,7 +6,7 @@ from .._tier0 import create from .._tier1 import copy_slice -@plugin_function(output_creator=create_none, categories=['transform', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['transform', 'in assistant']) def sub_stack(source : Image, destination : Image = None, start_z : int = 0, end_z : int = 0) -> Image: """Crops multiple Z-slices of a 3D stack into a new 3D stack. diff --git a/pyclesperanto_prototype/_tier3/_absolute_difference.py b/pyclesperanto_prototype/_tier3/_absolute_difference.py index 3585c0b2..7930cc24 100644 --- a/pyclesperanto_prototype/_tier3/_absolute_difference.py +++ b/pyclesperanto_prototype/_tier3/_absolute_difference.py @@ -4,7 +4,7 @@ from pyclesperanto_prototype._tier2 import subtract_images from pyclesperanto_prototype._tier1 import absolute -@plugin_function(categories=['combine', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['combine', 'in assistant']) def absolute_difference(source1 : Image, source2 : Image, destination : Image = None) -> Image: """Determines the absolute difference pixel by pixel between two images. diff --git a/pyclesperanto_prototype/_tier3/_divide_by_gaussian_background.py b/pyclesperanto_prototype/_tier3/_divide_by_gaussian_background.py index 8420cced..6e7591a4 100644 --- a/pyclesperanto_prototype/_tier3/_divide_by_gaussian_background.py +++ b/pyclesperanto_prototype/_tier3/_divide_by_gaussian_background.py @@ -4,7 +4,7 @@ from pyclesperanto_prototype._tier0 import plugin_function from pyclesperanto_prototype._tier1 import divide_images -@plugin_function(categories=['filter', 'background removal', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['filter', 'background removal', 'in assistant']) def divide_by_gaussian_background(source : Image, destination : Image = None, sigma_x : float = 2, sigma_y : float = 2, sigma_z : float = 2) -> Image: """Applies Gaussian blur to the input image and divides the original by the result. diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py b/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py index eb61d945..430a4a6d 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels_outside_size_range.py @@ -4,7 +4,7 @@ from .._tier0 import create_none from .._tier0 import create_like -@plugin_function(output_creator=create_none, categories=['label processing', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['label processing', 'in assistant']) def exclude_labels_outside_size_range(source : Image, destination : Image = None, minimum_size : float = 0, maximum_size : float = 100) -> Image: """Removes labels from a label map which are not within a certain size range. diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py b/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py index 12a98f61..7cc887cc 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_out_of_range.py @@ -4,7 +4,7 @@ from .._tier0 import create_none from .._tier0 import create_like -@plugin_function(output_creator=create_none, categories=['label processing', 'combine', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['label processing', 'combine']) def exclude_labels_with_values_out_of_range(values_vector : Image, label_map_input : Image, label_map_destination : Image = None, minimum_value_range : float = 0, maximum_value_range : float = 100) -> Image: """This operation removes labels from a labelmap and renumbers the remaining labels. diff --git a/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_within_range.py b/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_within_range.py index de5e6bfe..2b32c558 100644 --- a/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_within_range.py +++ b/pyclesperanto_prototype/_tier3/_exclude_labels_with_values_within_range.py @@ -4,7 +4,7 @@ from .._tier0 import create_none from .._tier0 import create_like -@plugin_function(output_creator=create_none, categories=['label processing', 'combine', 'bia-bob-suggestion']) +@plugin_function(output_creator=create_none, categories=['label processing', 'combine']) def exclude_labels_with_values_within_range(values_vector : Image, label_map_input : Image, label_map_destination : Image = None, minimum_value_range : float = 0, maximum_value_range : float = 100) -> Image: """This operation removes labels from a labelmap and renumbers the remaining labels. diff --git a/pyclesperanto_prototype/_tier3/_labelled_spots_to_pointlist.py b/pyclesperanto_prototype/_tier3/_labelled_spots_to_pointlist.py index 80ebcceb..ee100731 100644 --- a/pyclesperanto_prototype/_tier3/_labelled_spots_to_pointlist.py +++ b/pyclesperanto_prototype/_tier3/_labelled_spots_to_pointlist.py @@ -4,7 +4,7 @@ from .._tier0 import plugin_function from .._tier0 import Image -@plugin_function(output_creator=create_pointlist_from_labelmap, categories=['bia-bob-suggestion']) +@plugin_function(output_creator=create_pointlist_from_labelmap, categories=[]) def labelled_spots_to_pointlist(input_labelled_spots:Image, destination_pointlist :Image = None) -> Image: """Generates a coordinate list of points in a labelled spot image. diff --git a/pyclesperanto_prototype/_tier3/_squared_difference.py b/pyclesperanto_prototype/_tier3/_squared_difference.py index 8ad99e39..f6bed99f 100644 --- a/pyclesperanto_prototype/_tier3/_squared_difference.py +++ b/pyclesperanto_prototype/_tier3/_squared_difference.py @@ -4,7 +4,7 @@ from pyclesperanto_prototype._tier2 import subtract_images from pyclesperanto_prototype._tier1 import power -@plugin_function(categories=['combine', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['combine', 'in assistant']) def squared_difference(source1 : Image, source2 : Image, destination : Image = None) -> Image: """Determines the squared difference pixel by pixel between two images. diff --git a/pyclesperanto_prototype/_tier4/_erode_connected_labels.py b/pyclesperanto_prototype/_tier4/_erode_connected_labels.py index 48966821..3e34c2f7 100644 --- a/pyclesperanto_prototype/_tier4/_erode_connected_labels.py +++ b/pyclesperanto_prototype/_tier4/_erode_connected_labels.py @@ -2,7 +2,7 @@ from .._tier0 import plugin_function from .._tier0 import create_labels_like -@plugin_function(categories=['label processing', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label processing', 'in assistant'], output_creator=create_labels_like) def erode_connected_labels(labels_input : Image, labels_destination : Image = None, radius: int = 1) -> Image: """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 diff --git a/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py b/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py index c8f57100..fdf5d77d 100644 --- a/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py +++ b/pyclesperanto_prototype/_tier4/_extend_labeling_via_voronoi.py @@ -9,7 +9,7 @@ from .._tier1 import onlyzero_overwrite_maximum_diamond import numpy as np -@plugin_function(categories=['label processing', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label processing', 'in assistant'], output_creator=create_labels_like) def extend_labeling_via_voronoi(labeling_source : Image, labeling_destination : Image = None) -> Image: """Takes a label map image and dilates the regions using a octagon shape until they touch. diff --git a/pyclesperanto_prototype/_tier4/_extended_depth_of_focus_variance_projection.py b/pyclesperanto_prototype/_tier4/_extended_depth_of_focus_variance_projection.py index 63ac1e86..4de75770 100644 --- a/pyclesperanto_prototype/_tier4/_extended_depth_of_focus_variance_projection.py +++ b/pyclesperanto_prototype/_tier4/_extended_depth_of_focus_variance_projection.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function, Image, create_2d_yx -@plugin_function(output_creator = create_2d_yx, categories=['projection', 'bia-bob-suggestion']) +@plugin_function(output_creator = create_2d_yx, categories=['projection']) def extended_depth_of_focus_variance_projection(source : Image, destination : Image = None, radius_x : int = 10, radius_y : int = 10, sigma : float = 5) -> Image: """Extended depth of focus projection maximizing local pixel intensity variance. diff --git a/pyclesperanto_prototype/_tier4/_mean_squared_error.py b/pyclesperanto_prototype/_tier4/_mean_squared_error.py index d54d52f4..e2890022 100644 --- a/pyclesperanto_prototype/_tier4/_mean_squared_error.py +++ b/pyclesperanto_prototype/_tier4/_mean_squared_error.py @@ -4,7 +4,7 @@ from .._tier3 import squared_difference from .._tier3 import mean_of_all_pixels -@plugin_function(categories=['in assistant', 'combine', 'bia-bob-suggestion']) +@plugin_function(categories=['in assistant', 'combine']) def mean_squared_error(source1 : Image, source2 : Image) -> float: """Determines the mean squared error (MSE) between two images. diff --git a/pyclesperanto_prototype/_tier4/_proximal_neighbor_count_map.py b/pyclesperanto_prototype/_tier4/_proximal_neighbor_count_map.py index c15fd55f..3899700a 100644 --- a/pyclesperanto_prototype/_tier4/_proximal_neighbor_count_map.py +++ b/pyclesperanto_prototype/_tier4/_proximal_neighbor_count_map.py @@ -2,7 +2,7 @@ from .._tier0 import Image import numpy as np -@plugin_function(categories=['label measurement', 'map', 'in assistant', 'bia-bob-suggestion'], priority=1) +@plugin_function(categories=['label measurement', 'map', 'in assistant'], priority=1) def proximal_neighbor_count_map(source : Image, destination : Image = None, min_distance : float = 0, max_distance : float = np.finfo(np.float32).max) -> Image: """Takes a label map, determines which labels are within a give distance range and replaces every label with the number of neighboring labels. diff --git a/pyclesperanto_prototype/_tier4/_touching_neighbor_count_map.py b/pyclesperanto_prototype/_tier4/_touching_neighbor_count_map.py index f94a636a..cce5f539 100644 --- a/pyclesperanto_prototype/_tier4/_touching_neighbor_count_map.py +++ b/pyclesperanto_prototype/_tier4/_touching_neighbor_count_map.py @@ -4,7 +4,7 @@ from .._tier1 import count_touching_neighbors from .._tier1 import replace_intensities -@plugin_function(categories=['label measurement', 'map', 'in assistant', 'bia-bob-suggestion'], priority=1) +@plugin_function(categories=['label measurement', 'map', 'in assistant'], priority=1) def touching_neighbor_count_map(source : Image, destination : Image = None) -> Image: """Takes a label map, determines which labels touch and replaces every label with the number of touching neighboring labels. diff --git a/pyclesperanto_prototype/_tier5/_closing_labels.py b/pyclesperanto_prototype/_tier5/_closing_labels.py index df9f5c47..b0462709 100644 --- a/pyclesperanto_prototype/_tier5/_closing_labels.py +++ b/pyclesperanto_prototype/_tier5/_closing_labels.py @@ -4,7 +4,7 @@ from .._tier4 import dilate_labels -@plugin_function(categories=['label processing', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label processing', 'in assistant'], output_creator=create_labels_like) def closing_labels(labels_input: Image, labels_destination: Image = None, radius: int = 0) -> Image: """Apply a morphological closing operation to a label image. diff --git a/pyclesperanto_prototype/_tier5/_masked_voronoi_labeling.py b/pyclesperanto_prototype/_tier5/_masked_voronoi_labeling.py index 57d35117..74be6c37 100644 --- a/pyclesperanto_prototype/_tier5/_masked_voronoi_labeling.py +++ b/pyclesperanto_prototype/_tier5/_masked_voronoi_labeling.py @@ -4,7 +4,7 @@ from .._tier4 import connected_components_labeling_box from .._tier4 import extend_labeling_via_voronoi -@plugin_function(categories=['label', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label'], output_creator=create_labels_like) def masked_voronoi_labeling(binary_source : Image, mask_image : Image, labeling_destination : Image = None) -> Image: """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. diff --git a/pyclesperanto_prototype/_tier5/_opening_labels.py b/pyclesperanto_prototype/_tier5/_opening_labels.py index e54487e6..c8f41653 100644 --- a/pyclesperanto_prototype/_tier5/_opening_labels.py +++ b/pyclesperanto_prototype/_tier5/_opening_labels.py @@ -4,7 +4,7 @@ from .._tier4 import dilate_labels, erode_labels -@plugin_function(categories=['label processing', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label processing', 'in assistant'], output_creator=create_labels_like) def opening_labels(labels_input: Image, labels_destination: Image = None, radius: int = 0) -> Image: """Apply a morphological opening operation to a label image. diff --git a/pyclesperanto_prototype/_tier6/_merge_labels_with_border_intensity_within_range.py b/pyclesperanto_prototype/_tier6/_merge_labels_with_border_intensity_within_range.py index 371cd47b..d4e4959d 100644 --- a/pyclesperanto_prototype/_tier6/_merge_labels_with_border_intensity_within_range.py +++ b/pyclesperanto_prototype/_tier6/_merge_labels_with_border_intensity_within_range.py @@ -2,7 +2,7 @@ import numpy as np -@plugin_function(categories=['label processing', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label processing', 'in assistant'], output_creator=create_labels_like) def merge_labels_with_border_intensity_within_range(image: Image, labels: Image, labels_destination: Image = None, diff --git a/pyclesperanto_prototype/_tier8/_rigid_transform.py b/pyclesperanto_prototype/_tier8/_rigid_transform.py index b49b088e..20562a47 100644 --- a/pyclesperanto_prototype/_tier8/_rigid_transform.py +++ b/pyclesperanto_prototype/_tier8/_rigid_transform.py @@ -1,7 +1,7 @@ from .._tier0 import plugin_function from .._tier0 import Image, create_none, create_like -@plugin_function(categories=['transform', 'in assistant', 'bia-bob-suggestion'], output_creator=create_none) +@plugin_function(categories=['transform', 'in assistant'], output_creator=create_none) def rigid_transform( source: Image, destination: Image = None, diff --git a/pyclesperanto_prototype/_tier9/_average_distance_of_n_nearest_neighbors_map.py b/pyclesperanto_prototype/_tier9/_average_distance_of_n_nearest_neighbors_map.py index 0a1a8b53..4dff37b0 100644 --- a/pyclesperanto_prototype/_tier9/_average_distance_of_n_nearest_neighbors_map.py +++ b/pyclesperanto_prototype/_tier9/_average_distance_of_n_nearest_neighbors_map.py @@ -3,7 +3,7 @@ from .._tier1 import replace_intensities from .._tier0 import Image -@plugin_function(categories=['label measurement', 'map', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['label measurement', 'map', 'in assistant']) def average_distance_of_n_nearest_neighbors_map(labels : Image, distance_map : Image = None, n : int = 1) -> Image: """Takes a label map, determines distances between all centroids and replaces every label with the average distance to the n closest diff --git a/pyclesperanto_prototype/_tier9/_average_neighbor_distance_map.py b/pyclesperanto_prototype/_tier9/_average_neighbor_distance_map.py index a7c880ec..d6b574fd 100644 --- a/pyclesperanto_prototype/_tier9/_average_neighbor_distance_map.py +++ b/pyclesperanto_prototype/_tier9/_average_neighbor_distance_map.py @@ -2,7 +2,7 @@ from .._tier1 import replace_intensities from .._tier0 import Image -@plugin_function(categories=['label measurement', 'in assistant', 'bia-bob-suggestion']) +@plugin_function(categories=['label measurement', 'in assistant']) def average_neighbor_distance_map(labels : Image, distance_map : Image = None) -> Image: """Takes a label map, determines which labels touch and replaces every label with the average distance to their neighboring labels. diff --git a/pyclesperanto_prototype/_tier9/_eroded_otsu_labeling.py b/pyclesperanto_prototype/_tier9/_eroded_otsu_labeling.py index 5967314f..fc913d37 100644 --- a/pyclesperanto_prototype/_tier9/_eroded_otsu_labeling.py +++ b/pyclesperanto_prototype/_tier9/_eroded_otsu_labeling.py @@ -1,6 +1,6 @@ from .._tier0 import plugin_function, Image, create_labels_like -@plugin_function(categories=['label', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label', 'in assistant'], output_creator=create_labels_like) def eroded_otsu_labeling(image: Image, labels_destination: Image = None, number_of_erosions: int = 5, outline_sigma: float = 2) -> Image: """Segments and labels an image using blurring, Otsu-thresholding, binary erosion and masked Voronoi-labeling. diff --git a/pyclesperanto_prototype/_tier9/_gauss_otsu_labeling.py b/pyclesperanto_prototype/_tier9/_gauss_otsu_labeling.py index 5a71ca62..62000edf 100644 --- a/pyclesperanto_prototype/_tier9/_gauss_otsu_labeling.py +++ b/pyclesperanto_prototype/_tier9/_gauss_otsu_labeling.py @@ -3,7 +3,7 @@ from .._tier0 import Image -@plugin_function(categories=['label', 'in assistant', 'bia-bob-suggestion'], output_creator=create_labels_like) +@plugin_function(categories=['label', 'in assistant'], output_creator=create_labels_like) def gauss_otsu_labeling(source : Image, label_image_destination : Image = None, outline_sigma : float = 2) -> Image: """Labels objects directly from grey-value images. From 156e41e875818aa1f288ee34cf6d3892fe8968bc Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Mon, 29 Apr 2024 17:39:22 +0200 Subject: [PATCH 2/3] update author email --- setup.cfg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.cfg b/setup.cfg index 32675c55..ea56cbb9 100644 --- a/setup.cfg +++ b/setup.cfg @@ -2,7 +2,7 @@ name = pyclesperanto_prototype version = 0.24.2 author = Robert Haase -author_email = robert.haase@tu-dresden.de +author_email = robert.haase@uni-leipzig.de url = https://github.com/clEsperanto/pyclesperanto_prototype license = BSD-3-Clause description = GPU-accelerated image processing in python using OpenCL From d6d5e36a6051b07a0f76d95c01822ca856e4289a Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Mon, 29 Apr 2024 17:39:45 +0200 Subject: [PATCH 3/3] bump version --- pyclesperanto_prototype/__init__.py | 2 +- setup.cfg | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pyclesperanto_prototype/__init__.py b/pyclesperanto_prototype/__init__.py index 74bde097..bc287ade 100644 --- a/pyclesperanto_prototype/__init__.py +++ b/pyclesperanto_prototype/__init__.py @@ -10,5 +10,5 @@ from ._tier10 import * from ._tier11 import * -__version__ = "0.24.2" +__version__ = "0.24.3" __common_alias__ = "cle" diff --git a/setup.cfg b/setup.cfg index ea56cbb9..922899f8 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,6 +1,6 @@ [metadata] name = pyclesperanto_prototype -version = 0.24.2 +version = 0.24.3 author = Robert Haase author_email = robert.haase@uni-leipzig.de url = https://github.com/clEsperanto/pyclesperanto_prototype