我们从Python开源项目中，提取了以下16个代码示例，用于说明如何使用scipy.ndimage.sobel()。
def run(self, ips, snap, img, para = None): imgs = ips.imgs gradient = np.zeros(imgs.shape, dtype=np.float32) gradient += ndimg.sobel(imgs, axis=0, output=np.float32)**2 gradient += ndimg.sobel(imgs, axis=1, output=np.float32)**2 gradient += ndimg.sobel(imgs, axis=2, output=np.float32)**2 gradient **= 0.5 msk = np.zeros(imgs.shape, dtype=np.uint8) msk[imgs>para['thr2']] = 1 msk[imgs<para['thr1']] = 2 #rst = watershed(gradient, msk) rst = watershed(gradient, msk.astype(np.uint16)) imgs[:] = (rst==1)*255 ips.lut = self.buflut
def image_gradient(image, horv): """apply a sobel filter to the image to approximate the gradient Parameters ---------- image : ndarray(h, v) image as an ndarray horv : string "h" or "v", direction of gradient. Returns ------- image_dir : ndarray(h, v) directional gradient magnitude at each pixel """ axis = 1 if horv == 'h' else 0 grad = ndi.sobel(image, axis, mode='constant', cval=np.nan) / 8.0 return np.nan_to_num(grad)
def compute_eng_grad(img): """ Computes the energy of an image using gradient magnitude Args: img4 (n,m,4 numpy matrix): RGB image with additional mask layer. rgb_weights (n,m numpy matrix): img-specific weights for RBG values Returns: n,m numpy matrix: Gradient energy map of the provided image """ bw_img = rgb_to_gray(img) eng = generic_gradient_magnitude(bw_img, sobel) eng = gaussian_gradient_magnitude(bw_img, 1) return normalize(eng)
def check_reg(fixed_img, moved_img, scale=15, norm=True, sigma=0.8, **kwargs): dim = list(moved_img.shape) resol = list(moved_img.header['pixdim'][1:4]) # Convert 4D image to 3D or raise error data = convert_to_3d(moved_img) # Check normalization if norm: data = apply_p2_98(data) # Set slice axis for mosaic grid slice_axis, cmap = check_sliceaxis_cmap(data, kwargs) cmap = 'YlOrRd' # Set grid shape data, slice_grid, size = set_mosaic_fig(data, dim, resol, slice_axis, scale) fig, axes = BrainPlot.mosaic(fixed_img, scale=scale, norm=norm, cmap='bone', **kwargs) # Applying inversion invert = check_invert(kwargs) data = apply_invert(data, *invert) # Plot image for i in range(slice_grid[1] * slice_grid[2]): ax = axes.flat[i] edge = data[:, :, i] edge = feature.canny(edge, sigma=sigma) # edge detection for second image # edge = ndimage.gaussian_filter(edge, 3) mask = np.ones(edge.shape) sx = ndimage.sobel(edge, axis=0, mode='constant') sy = ndimage.sobel(edge, axis=1, mode='constant') sob = np.hypot(sx, sy) mask[sob == False] = np.nan m_norm = colors.Normalize(vmin=0, vmax=1.5) if i < slice_grid[0] and False in np.isnan(mask.flatten()): ax.imshow(mask.T, origin='lower', interpolation='nearest', cmap=cmap, norm=m_norm, alpha=0.8) else: ax.imshow(np.zeros((dim[0], dim[1])).T, origin='lower', interpolation='nearest', cmap='bone') ax.set_axis_off() fig.set_facecolor('black') if notebook_env: display(fig) return fig, axes
def run(self, ips, snap, img, para = None): if para['axis']=='both': img[:] = np.abs(nimg.sobel(snap, axis=0, output=img.dtype)) img += np.abs( nimg.sobel(snap, axis=1, output=img.dtype)) else: nimg.sobel(snap, axis={'horizontal':0,'vertical':1}[para['axis']], output=img) img[:] = np.abs(img) img //= 4
def run(self, ips, imgs, para = None): gradient = np.zeros(imgs.shape, dtype=np.float32) gradient += ndimg.sobel(imgs, axis=0, output=np.float32)**2 gradient += ndimg.sobel(imgs, axis=1, output=np.float32)**2 gradient += ndimg.sobel(imgs, axis=2, output=np.float32)**2 gradient **= 0.5 gradient /= 8 if imgs.dtype == np.uint8: np.clip(gradient, 0, 255, gradient) imgs[:] = gradient
def generate_pattern(self, reference, size): """Extracts a pattern from the reference image. Firstly, the image is transformed to grayscale. A random square from image is picked. A pattern is extracted using the edge detection (Sobel's filter). :param reference: Reference image. :param int size: Size of a pattern (length of its edge). :returns: A pattern extracted from the image. """ # Import image from reference and convert it to grayscale. img = mpimg.imread(reference) gray = np.mean(img, -1) # Normalization of data to decimal (0.0 - 1.0) representation if gray.max() > 1.0: gray /= 255.0 # Extract a random slice with the pixel size given as parameter slice_center_x = random.randint(0, len(img[0]) - size - 1) slice_center_y = random.randint(0, len(img) - size - 1) slice = gray[slice_center_y: slice_center_y + size, slice_center_x: slice_center_x + size] # # Detects border to generate the pattern of the brush dx = ndimage.sobel(slice, 0) # horizontal derivative dy = ndimage.sobel(slice, 1) # vertical derivative pattern = np.hypot(dx, dy) # grayscale slice with border detection # Normalize pattern if pattern.max() > 1.0: return pattern / pattern.max() return pattern # Test
def _compute_derivatives(image, mode='constant', cval=0): """Compute derivatives the way that scikit-image does it (for comparison). This method is fully copied from the repository.""" imgy = ndimage.sobel(image, axis=0, mode=mode, cval=cval) imgx = ndimage.sobel(image, axis=1, mode=mode, cval=cval) return imgx, imgy
def seperate_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) #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 ##structure = np.ones((BINARY_CLOSING_SIZE,BINARY_CLOSING_SIZE)) # 5 is not enough, 7 is structure = morphology.disk(BINARY_CLOSING_SIZE) # better , 5 seems sufficient, we use 7 for safety/just in case lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=structure, iterations=3) #, iterations=3) # was structure=np.ones((5,5)) ### NOTE if no iterattions, i.e. default 1 we get holes within lungs for the disk(5) and perhaps more #Apply the lungfilter (note the filtered areas being assigned -2000 HU) segmented = np.where(lungfilter == 1, image, -2000*np.ones((512, 512))) ### was -2000 return segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed
def seperate_lungs_3d(image): #Creation of the markers as shown above: marker_internal, marker_external, marker_watershed = generate_markers_3d(image) #Creation of the Sobel-Gradient sobel_filtered_dx = ndimage.sobel(image, axis=2) sobel_filtered_dy = ndimage.sobel(image, axis=1) 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=(1,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 = blackhat_struct[np.newaxis,:,:] #Perform the Black-Hat outline += ndimage.black_tophat(outline, structure=blackhat_struct) # very long time #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 ##structure = np.ones((BINARY_CLOSING_SIZE,BINARY_CLOSING_SIZE)) # 5 is not enough, 7 is structure = morphology.disk(BINARY_CLOSING_SIZE) # better , 5 seems sufficient, we use 7 for safety/just in case structure = structure[np.newaxis,:,:] lungfilter = ndimage.morphology.binary_closing(lungfilter, structure=structure, iterations=3) #, iterations=3) # was structure=np.ones((5,5)) ### NOTE if no iterattions, i.e. default 1 we get holes within lungs for the disk(5) and perhaps more #Apply the lungfilter (note the filtered areas being assigned -2000 HU) segmented = np.where(lungfilter == 1, image, -2000*np.ones(marker_internal.shape)) return segmented, lungfilter, outline, watershed, sobel_gradient, marker_internal, marker_external, marker_watershed
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
