def tophat_test(plot=True): arr = np.ones((100, 100), dtype="float64") yy, xx = np.mgrid[-50:50, -50:50] arr[xx**2 + yy**2 <= 30**2] = 0.0 struct = disk(32).astype("uint8") bth_nd = nd.black_tophat(arr, structure=struct) bth_cv = cv2.morphologyEx(arr, cv2.MORPH_BLACKHAT, struct) if plot: import matplotlib.pyplot as p p.subplot(131) p.imshow(bth_nd) p.colorbar() p.subplot(132) p.imshow(bth_cv) p.colorbar() p.subplot(133) p.imshow(np.abs(bth_nd - bth_cv)) p.colorbar() p.show() np.testing.assert_equal(bth_nd, bth_cv)
def watersplit(_probs, _points, img_pil, blob_ind): import numpy as np from skimage.morphology import watershed from skimage.segmentation import find_boundaries from scipy import ndimage from scipy import ndimage as ndi points = _points.copy() img_pilb = img_pil.convert('L') # points[points!=0] = np.arange(1, points.sum()+1) points = ndi.label(points)[0] points = points.astype(float) # probs = ndimage.black_tophat(_probs.copy(), 7) probs = ndimage.black_tophat(_probs.clone(), 7) # seg = watershed(probs, points, mask=img_pilb) water_mask = watershed(probs, points, mask=blob_ind) mask_list = [] for p in np.unique(points): if p == 0: continue y_list, x_list = np.where(points==p) mask_list += [{'yi':y_list[0], 'xi':x_list[0], 'mask':water_mask==p}] # for i, mask_dict in enumerate(mask_list): # img_maskspil = hi.mask_on_image(img_pil, mask_dict['mask']) # img_points = hi.points_on_image([mask_dict['yi']], [mask_dict['xi']], img_maskspil) # hu.save_image('water_mask_%d.jpg' % i, img_points) return mask_list
def tophat_test(plot=True): arr = np.ones((100, 100), dtype="float64") yy, xx = np.mgrid[-50:50, -50:50] arr[xx**2 + yy**2 <= 30**2] = 0.0 struct = disk(32).astype("uint8") bth_nd = nd.black_tophat(arr, structure=struct) bth_cv = cv2.morphologyEx(arr, cv2.MORPH_BLACKHAT, struct) if plot: import matplotlib.pyplot as p p.subplot(131) p.imshow(bth_nd) p.colorbar() p.subplot(132) p.imshow(bth_cv) p.colorbar() p.subplot(133) p.imshow(np.abs(bth_nd-bth_cv)) p.colorbar() p.show() np.testing.assert_equal(bth_nd, bth_cv)
def seperate_lungs(self, image): segemented_array = np.zeros(image.shape) marker_internal, marker_external, marker_watershed = self.generate_marker( image) # value of gradient (slope) in X and Y-direction sobel_filtered_dx = ndimage.sobel( image, 1) # vertical derivate ( detects horizontal edges) sobel_filtered_dy = ndimage.sobel( image, 0) # horizontal derivate (detects vertical edges) sobel_gradient = np.hypot( sobel_filtered_dx, sobel_filtered_dy ) # magnitude of gradient, gets rids of a (-)ve sign sobel_gradient *= 255.0 / np.max( sobel_gradient ) # normalize (This is our landscape image and we will fit it with water) watershed = morphology.watershed(sobel_gradient, marker_watershed) outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) # Creation of the disk-kernel blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 7) outline += ndimage.black_tophat(outline, structure=blackhat_struct) lungfilter = np.bitwise_or(marker_internal, outline) lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones( (5, 5)), iterations=3) segmented = np.where(lungfilter == 1, image, -2000 * np.ones( (512, 512))) segemented_array = segmented return segmented
def seperate_skull(image): marker_internal, marker_external, marker_watershed = generate_markers( image) sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) watershed = morphology.watershed(sobel_gradient, marker_watershed) outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) outline += ndimage.black_tophat(outline, structure=blackhat_struct) lungfilter = np.bitwise_or(marker_internal, outline) lungfilter = ndimage.morphology.binary_closing( lungfilter, structure=np.ones((5, 5)), iterations=3) segmented = np.where(lungfilter == 1, image, -2000 * np.ones((512, 512))) return segmented
def tophat(img, params): if params['footprint_shape'] == 'rectangle': footprint = np.ones( (params['footprint_size_y'], params['footprint_size_x']), dtype=int) elif params['footprint_shape'] == 'ellipse': a = params['footprint_size_x'] / 2 b = params['footprint_size_y'] / 2 x, y = np.mgrid[-ceil(a):ceil(a) + 1, -ceil(b):ceil(b) + 1] footprint = ((x / a)**2 + (y / b)**2 < 1) * 1 mode = params['mode'] cval = params['cval'] origin = params['origin'] if params['type'] == 'black': return ndimage.black_tophat(img, size=None, footprint=footprint, structure=None, mode=mode, cval=cval, origin=origin) elif params['type'] == 'white': return ndimage.white_tophat(img, size=None, footprint=footprint, structure=None, mode=mode, cval=cval, origin=origin)
def test_black_tophat_operation_sparse_input_struct_zeros(self): struct = np.zeros((3, 3, 3)) print("\n test_black_tophat_operation_sparse_input_struct_zeros...") v_output = vc.black_tophat(input_svar, structure=struct, make_float32=False) d_output = ndimage.black_tophat(input_svar, structure=struct) msgs = "test_black_tophat_operation_sparse_input_struct_zeros" self.assertTrue((d_output == v_output).all(), msg=msgs)
def test_3d_fallback_black_tophat(): image = np.ones((7, 7, 7), dtype=bool) image[2, 2:4, 2:4] = 0 image[3, 2:5, 2:5] = 0 image[4, 3:5, 3:5] = 0 new_image = grey.black_tophat(image) footprint = ndimage.generate_binary_structure(3,1) image_expected = ndimage.black_tophat(image,footprint=footprint) testing.assert_array_equal(new_image, image_expected)
def watersplit(_probs, _points): points = _points.copy() points[points != 0] = np.arange(1, points.sum() + 1) points = points.astype(float) probs = ndimage.black_tophat(_probs.copy(), 7) seg = watershed(probs, points) return find_boundaries(seg)
def get_filtered_lung(image): # Creation of the internal Marker marker_internal = image < -500 marker_internal = segmentation.clear_border(marker_internal) marker_internal_labels = measure.label(marker_internal) areas = [r.area for r in measure.regionprops(marker_internal_labels)] areas.sort() if len(areas) > 2: for region in measure.regionprops(marker_internal_labels): if region.area < areas[-2]: for coordinates in region.coords: marker_internal_labels[coordinates[0], coordinates[1]] = 0 marker_internal = marker_internal_labels > 0 # Creation of the external Marker external_a = ndimage.binary_dilation(marker_internal, iterations=10) external_b = ndimage.binary_dilation(marker_internal, iterations=55) marker_external = external_b ^ external_a # Creation of the Watershed Marker matrix marker_watershed = np.zeros((512, 512), dtype=np.int) marker_watershed += marker_internal * 255 marker_watershed += marker_external * 128 # Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) # Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) # Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) # Performing Black-Tophat Morphology for reinclusion # Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) # Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) # Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) # Close holes in the lungfilter # fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5, 5)), iterations=3) return lungfilter
def test_black_tophat_operation_sparse_input_default_value(self): print("\n test_black_tophat_operation_sparse_input_default_value...") v_output = vc.black_tophat(input_svar, structure=structure, make_float32=False) d_output = ndimage.black_tophat( input_svar, structure=structure, ) msgs = "test_black_tophat_operation_sparse_input_default_value" self.assertTrue((d_output == v_output).all(), msg=msgs)
def __test_black_tophat_operation(self,input_var): print("\n black_tophat Voxel testing...") start_time = t.time() v_output = vc.black_tophat(input_var,structure=structure,no_of_blocks=PL[0],fakeghost=PL[1],make_float32=False) print("black_tophat Voxel testing time taken: ",(t.time() - start_time)," sec") #print("\n black_tophat Default testing...") start_time = t.time() d_output = ndimage.black_tophat(input_var,structure=structure) print("black_tophat Default testing time taken: ",(t.time() - start_time)," sec") msgs = "black_tophat_operation_FAIL_with parameters: ",PL self.assertTrue((d_output==v_output).all(), msg=msgs)
def test_black_tophat_operation_sparse_input_blocks_ten(self): print("\n test_black_tophat_operation_sparse_input_blocks_ten...") v_output = vc.black_tophat(input_svar, structure=structure, no_of_blocks=10, make_float32=False) d_output = ndimage.black_tophat( input_svar, structure=structure, ) msgs = "test_black_tophat_operation_sparse_input_blocks_ten" self.assertTrue((d_output == v_output).all(), msg=msgs)
def test_3d_fallback_black_tophat(): image = np.ones((7, 7, 7), dtype=bool) image[2, 2:4, 2:4] = 0 image[3, 2:5, 2:5] = 0 image[4, 3:5, 3:5] = 0 with expected_warnings(['operator.*deprecated|\A\Z']): new_image = grey.black_tophat(image) footprint = ndi.generate_binary_structure(3,1) with expected_warnings(['operator.*deprecated|\A\Z']): image_expected = ndi.black_tophat(image,footprint=footprint) testing.assert_array_equal(new_image, image_expected)
def test_black_tophat_operation_dense_input_fakeghost_four(self): print("\n test_black_tophat_operation_dense_input_fakeghost_four...") v_output = vc.black_tophat(input_dvar, structure=structure, fakeghost=4, make_float32=False) d_output = ndimage.black_tophat( input_dvar, structure=structure, ) msgs = "test_black_tophat_operation_dense_input_fakeghost_four" self.assertTrue((d_output == v_output).all(), msg=msgs)
def test_3d_fallback_black_tophat(): image = np.ones((7, 7, 7), dtype=bool) image[2, 2:4, 2:4] = 0 image[3, 2:5, 2:5] = 0 image[4, 3:5, 3:5] = 0 with expected_warnings(['operator.*deprecated|\A\Z']): new_image = grey.black_tophat(image) footprint = ndi.generate_binary_structure(3, 1) with expected_warnings(['operator.*deprecated|\A\Z']): image_expected = ndi.black_tophat(image, footprint=footprint) assert_array_equal(new_image, image_expected)
def exer1(): cells_binary = color.rgb2gray(io.imread('./Week 5/cells_binary.png')) # cells_binary = np.max(cells_binary) - cells_binary ball = disk(2) opened = opening(cells_binary, ball) closed = closing(cells_binary, ball) # fig, ax = plt.subplots(1, 3) # ax[0].imshow(cells_binary, cmap='gray') # ax[1].imshow(closed, cmap='gray') # ax[2].imshow(opened, cmap='gray') # plt.show() io.imsave('ball.png', ball) io.imsave('opened.png', opened) io.imsave('closed.png', closed) blobs_inv = io.imread('./Week 5/blobs_inv.png') blobs_inv = np.max(blobs_inv) - blobs_inv se0 = np.array([[1, 1, 1, 1, 1]]) se1 = disk(2) print() print(se1) se2 = np.array([[0, 0, 0], [1, 1, 0], [1, 1, 0]]) hitormiss0 = binary_hit_or_miss(blobs_inv, se0, origin1=[0, 2]) hitormiss1 = binary_hit_or_miss(blobs_inv, se1, 1 - disk(12)) hitormiss2 = binary_hit_or_miss(blobs_inv, se2, 1 - se2) top_hat0 = white_tophat(blobs_inv, se0) top_hat1 = white_tophat(blobs_inv, se1) top_hat2 = white_tophat(blobs_inv, se2) btop_hat0 = black_tophat(blobs_inv, se0) btop_hat1 = black_tophat(blobs_inv, se1) btop_hat2 = black_tophat(blobs_inv, se2) plt.imshow(hitormiss2, cmap='gray') plt.savefig('hitormiss2pdf')
def separate_lungs(image, return_list=None, iteration=-1): """ This only takes in a 2D slice to make he lung segmentation and takes really long to run. But supposedly will get all corner cases. Not sure if mask from this is very good. Looks like the mask might be too dilated. :param image: :param return_list: :param iteration: :return: """ #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = generate_markers( image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5, 5)), iterations=3) # #Apply the lungfilter (note the filtered areas being assigned -2000 HU) # segmented = np.where(lungfilter == 1, image, -2000*np.ones((512, 512))) if iteration >= 0 and return_list: return_list[iteration] = lungfilter else: return lungfilter
def fill_border_holes_with_black_hat(self, outline): blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 2) outline += ndimage.black_tophat(outline, structure=blackhat_struct) return outline
def seperate_lungs(image): """ Function conducts lung segmentation process using watershed algorithm :param image: a pixel array :return: segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed: np ndarrays of segmented lungs (segmented) and other markers used in the process """ # Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = SegmentationA.generate_markers( image) # Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) # Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) # Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) # Performing Black-Tophat Morphology for reinclusion # Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) # Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) # Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) # Close holes in the lungfilter # fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones( (5, 5)), iterations=3) # Apply the lungfilter (note the filtered areas being assigned -2000 HU) segmented = np.where(lungfilter == 1, image, -2000 * np.ones( (len(image), len(image[0])))) return segmented, lungfilter
def __operationTask(self,input_var): ''' perform respective moephological operation on input block. Parameters ---------- input_var : type: 3d numpy array, ith block. Returns ------- output : type: 3d array, output of operation, ith block array. ''' D=self.__operationArgumentDic if self.__operation=="binary_closing": return ndimage.binary_closing(input_var, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif self.__operation=="binary_dilation": return ndimage.binary_dilation(input_var, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif self.__operation=="binary_erosion": return ndimage.binary_erosion(input_var, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif self.__operation=="binary_fill_holes": #the output might be different then scipy.ndimage return ndimage.binary_fill_holes(input_var, structure=D["structure"],output=D["output"], origin=D["origin"]) elif self.__operation=="binary_hit_or_miss": return ndimage.binary_hit_or_miss(input_var, structure1=D["structure1"],structure2=D["structure2"],output=D["output"], origin1=D["origin1"], origin2=D["origin2"]) elif self.__operation=="binary_opening": return ndimage.binary_opening(input_var, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif self.__operation=="binary_propagation": return ndimage.binary_propagation(input_var, structure=D["structure"],output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"]) elif self.__operation=="black_tophat": return ndimage.black_tophat(input_var, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif self.__operation=="grey_dilation": return ndimage.grey_dilation(input_var, structure=D["structure"],size=D["size"], footprint=D["footprint"],output=D["output"], mode=D["mode"], cval=D["cval"], origin=D["origin"]) elif self.__operation=="grey_closing": return ndimage.grey_closing(input_var, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif self.__operation=="grey_erosion": return ndimage.grey_erosion(input_var, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif self.__operation=="grey_opening": return ndimage.grey_opening(input_var, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif self.__operation=="morphological_gradient": return ndimage.morphological_gradient(input_var, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif self.__operation=="morphological_laplace": return ndimage.morphological_laplace(input_var, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif self.__operation=="white_tophat": return ndimage.white_tophat(input_var, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif self.__operation=="multiply": return input_var*D["scalar"] else: return input_var # no operation performed....
def get_segmented_lungs(image): #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = generate_markers( image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] #blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) blackhat_struct = ndimage.iterate_structure( blackhat_struct, 14 ) # <- retains more of the area, 12 works well. Changed to 14, 12 still excluded some parts. #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5, 5)), iterations=3) #Apply the lungfilter (note the filtered areas being assigned threshold_min HU) segmented = np.where(lungfilter == 1, image, threshold_min * np.ones(image.shape)) #return segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed return segmented
def seperate_lungs(image, min_hu, iterations, threshold=-700): """ Segments lungs using various techniques. Parameters: image (Scan image), iterations (more iterations, more accurate mask) Returns: - Segmented Lung """ h, w = image.shape[0], image.shape[1] marker_internal, marker_external, marker_watershed = generate_markers( image, threshold) # Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) if np.max(sobel_gradient) == 0: return image sobel_gradient *= 255.0 / np.max(sobel_gradient) watershed = segmentation.watershed(sobel_gradient, marker_watershed) outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) # Structuring element used for the filter blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, iterations) # Perform Black Top-hat filter outline += ndimage.black_tophat(outline, structure=blackhat_struct) lungfilter = np.bitwise_or(marker_internal, outline) lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5, 5)), iterations=3) segmented = np.where(lungfilter == 1, image, min_hu * np.ones((h, w))) return segmented
def get_segmented_lungs(image): #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = generate_markers(image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3,3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] #blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) blackhat_struct = ndimage.iterate_structure(blackhat_struct, 14) # <- retains more of the area, 12 works well. Changed to 14, 12 still excluded some parts. #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5,5)), iterations=3) #Apply the lungfilter (note the filtered areas being assigned threshold_min HU) segmented = np.where(lungfilter == 1, image, threshold_min*np.ones(image.shape)) #return segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed return segmented
def get_segmented_lungs(self, image, plot=False): # TODO: might add the logic for plotting the filters applied in the process #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = self.generate_markers(image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndi.sobel(image, 1) sobel_filtered_dy = ndi.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndi.morphological_gradient(watershed, size=(3,3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndi.iterate_structure(blackhat_struct, 8) #Perform the Black-Hat outline += ndi.black_tophat(outline, structure=blackhat_struct) #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndi.morphology.binary_closing(lungfilter, structure=np.ones((5,5)), iterations=3) #Apply the lungfilter (the filtered areas being assigned 0 HU segmented = np.where(lungfilter == 1, image, np.zeros(image.shape)) return segmented
def operationTask(input): D=operationArgumentDic #self.M.add_mem()#..................................................................................................... if operation=="binary_closing": return ndimage.binary_closing(input, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif operation=="binary_dilation": return ndimage.binary_dilation(input, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif operation=="binary_erosion": return ndimage.binary_erosion(input, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif operation=="binary_fill_holes": return ndimage.binary_fill_holes(input, structure=D["structure"],output=D["output"], origin=D["origin"]) elif operation=="binary_hit_or_miss": return ndimage.binary_hit_or_miss(input, structure1=D["structure1"],structure2=D["structure2"],output=D["output"], origin1=D["origin1"], origin2=D["origin2"]) elif operation=="binary_opening": return ndimage.binary_opening(input, structure=D["structure"], iterations=D["iterations"], output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"], brute_force=D["brute_force"]) elif operation=="binary_propagation": return ndimage.binary_propagation(input, structure=D["structure"],output=D["output"], origin=D["origin"], mask=D["mask"], border_value=D["border_value"]) elif operation=="black_tophat": return ndimage.black_tophat(input, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif operation=="grey_dilation": return ndimage.grey_dilation(input, structure=D["structure"],size=D["size"], footprint=D["footprint"],output=D["output"], mode=D["mode"], cval=D["cval"], origin=D["origin"]) elif operation=="grey_closing": return ndimage.grey_closing(input, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif operation=="grey_erosion": return ndimage.grey_erosion(input, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif operation=="grey_opening": return ndimage.grey_opening(input, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif operation=="morphological_gradient": return ndimage.morphological_gradient(input, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif operation=="morphological_laplace": return ndimage.morphological_laplace(input, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif operation=="white_tophat": return ndimage.white_tophat(input, structure=D["structure"], size=D["size"], footprint=D["footprint"], output=D["output"], origin=D["origin"],mode=D["mode"], cval=D["cval"]) elif operation=="intMultiply": return input*D["scalar"] else: return input
def Exer114(): ''' NOT USED Returns ------- None. ''' A = io.imread("./Week 5/cells_binary.png") def LargeOpening(I, n): for i in range(n): I = binary_erosion(I) for i in range(n): I = binary_dilation(I) return (I) fig_d = [1, 3] SE = A[367:395, 217:245] plt.figure() plt.subplot(fig_d[0], fig_d[1], 1) plotImage(gca(), opening(opening(SE)), 'SE_hit', gray=True) plt.subplot(fig_d[0], fig_d[1], 2) plotImage(gca(), black_tophat(opening(opening(A))[250:350, 350:450], ), 'Opening', gray=True) plt.subplot(fig_d[0], fig_d[1], 3) plotImage(gca(), closing(closing(A)[250:350, 350:450]), 'Closing', gray=True)
def water_regions(_probs, _points, return_dict=False): points = _points.copy() if return_dict: y_ind, x_ind = np.where(points != 0) yx_list = [] for i in range(y_ind.shape[0]): label = i + 1 points[y_ind[i], x_ind[i]] = label yx_list += [{"y": y_ind[i], "x": x_ind[i], "label": label}] points = points.astype(float) else: points[points != 0] = np.arange(1, points.sum() + 1) points = points.astype(float) probs = ndimage.black_tophat(_probs.copy(), 7) seg = watershed(probs, points) if return_dict: return {"seg": seg, "yx_list": yx_list} return seg
def threshold(img, radius, threshold): smoothed = nd.black_tophat(img, radius) difference = img - smoothed return difference > scoreatpercentile(difference[np.where(~np.isnan(difference))], threshold)
def seperateLungs(image, n_iters=2, only_internal=False, only_watershed=False): """ Segments lungs using various techniques. Parameters: image (Scan image) Returns: - Segmented Lung - Lung Filter - Outline Lung - Watershed Lung - Sobel Gradient """ if only_internal: marker_internal = generateMarkers(image, only_internal) else: marker_internal, marker_external, marker_watershed = generateMarkers( image, only_internal) ''' Creation of Sobel Gradient ''' # Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) ''' Using the watershed algorithm We pass the image convoluted by sobel operator and the watershed marker to morphology.watershed and get a matrix matrix labeled using the watershed segmentation algorithm. ''' watershed = morphology.watershed(sobel_gradient, marker_watershed) if only_watershed: return watershed ''' Reducing the image to outlines after Watershed algorithm ''' outline = ndimage.morphological_gradient(watershed, size=(3, 3)) outline = outline.astype(bool) ''' Black Top-hat Morphology: The black top hat of an image is defined as its morphological closing minus the original image. This operation returns the dark spots of the image that are smaller than the structuring element. Note that dark spots in the original image are bright spots after the black top hat. ''' # Structuring element used for the filter blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, n_iters) # Perform Black Top-hat filter outline += ndimage.black_tophat(outline, structure=blackhat_struct) outline += ndimage.black_tophat(outline, structure=blackhat_struct) ''' Generate lung filter using internal marker and outline. ''' lungfilter = np.bitwise_or(marker_internal, outline) lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5, 5)), iterations=3) ''' Segment lung using lungfilter and the image. ''' segmented = np.where(lungfilter == 1, image, -2000 * np.ones(image.shape)) return segmented, lungfilter, outline, watershed, sobel_gradient
def seperate_lungs_and_pad(scan): # make total 256 slices fill in -1100 as exterme value segmented_scan = np.full ((256, 512, 512), THRESHOLD_LOW) for i, image in enumerate (scan): # Ignore all slices later than 255 if required. if (i == 256): break # Creation of the internal Marker marker_internal = image < -400 marker_internal = segmentation.clear_border(marker_internal) marker_internal_labels = measure.label(marker_internal) areas = [r.area for r in measure.regionprops(marker_internal_labels)] areas.sort() if len(areas) > 2: for region in measure.regionprops(marker_internal_labels): if region.area < areas[-2]: for coordinates in region.coords: marker_internal_labels[coordinates[0], coordinates[1]] = 0 marker_internal = marker_internal_labels > 0 #Creation of the external Marker external_a = ndimage.binary_dilation(marker_internal, iterations=10) external_b = ndimage.binary_dilation(marker_internal, iterations=55) marker_external = external_b ^ external_a #Creation of the Watershed Marker matrix marker_watershed = np.zeros((512, 512), dtype=np.int) marker_watershed += marker_internal * 255 marker_watershed += marker_external * 128 #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, 1) sobel_filtered_dy = ndimage.sobel(image, 0) sobel_gradient = np.hypot(sobel_filtered_dx, sobel_filtered_dy) sobel_gradient *= 255.0 / np.max(sobel_gradient) #Watershed algorithm watershed = morphology.watershed(sobel_gradient, marker_watershed) #Reducing the image created by the Watershed algorithm to its outline outline = ndimage.morphological_gradient(watershed, size=(3,3)) outline = outline.astype(bool) #Performing Black-Tophat Morphology for reinclusion #Creation of the disk-kernel and increasing its size a bit blackhat_struct = [[0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0]] blackhat_struct = ndimage.iterate_structure(blackhat_struct, 8) #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) #Use the internal marker and the Outline that was just created to generate the lungfilter lungfilter = np.bitwise_or(marker_internal, outline) #Close holes in the lungfilter #fill_holes is not used here, since in some slices the heart would be reincluded by accident lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=np.ones((5,5)), iterations=3) #Apply the lungfilter (note the filtered areas being assigned 30 HU) segmented_scan[i] = np.where(lungfilter == 1, image, 30*np.ones((512, 512))) return segmented_scan
output = vc.black_tophat(input_var, make_float32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("vc black_tophat: ", (t.time() - start_time), " sec") print("\nblack_tophat Default") start_time = t.time() d = ndimage.black_tophat(input_var, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("scipy black_tophat: ", (t.time() - start_time), " sec") print("\nresult: ", (d == output).all()) #13.morphological_gradient.............. print("\nmorphological_gradient VoxelProcessing") start_time = t.time() output = vc.morphological_gradient(input_var, make_float32=False, size=None, footprint=None, structure=structure, output=None,
def main(): structure = np.ones((3, 3, 3)) #.............test1. dense....... filename = 'gyroidUniform.npy' input = np.load(filename, mmap_mode="r") print( "..............................dense.............................................." ) #0.Nothing.............. print("\n nothing testing...") output = vc.nothing(input, blockSize=50, fakeGhost=4, makeFloat32=False) print("\nresult: ", (input == output).all()) print(output.dtype, input.dtype) #1.grey_dilation.............. print("\ngrey_dilation VoxelProcessind") output = vc.grey_dilation(input, structure=structure, makeFloat32=False) print("\ngrey_dilation Default") d = ndimage.grey_dilation(input, structure=structure) print("\nresult: ", (d == output).all()) print(output.dtype, input.dtype) #2.grey_erosion.............. print("\ngrey_erosion VoxelProcessind") output = vc.grey_erosion(input, makeFloat32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\ngrey_erosion Default") d = ndimage.grey_erosion(input, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nresult: ", (d == output).all()) #3.grey_closing.............. print("\ngrey_closing VoxelProcessind") output = vc.grey_closing(input, makeFloat32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\ngrey_closing Default") d = ndimage.grey_closing(input, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nresult: ", (d == output).all()) print(output.dtype, input.dtype) #4.grey_opening.............. print("\ngrey_opening VoxelProcessind") output = vc.grey_opening(input, makeFloat32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\ngrey_opening Default") d = ndimage.grey_opening(input, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nresult: ", (d == output).all()) #5.binary_closing.............. print("\nbinary_closing VoxelProcessind") output = vc.binary_closing(input, makeFloat32=False, structure=None, iterations=1, output=None, origin=0, mask=None, border_value=0, brute_force=False) print("\nbinary_closing Default") d = ndimage.binary_closing(input, structure=None, iterations=1, output=None, origin=0, mask=None, border_value=0, brute_force=False) print("\nresult: ", (d == output).all()) print(output[151][151][151]) #6.binary_opening.............. print("\nbinary_opening VoxelProcessind") output = vc.binary_opening(input, structure=None, iterations=1, output=None, origin=0, mask=None, border_value=0, brute_force=False) print("\nbinary_opening Default") d = ndimage.binary_opening(input, structure=None, iterations=1, output=None, origin=0, mask=None, border_value=0, brute_force=False) print("\nresult: ", (d == output).all()) #7.binary_dilation.............. print("\nbinary_dilation VoxelProcessind") output = vc.binary_dilation(input, makeFloat32=False, structure=structure, iterations=1, mask=None, output=None, border_value=0, origin=0, brute_force=False) print("\nbinary_dilation Default") d = ndimage.binary_dilation(input, structure=structure, iterations=1, mask=None, output=None, border_value=0, origin=0, brute_force=False) print("\nresult: ", (d == output).all()) #8.binary_erosion.............. print("\nbinary_erosion VoxelProcessind") output = vc.binary_erosion(input, makeFloat32=False, structure=None, iterations=1, mask=None, output=None, border_value=0, origin=0, brute_force=False) print("\nbinary_erosion Default") d = ndimage.binary_erosion(input, structure=None, iterations=1, mask=None, output=None, border_value=0, origin=0, brute_force=False) print("\nresult: ", (d == output).all()) #9.binary_fill_holes.............. print("\nbinary_fill_holes VoxelProcessind") output = vc.binary_fill_holes(input, makeFloat32=False, structure=None, output=None, origin=0) print("\nbinary_fill_holes Default") d = ndimage.binary_fill_holes(input, structure=None, output=None, origin=0) print("\nresult: ", (d == output).all()) #10.binary_hit_or_miss.............. print("\nbinary_hit_or_miss VoxelProcessind") output = vc.binary_hit_or_miss(input, makeFloat32=False, structure1=None, structure2=None, output=None, origin1=0, origin2=None) print("\nbinary_hit_or_miss Default") d = ndimage.binary_hit_or_miss(input, structure1=None, structure2=None, output=None, origin1=0, origin2=None) print("\nresult: ", (d == output).all()) #11.binary_propagation.............. print("\nbinary_propagation VoxelProcessind") output = vc.binary_propagation(input, makeFloat32=False, structure=None, mask=None, output=None, border_value=0, origin=0) print("\nbinary_propagation Default") d = ndimage.binary_propagation(input, structure=None, mask=None, output=None, border_value=0, origin=0) print("\nresult: ", (d == output).all()) #12.black_tophat.............. print("\nblack_tophat VoxelProcessind") output = vc.black_tophat(input, makeFloat32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nblack_tophat Default") d = ndimage.black_tophat(input, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nresult: ", (d == output).all()) #13.morphological_gradient.............. print("\nmorphological_gradient VoxelProcessind") output = vc.morphological_gradient(input, makeFloat32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nmorphological_gradient Default") d = ndimage.morphological_gradient(input, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nresult: ", (d == output).all()) #14.morphological_laplace.............. print("\nmorphological_laplace VoxelProcessind") output = vc.morphological_laplace(input, makeFloat32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nmorphological_laplace Default") d = ndimage.morphological_laplace(input, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nresult: ", (d == output).all()) #15.white_tophat.............. print("\nwhite_tophat VoxelProcessind") output = vc.white_tophat(input, makeFloat32=False, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nwhite_tophat VoxelProcessind Default") d = ndimage.white_tophat(input, size=None, footprint=None, structure=structure, output=None, mode='reflect', cval=0.0, origin=0) print("\nresult: ", (d == output).all()) #16.intMultiply.............. print("\nintMultiply VoxelProcessind") output = vc.intMultiply(input, makeFloat32=False, blockSize=50, fakeGhost=1, scalar=10) print("\nintMultiply Default") d = input * 10 print("\nresult: ", (d == output).all()) print( "..............................Sparse.............................................." ) input = random(400, 80000, density=0.3, dtype="float64") input = input.todense() input = np.array(input) input = np.reshape(input, (400, 200, 400)) #0.Nothing.............. print("\n nothing testing...") output = vc.nothing(input, makeFloat32=False) print("\nresult: ", (input == output).all()) print(output.dtype, input.dtype) #1.grey_dilation.............. print("\ngrey_dilation VoxelProcessind") output = vc.grey_dilation(input, structure=structure, makeFloat32=False) print("\ngrey_dilation Default") d = ndimage.grey_dilation(input, structure=structure) print("\nresult: ", (d == output).all()) print(output.dtype, input.dtype) #2.grey_erosion.............. print("\ngrey_erosion VoxelProcessind") output = vc.grey_erosion(input, makeFloat32=False, structure=structure) print("\ngrey_erosion Default") d = ndimage.grey_erosion(input, structure=structure) print("\nresult: ", (d == output).all()) #3.grey_closing.............. print("\ngrey_closing VoxelProcessind") output = vc.grey_closing(input, makeFloat32=False, structure=structure) print("\ngrey_closing Default") d = ndimage.grey_closing(input, structure=structure) print("\nresult: ", (d == output).all()) print(output.dtype, input.dtype) #4.grey_opening.............. print("\ngrey_opening VoxelProcessind") output = vc.grey_opening(input, makeFloat32=False, structure=structure) print("\ngrey_opening Default") d = ndimage.grey_opening(input, structure=structure) print("\nresult: ", (d == output).all()) #5.binary_closing.............. print("\nbinary_closing VoxelProcessind") output = vc.binary_closing(input, makeFloat32=False) print("\nbinary_closing Default") d = ndimage.binary_closing(input) print("\nresult: ", (d == output).all()) #6.binary_opening.............. print("\nbinary_opening VoxelProcessind") output = vc.binary_opening(input, makeFloat32=False) print("\nbinary_opening Default") d = ndimage.binary_opening(input) print("\nresult: ", (d == output).all()) #7.binary_dilation.............. print("\nbinary_dilation VoxelProcessind") output = vc.binary_dilation(input, makeFloat32=False, structure=structure) print("\nbinary_dilation Default") d = ndimage.binary_dilation(input, structure=structure) print("\nresult: ", (d == output).all()) #8.binary_erosion.............. print("\nbinary_erosion VoxelProcessind") output = vc.binary_erosion(input, makeFloat32=False) print("\nbinary_erosion Default") d = ndimage.binary_erosion(input) print("\nresult: ", (d == output).all()) #9.binary_fill_holes.............. print("\nbinary_fill_holes VoxelProcessind") output = vc.binary_fill_holes(input, makeFloat32=False) print("\nbinary_fill_holes Default") d = ndimage.binary_fill_holes(input) print("\nresult: ", (d == output).all()) #10.binary_hit_or_miss.............. print("\nbinary_hit_or_miss VoxelProcessind") output = vc.binary_hit_or_miss(input, makeFloat32=False) print("\nbinary_hit_or_miss Default") d = ndimage.binary_hit_or_miss(input) print("\nresult: ", (d == output).all()) #11.binary_propagation.............. print("\nbinary_propagation VoxelProcessind") output = vc.binary_propagation(input, makeFloat32=False) print("\nbinary_propagation Default") d = ndimage.binary_propagation(input) print("\nresult: ", (d == output).all()) #12.black_tophat.............. print("\nblack_tophat VoxelProcessind") output = vc.black_tophat(input, makeFloat32=False, structure=structure) print("\nblack_tophat Default") d = ndimage.black_tophat(input, structure=structure) print("\nresult: ", (d == output).all()) #13.morphological_gradient.............. print("\nmorphological_gradient VoxelProcessind") output = vc.morphological_gradient( input, structure=structure, makeFloat32=False, ) print("\nmorphological_gradient Default") d = ndimage.morphological_gradient(input, structure=structure) print("\nresult: ", (d == output).all()) #14.morphological_laplace.............. print("\nmorphological_laplace VoxelProcessind") output = vc.morphological_laplace(input, structure=structure, makeFloat32=False) print("\nmorphological_laplace Default") d = ndimage.morphological_laplace(input, structure=structure) print("\nresult: ", (d == output).all()) #15.white_tophat.............. print("\nwhite_tophat VoxelProcessind") output = vc.white_tophat(input, makeFloat32=False, structure=structure) print("\nwhite_tophat VoxelProcessind Default") d = ndimage.white_tophat(input, structure=structure) print("\nresult: ", (d == output).all()) #16.intMultiply.............. print("\nintMultiply VoxelProcessind") output = vc.intMultiply(input, makeFloat32=False, scalar=10) print("\nintMultiply Default") d = input * 10 print("\nresult: ", (d == output).all())