def test_connected_components_labeling_box_blobs():
import pyclesperanto_prototype as cle
from skimage.io import imread, imsave
# initialize GPU
cle.select_device("GTX")
print("Used GPU: " + cle.get_device().name)
# load data
image = imread('https://imagej.nih.gov/ij/images/blobs.gif')
print("Loaded image size: " + str(image.shape))
# push image to GPU memory
input = cle.push(image)
print("Image size in GPU: " + str(input.shape))
# process the image
inverted = cle.subtract_image_from_scalar(image, scalar=255)
blurred = cle.gaussian_blur(inverted, sigma_x=1, sigma_y=1)
binary = cle.threshold_otsu(blurred)
labeled = cle.connected_components_labeling_box(binary)
# The maxmium intensity in a label image corresponds to the number of objects
num_labels = cle.maximum_of_all_pixels(labeled)
# print out result
print("Num objects in the image: " + str(num_labels))
assert num_labels == 63
def test_multiply_image_and_coordinate():
test1 = cle.push(
np.asarray([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2]]))
reference = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]))
result = cle.create(test1)
cle.multiply_image_and_coordinate(test1, result, 0)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
assert (np.array_equal(a, b))
def workflow(input: Image, sigma=3, threshold: float = 30) -> Labels:
if input:
# push image to GPU memory and show it
gpu_input = cle.push(input.data)
# Spot detection
# After some noise removal/smoothing, we perform a local maximum detection
# gaussian blur
gpu_blurred = cle.gaussian_blur(gpu_input,
sigma_x=sigma,
sigma_y=sigma,
sigma_z=0)
# detect maxima
gpu_detected_maxima = cle.detect_maxima_box(gpu_blurred)
# Spot curation
# Now, we remove spots with values below a certain intensity and label the remaining spots
# threshold
gpu_thresholded = cle.greater_constant(gpu_blurred,
constant=threshold * 10)
# mask
gpu_masked_spots = cle.mask(gpu_detected_maxima, gpu_thresholded)
# label spots
gpu_labelled_spots = cle.connected_components_labeling_box(
gpu_masked_spots)
number_of_spots = cle.maximum_of_all_pixels(gpu_labelled_spots)
print("Number of detected spots: " + str(number_of_spots))
# Expanding labelled spots
# Next, we spatially extend the labelled spots by applying a maximum filter.
# label map closing
number_of_dilations = 10
number_of_erosions = 4
flip = cle.create_like(gpu_labelled_spots)
flop = cle.create_like(gpu_labelled_spots)
flag = cle.create([1, 1, 1])
cle.copy(gpu_labelled_spots, flip)
for i in range(0, number_of_dilations):
cle.onlyzero_overwrite_maximum_box(flip, flag, flop)
cle.onlyzero_overwrite_maximum_diamond(flop, flag, flip)
flap = cle.greater_constant(flip, constant=1)
for i in range(0, number_of_erosions):
cle.erode_box(flap, flop)
cle.erode_sphere(flop, flap)
gpu_labels = cle.mask(flip, flap)
output = cle.pull(gpu_labels)
return output
def test_threshold_otsu_against_scikit_image():
# threshold using skimage
from skimage.data import camera
from skimage.filters import threshold_otsu
image = camera()
thresh = threshold_otsu(image)
binary = image > thresh
print(thresh)
#from skimage import exposure
#counts, bin_centers = exposure.histogram(image.ravel(), 256, source_range='image')
#print(str(counts))
#print(str(bin_centers))
# threshold in GPU
import pyclesperanto_prototype as cle
gpu_image = cle.push(image)
gpu_binary = cle.threshold_otsu(gpu_image)
print(str(binary))
print(str(cle.pull(gpu_binary)))
# compare
import numpy as np
assert(np.allclose(binary, (cle.pull(gpu_binary) > 0)))
def test_multiply_image_and_scalar():
test1 = cle.push(
np.asarray([[0, 0, 0, 0, 0], [1, 1, 1, 1, 1], [2, 2, 2, 2, 2]]))
reference = cle.push(
np.asarray([[0, 0, 0, 0, 0], [2, 2, 2, 2, 2], [4, 4, 4, 4, 4]]))
result = cle.create(test1)
cle.multiply_image_and_scalar(test1, result, 2)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
assert (np.array_equal(a, b))
def _binarize(input1: Layer,
operation_name: str = cle.threshold_otsu.__name__,
radius_x: int = 1,
radius_y: int = 1,
radius_z: int = 0,
myself=None):
if input1 is not None:
# execute operation
cle_input1 = cle.push(input1.data)
output = cle.create_like(cle_input1)
operation = cle.operation(operation_name)
# update GUI
label_parameters(
operation,
[myself.gui.radius_x, myself.gui.radius_y, myself.gui.radius_z])
_call_operation_ignoring_to_many_arguments(
operation, [cle_input1, output, radius_x, radius_y, radius_z])
output = cle.pull(output).astype(int)
# show result in napari
if not hasattr(myself, 'layer'):
myself.viewer.add_labels(output, translate=input1.translate)
else:
myself.layer.data = output
myself.layer.contrast_limits = (0, 1)
myself.layer.name = "Result of " + operation.__name__
myself.layer.translate = input1.translate
def test_maximum_image_and_scalar():
test1 = cle.push(
np.asarray([[0, 3, 4, 5, 0], [0, 2, 1, 6, 0], [0, 0, 8, 7, 0]]))
reference = cle.push(
np.asarray([[2, 3, 4, 5, 2], [2, 2, 2, 6, 2], [2, 2, 8, 7, 2]]))
result = cle.create(test1)
cle.maximum_image_and_scalar(test1, result, 2)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
assert (np.array_equal(a, b))
def test_exclude_labels_with_map_values_equal_to_constant_2d():
gpu_input = cle.push(np.asarray([[0, 1, 2, 3, 4, 5, 6]]))
gpu_reference = cle.push(np.asarray([[0, 1, 2, 0, 3, 4, 5]]))
gpu_output = cle.exclude_labels_with_map_values_equal_to_constant(
gpu_input, gpu_input, constant=3)
a = cle.pull(gpu_output)
b = cle.pull(gpu_reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def _denoise(input1: Image,
operation_name: str = cle.gaussian_blur.__name__,
x: float = 1,
y: float = 1,
z: float = 0,
myself=None):
if input1:
# execute operation
cle_input = cle.push(input1.data)
output = cle.create_like(cle_input)
operation = cle.operation(operation_name)
# update GUI
label_parameters(operation, [myself.gui.x, myself.gui.y, myself.gui.z])
_call_operation_ignoring_to_many_arguments(
operation, [cle_input, output, x, y, z])
max_intensity = cle.maximum_of_all_pixels(output)
if max_intensity == 0:
max_intensity = 1 # prevent division by zero in vispy
output = cle.pull(output)
# show result in napari
if not hasattr(myself, 'layer'):
myself.viewer.add_image(output,
colormap=input1.colormap,
translate=input1.translate)
else:
myself.layer.data = output
myself.layer.name = "Result of " + operation.__name__
myself.layer.contrast_limits = (0, max_intensity)
myself.layer.translate = input1.translate
def test_resample_downsample_3d():
test1 = cle.push(
np.asarray([[[0, 0, 2, 2], [0, 0, 2, 2], [1, 1, 4, 4], [1, 1, 4, 4]],
[[0, 0, 2, 2], [0, 0, 2, 2], [1, 1, 4, 4], [1, 1, 4, 4]],
[[5, 5, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5]],
[[5, 5, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5]]]))
reference = cle.push(np.asarray([[[0, 2], [1, 4]], [[5, 5], [5, 5]]]))
result = cle.resample(test1, factor_x=0.5, factor_y=0.5, factor_z=0.5)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
assert (np.array_equal(a, b))
def _projection(input1: Layer,
operation_name: str = cle.maximum_z_projection.__name__,
myself=None):
if input1 is not None:
# execute operation
cle_input1 = cle.push(input1.data)
output = None
operation = cle.operation(operation_name)
output = _call_operation_ignoring_to_many_arguments(
operation, [cle_input1, output])
output = cle.pull(output).astype(int)
# show result in napari
if not hasattr(myself, 'layer'):
if isinstance(input1, Labels):
myself.viewer.add_labels(output,
translate=input1.translate[1:3])
else:
myself.viewer.add_image(output,
translate=input1.translate[1:3])
else:
myself.layer.data = output
myself.layer.contrast_limits = input1.contrast_limits
myself.layer.name = "Result of " + operation.__name__
myself.layer.translate = input1.translate[1:3]
def _map(input1: Labels,
operation_name: str = cle.label_pixel_count_map.__name__,
n: float = 1,
myself=None):
if input1 is not None:
# execute operation
cle_input1 = cle.push(input1.data)
output = cle.create_like(cle_input1)
operation = cle.operation(operation_name)
# update GUI
label_parameters(operation, [myself.gui.n])
_call_operation_ignoring_to_many_arguments(operation,
[cle_input1, output, n])
max_intensity = cle.maximum_of_all_pixels(output)
if max_intensity == 0:
max_intensity = 1 # prevent division by zero in vispy
output = cle.pull(output)
# show result in napari
if not hasattr(myself, 'layer'):
myself.viewer.add_image(output,
colormap='turbo',
interpolation='nearest',
translate=input1.translate)
else:
myself.layer.data = output
myself.layer.name = "Result of " + operation.__name__
myself.layer.contrast_limits = (0, max_intensity)
myself.layer.translate = input1.translate
def _mesh(input1: Labels,
operation_name: str = cle.draw_mesh_between_touching_labels.__name__,
n: float = 1,
myself=None):
if input1 is not None:
# execute operation
cle_input1 = cle.push(input1.data)
output = cle.create_like(cle_input1)
operation = cle.operation(operation_name)
# update GUI
label_parameters(operation, [myself.gui.n])
_call_operation_ignoring_to_many_arguments(operation,
[cle_input1, output, n])
min_intensity = cle.minimum_of_all_pixels(output)
max_intensity = cle.maximum_of_all_pixels(output)
if max_intensity - min_intensity == 0:
max_intensity = min_intensity + 1 # prevent division by zero in vispy
output = cle.pull(output)
# show result in napari
if not hasattr(myself, 'layer'):
myself.viewer.add_image(output,
colormap='green',
blending='additive',
translate=input1.translate)
else:
myself.layer.data = output
myself.layer.name = "Result of " + operation.__name__
myself.layer.contrast_limits = (min_intensity, max_intensity)
myself.layer.translate = input1.translate
def test_set_column():
result = cle.push(
np.asarray([[3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3],
[3, 3, 3, 3, 3], [3, 3, 3, 3, 3]]))
reference = cle.push(
np.asarray([[3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3],
[4, 4, 4, 4, 4], [3, 3, 3, 3, 3]]))
cle.set_column(result, 3, 4)
print(result)
a = cle.pull(result)
b = cle.pull(reference)
assert (np.allclose(a, b, 0.001))
def test_label_label_mean_extension_map_2d():
labels = cle.push(np.asarray([[1, 1, 2], [1, 0, 0], [3, 3, 0]]))
reference = cle.push(
np.asarray([[0.65403885, 0.65403885, 0], [0.65403885, 0, 0],
[0.5, 0.5, 0]]))
result = cle.label_mean_extension_map(labels)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
print(b)
assert (np.allclose(a, b, 0.001))
def test_gradient_y():
test = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 1, 2, 0, 0], [0, 1, 2, 0, 0],
[0, 1, 3, 0, 0], [0, 0, 0, 0, 0]]))
reference = cle.push(
np.asarray([[0, 0, 0, 0, 0], [1, 2, -1, -2, 0], [1, 2, -1, -2, 0],
[1, 3, -1, -3, 0], [0, 0, 0, 0, 0]]))
result = cle.create(test)
cle.gradient_y(test, result)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
assert (np.array_equal(a, b))
def test_mean_of_all_pixels_3d():
test1 = cle.push(
np.asarray([[[0, 4, 0, 0, 2], [0, 0, 0, 8, 0], [3, 0, 0, 0, 0],
[0, 0, 0, 0, 1], [0, 5, 2, 0, 0]]]))
s = cle.mean_of_all_pixels(test1)
assert s == 1
def test_read_intensities_from_map():
intensities = cle.push(np.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
labels = cle.push(np.asarray([[8, 0, 7], [6, 5, 4], [3, 2, 1]]))
reference = cle.push(np.asarray([[2, 9, 8, 7, 6, 5, 4, 3, 1]]))
result = cle.read_intensities_from_map(labels, intensities)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def test_extend_labels_with_maximum_radius_3d():
gpu_input = cle.push(np.asarray([
[
[0, 0, 0, 0, 0, 2],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 4, 0, 0],
[0, 0, 0, 0, 0, 0],
[5, 0, 0, 0, 0, 3],
], [
[1, 0, 0, 0, 0, 2],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0],
[5, 0, 0, 0, 0, 0],
]
]))
gpu_reference = cle.push(np.asarray([
[
[1, 1, 0, 0, 2, 2],
[1, 1, 0, 0, 2, 2],
[0, 0, 4, 4, 4, 0],
[0, 0, 4, 4, 4, 0],
[5, 5, 4, 4, 4, 3],
[5, 5, 0, 0, 3, 3],
],[
[1, 1, 0, 0, 2, 2],
[1, 1, 0, 0, 2, 2],
[0, 0, 4, 4, 4, 0],
[0, 0, 4, 4, 4, 0],
[5, 5, 4, 4, 4, 3],
[5, 5, 0, 0, 3, 3],
]
]))
gpu_output = cle.extend_labels_with_maximum_radius(gpu_input, radius=1)
a = cle.pull(gpu_output)
b = cle.pull(gpu_reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def test_sobel():
test1 = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0],
[0, 0, 1, 0, 0], [0, 0, 0, 0, 0]]))
reference = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 1.41, 2, 1.41, 0],
[0, 3.16, 2, 3.16, 0], [0, 3.16, 2, 3.16, 0],
[0, 1.41, 2, 1.41, 0]]))
result = cle.create(test1)
cle.sobel(test1, result)
a = cle.pull(result)
print(a)
b = cle.pull(reference)
assert (np.allclose(a, b, 0.01))
def test_read_intensities_from_positions():
intensities = cle.push(np.asarray([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
pointlist = cle.push(np.asarray([[0, 1, 0], [0, 2, 2]]))
reference = cle.push(np.asarray([[1, 8, 7]]))
result = cle.read_intensities_from_positions(pointlist, intensities)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def test_labelled_spots_to_pointlist():
gpu_input = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 1, 0, 1, 0], [0, 0, 0, 0, 0],
[0, 0, 1, 0, 0], [0, 0, 0, 0, 1]]))
gpu_reference = cle.push(np.asarray([[1, 3, 2, 4], [1, 1, 3, 4]]))
gpu_output = cle.spots_to_pointlist(gpu_input)
a = cle.pull(gpu_output)
b = cle.pull(gpu_reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def test_label_mean_intensity_map_2d():
intensity = cle.push(np.asarray([[1, 1, 2], [4, 0, 0], [5, 3, 0]]))
labels = cle.push(np.asarray([[1, 1, 2], [1, 0, 0], [3, 3, 0]]))
reference = cle.push(np.asarray([[2, 2, 2], [2, 0, 0], [4, 4, 0]]))
result = cle.label_mean_intensity_map(intensity, labels)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def test_dilate_box():
test = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 1, 0, 0],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]))
reference = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0],
[0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]))
result = cle.create(test)
cle.dilate_box(test, result)
print(result)
a = cle.pull(result)
b = cle.pull(reference)
assert (np.array_equal(a, b))
def test_connected_components_labeling_diamond():
gpu_input = cle.push(
np.asarray([[[0, 1, 0, 1], [0, 1, 0, 0], [1, 0, 0, 1]]]))
gpu_reference = cle.push(
np.asarray([[[0, 1, 0, 2], [0, 1, 0, 0], [3, 0, 0, 4]]]))
gpu_output = cle.connected_components_labeling_diamond(gpu_input)
a = cle.pull_zyx(gpu_output)
b = cle.pull_zyx(gpu_reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def test_sum_of_all_pixels_2d():
test1 = cle.push(
np.asarray([[0, 4, 0, 0, 2], [0, 0, 0, 8, 0], [3, 0, 0, 0, 0],
[0, 0, 0, 0, 1], [0, 0, 2, 0, 0]]))
s = cle.sum_of_all_pixels(test1)
assert s == 20
def test_smaller_or_equal_constant():
test1 = cle.push(
np.asarray([[0, 0, 0, 0, 0], [0, 1, 2, 3, 0], [0, 2, 3, 4, 0],
[0, 4, 5, 5, 0], [0, 0, 0, 0, 0]]))
reference = cle.push(
np.asarray([[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 0, 1],
[1, 0, 0, 0, 1], [1, 1, 1, 1, 1]]))
result = cle.create(test1)
cle.smaller_constant(test1, result, 4)
print(result)
a = cle.pull(result)
b = cle.pull(reference)
assert (np.array_equal(a, b))
def test_apply_vector_field_2d():
source = cle.push(
np.asarray([
[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 2, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0],
]))
vector_x = cle.push(
np.asarray([
[0, 0, 0, 0, 0],
[0, 0.5, 0.5, 0.5, 0],
[0, 0.5, 1.0, 0.5, 0],
[0, 0.5, 0.5, 0.5, 0],
[0, 0, 0, 0, 0],
]))
vector_y = cle.push(
np.asarray([
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
]))
reference = cle.push(
np.asarray([
[0, 0, 0, 0, 0],
[0, 1, 1, 0, 0],
[0, 2, 1, 0, 0],
[0, 1, 1, 0, 0],
[0, 0, 0, 0, 0],
]))
result = cle.apply_vector_field(source, vector_x, vector_y)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
print(b)
assert (np.array_equal(a, b))
def test_set_ramp_x():
result = cle.push(
np.asarray([[[0, 0, 0], [3, 4, 3], [3, 4, 3]],
[[3, 4, 3], [3, 4, 3], [3, 4, 3]]]))
reference = cle.push(
np.asarray([[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
[[1, 1, 1], [1, 1, 1], [1, 1, 1]]]))
cle.set_ramp_x(result)
a = cle.pull(result)
b = cle.pull(reference)
print(a)
assert (np.allclose(a, b, 0.001))
def test_push_np():
reference = np.asarray([[1, 2], [-3, 4]])
image = cle.push(reference)
result = cle.pull(image)
assert np.allclose(result, reference)
