def thresholding(image, threshold): if isinstance(threshold,int) or isinstance(threshold,float): thresh = threshold elif isinstance(threshold,str): # Assume its Ok to use the same threshold for each layer. parsestr = threshold.split(" ") parsestr = [i.lower() for i in parsestr] parsestr = set(parsestr) if "otsu" in parsestr: if "global" in parsestr: ind = np.argmax([np.mean(i) for i in image]) thresh = filters.threshold_otsu(image[ind]) print thresh, ind elif "local" in parsestr: radius = int(parsestr[2]) mask = morphology.disk(radius) thresh = filters.rank.otsu(image,mask) if "li" in parsestr: thresh = filters.threshold_li(image) if "yen" in parsestr: thresh = filters.threshold_yen(image) threshinds = image<thresh binimg = np.ones(image.shape) binimg[threshinds] = 0 return binimg, thresh
def cont(imagen, depth=2**16, gaussian=3, screenpercent=0.7,t=0): imagen = gaussian_filter(imagen, gaussian) if t==0: otsu = threshold_otsu(imagen, depth) elif t==1: otsu = filters.threshold_isodata(imagen, depth) else: otsu = filters.threshold_li(imagen) imagen = binarizar(imagen, otsu) imagen = gaussian_filter(imagen, gaussian) contours = measure.find_contours(imagen, 1) centro = np.asanyarray([1280*0.5, 960*0.5]) while len(contours) > 1: if sum(np.abs(centro - contours[1].mean(axis=0)) < [1280*screenpercent*0.5, 960*screenpercent*0.5]) != 2: del contours[1] elif sum(np.abs(centro - contours[0].mean(axis=0)) < [1280*screenpercent*0.5, 960*screenpercent*0.5]) != 2: del contours[0] else: if contours[1].size < contours[0].size: del contours[1] else: del contours[0] return imagen, contours[0]
def main(filename,outfile): # Open geotiff file: geoimg = gdal.Open(filename, gdal.GA_ReadOnly) image = geoimg.ReadAsArray().astype(np.uint16) rows = geoimg.RasterYSize cols = geoimg.RasterXSize if geoimg.RasterCount>1: img = image.max(axis=0) else: img = image.copy(); mbi = proc_mbi(img) save_geotiff(outfile, mbi, geoimg, gdal.GDT_Float64) # otsu = filters.threshold_otsu(mbi,1024) # mbi_bw = (mbi > otsu) # save_geotiff('/Users/jorge/Documents/LSE/Sample1m/Sample1m_mbiBW_otsu.tif', mbi_bw, geoimg, gdal.GDT_Byte) # yen = filters.threshold_yen(mbi,1024) # mbi_bw = (mbi > yen) # save_geotiff('/Users/jorge/Documents/LSE/Sample1m/Sample1m_mbiBW_yen.tif', mbi_bw, geoimg, gdal.GDT_Byte) # isodata = filters.threshold_isodata(mbi,1024) # mbi_bw = (mbi > isodata) # save_geotiff('/Users/jorge/Documents/LSE/Sample1m/Sample1m_mbiBW_isodata.tif', mbi_bw, geoimg, gdal.GDT_Byte) li = filters.threshold_li(mbi) mbi_bw = (mbi > li) save_geotiff('/Users/jorge/Documents/LSE/Sample1m/Sample1m_mbiBW_li.tif', mbi_bw, geoimg, gdal.GDT_Byte) # mbi_bw = (mbi > 0) # save_geotiff('/Users/jorge/Documents/LSE/Sample1m/Sample1m_mbiBW_minVal.tif', mbi_bw, geoimg, gdal.GDT_Byte) return True
def process_file(filename): """ Main processing function; loads image file, runs some simple filters, and returns labelled image array """ data = load_data(filename) print("Loaded data", data.shape) # Grayscale filt = data.mean(axis=-1) # Basic threshold print("Running basic thresholding...") bw = filt > skfilt.threshold_li(filt) labels = skmeas.label(bw) return labels
def gen_background_mask( img ): """ Utility function for making MRI image masks to remove the background via threshold filter. Parameters ---------- img: Numpy array containing the CEST data images Array must be ordered as [ phe2, phe1, npts] Returns ------- A 2D image mask. """ if len( img.shape ) == 3: t = img[0] elif len( img.shape ) == 2: t = img mask = img > filters.threshold_li(t) return mask
print(fi) im =io.imread(fi) print(im.shape, im.dtype) binThrAd = filters.threshold_adaptive(im,21, method='median', offset=0, mode='reflect', param=None) thrIso = filters.threshold_isodata(im, nbins=256, return_all=False) binIso = im > thrIso tiIso = "Iso %d" % thrIso print(thrIso) thrLi = filters.threshold_li(im) binLi = im > thrLi tiLi = "Li %d" % thrLi thrOtsu = filters.threshold_otsu(im, nbins=256) binOtsu = im > thrOtsu tiOtsu = "Otsu %d" % thrOtsu thrYen = filters.threshold_yen(im, nbins=256) binYen = im > thrYen tiYen = "Yen %d" % thrYen # cImg = displayImg(binYen, name='coins-binYen') # cImg.show() fPan = displayAll([im, binThrAd, binIso, binLi, binOtsu, binYen], ["Original", "Adaptive", tiIso, tiLi, tiOtsu, tiYen], fSize=12)
from skimage import data, color, filters import matplotlib.pyplot as plt from skimage.morphology import disk import skimage.filters.rank as sfr original_image = color.rgb2gray(data.camera()) plt.imshow(original_image, cmap=plt.cm.gray) thresh = [] thresh.append(filters.threshold_otsu(original_image)) thresh.append(filters.threshold_yen(original_image)) thresh.append(filters.threshold_li(original_image)) thresh.append(filters.threshold_isodata(original_image)) filtered_images = [] for t in thresh: dst = (original_image <= t) * 1.0 # 根据阈值进行分割 filtered_images.append(dst) name_list = ['otsu', 'yen', 'li', 'isodata'] fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(8, 8)) axes = axes.ravel() for ax, img, name in zip(axes, filtered_images, name_list): ax.imshow(img, cmap=plt.cm.gray, interpolation='nearest') ax.set_title(name) for ax in axes: ax.axis('off') fig.tight_layout()
def thresholding_optimal(img): return img > filters.threshold_li(img)
def watershed_scikit(self, input_img, cell_size=None, first_threshold=None, second_threshold=None): img_uint8 = cv2.copyMakeBorder(input_img, 5, 5, 5, 5, cv2.BORDER_CONSTANT, value=0) med_scikit = median(img_uint8, disk(1)) thresh = threshold_li(med_scikit) binary = med_scikit > thresh filled = ndimage.binary_fill_holes(binary) filled_blurred = gaussian(filled, 1) filled_int = (filled_blurred * 255).astype('uint8') # # edge_sobel = sobel(img_uint8) # # enhanced = 50*edge_sobel/edge_sobel.max() + img_uint8 # # enhanced.astype('uint8') # # med_scikit = median(img_uint8, disk(5)) thresh = threshold_li(filled_int) binary = filled_int > thresh filled = ndimage.binary_fill_holes(binary) filled_int = binary_opening(filled, disk(5)) filled_int = ndimage.binary_fill_holes(filled_int) # filled_blurred = gaussian(openeed, 3) # thresh = threshold_li(filled_int) # binary = filled_int > thresh #binary = binary_erosion(filled_int, disk(5)) distance = ndimage.distance_transform_edt(filled_int) binary1 = distance > first_threshold distance1 = ndimage.distance_transform_edt(binary1) binary2 = distance1 > second_threshold labeled_spots, num_features = label(binary2) spot_labels = np.unique(labeled_spots) spot_locations = ndimage.measurements.center_of_mass( binary2, labeled_spots, spot_labels[spot_labels > 0]) mask = np.zeros(distance.shape, dtype=bool) if spot_locations: mask[np.ceil(np.array(spot_locations)[:, 0]).astype(int), np.ceil(np.array(spot_locations)[:, 1]).astype(int)] = True markers, _ = ndimage.label(mask) labels = watershed(-distance, markers, mask=binary, compactness=0.5, watershed_line=True) boundary = find_boundaries(labels, connectivity=1, mode='thick', background=0) boundary_img = (255 * boundary[3:boundary.shape[0] - 3, 3:boundary.shape[1] - 3]).astype('uint8') resized_bound = cv2.resize(boundary_img, (input_img.shape[1], input_img.shape[0])) filled1 = ndimage.binary_fill_holes(resized_bound) mask = (255 * filled1).astype('uint8') - resized_bound boundary = resized_bound.astype('uint8') return boundary, mask
def test_acc(image_name,nnet_model=nnet): angle_indicator = int(image_name.split('_')[1]) image = misc.imread('test_sample/' + image_name + '.jpg',flatten = True).astype(float) image_rgb = misc.imread('test_sample/' + image_name + '.jpg') image_float = image_rgb.astype(float) image_mask = misc.imread('train_masks/' + image_name + '_mask.gif',flatten = True) image_mask = image_mask/255 #io.imshow(image_mask) image_index = np.where(image >= 0) sobel = filters.sobel(image) # working #io.imshow(sobel) sobel_blurred = filters.gaussian(sobel,sigma=1) # Working #io.imshow(sobel_blurred) canny_filter_image = canny(image/255.) #io.imshow(canny_filter_image) # threshold_niblack_11 = filters.threshold_niblack(sobel_blurred,201) #io.imshow(threshold_niblack) threshold_li = filters.threshold_li(image) mask_li = image > threshold_li #io.imshow(mask) sobel_h = filters.sobel_h(image) sobel_v = filters.sobel_v(image) laplace = filters.laplace(image) threshold_local_51 = filters.threshold_local(image,51) mask_local_51 = image > threshold_local_51 #io.imshow(mask) df = pd.DataFrame() df['l1_dist_y'] = abs(image_index[0] - 639.5)/639.5 df['l1_dist_x'] = abs(image_index[1] - 958.5)/958.5 df['l2_dist'] = np.sqrt((df.l1_dist_y)**2 + (df.l1_dist_x)**2)/np.sqrt(2) df['grey_values'] = image.reshape((1,1918*1280))[0]/255. df['red_values'] = image_rgb.reshape((3,1918*1280))[0]/255. df['blue_values'] = image_rgb.reshape((3,1918*1280))[1]/255. df['green_values'] = image_rgb.reshape((3,1918*1280))[2]/255. df['red_float'] = image_float.reshape((3,1918*1280))[0]/255. df['blue_float'] = image_float.reshape((3,1918*1280))[1]/255. df['green_float'] = image_float.reshape((3,1918*1280))[2]/255. df['sobel_blurred'] = sobel_blurred.reshape((1,1918*1280))[0]/255. df['canny_filter_image'] = canny_filter_image.reshape((1,1918*1280))[0].astype(int) df['sobel_h'] = sobel_h.reshape((1,1918*1280))[0]/255. df['sobel_v'] = sobel_v.reshape((1,1918*1280))[0]/255. df['laplace'] = laplace.reshape((1,1918*1280))[0]/511. df['threshold_local_51'] = mask_local_51.reshape((1,1918*1280))[0].astype(int) # df['threshold_niblack_11'] = threshold_niblack_11.reshape((1,1918*1280))[0]#/255. df['threshold_li'] = mask_li.reshape((1,1918*1280))[0].astype(int) for i in range(1,17): if i == angle_indicator: df['angle_indicator_' + str(i)] = 1 else: df['angle_indicator_' + str(i)] = -1 df['mask'] = image_mask.reshape((1,1918*1280))[0] df['mask'] = df['mask'] df['pred_mask'] = nnet_model.predict(X = df[[col for col in img_df.columns if col != 'mask']]) z = skm.confusion_matrix(df['mask'],df['pred_mask']) accuracy = 100*(z[0][0] + z[1][1])/float(sum(sum(z))) print 'Accuracy:', accuracy precision = 100*(z[1][1])/float(z[0][1] + z[1][1]) print 'Precision:', precision recall = 100*(z[1][1])/float(z[1][0]+z[1][1]) print 'Recall:', recall act_mask = np.array(df['mask']) act_mask = act_mask.reshape((1280,1918)) pred_mask = np.array(df['pred_mask']).astype(float) pred_mask = pred_mask.reshape((1280,1918)) io.imshow_collection([img_rgb,act_mask,pred_mask]) return df
# image_show(text_segmented) # pylab.show() # # text_segmented = text > 10 # image_show(text_segmented) # pylab.show() # # text_segmented = text > 20 # image_show(text_segmented) # pylab.show() # text_local = filters.threshold_local(text, block_size=51, offset=10) # image_show(text > text_local) # pylab.show() text_otsu = filters.threshold_otsu(text) image_show(text <= text_otsu) pylab.show() text_li = filters.threshold_li(text) image_show(text <= text_li) pylab.show() text_yen = filters.threshold_yen(text) image_show(text > text_yen) pylab.show() text_iso = filters.threshold_isodata(text) image_show(text > text_iso) pylab.show()
def _extract_roi(image, axis=-1): max_frame = np.max(image, axis=axis) initial_mask = max_frame > threshold_li(max_frame) regions = ndi.label(initial_mask)[0] region_sizes = np.bincount(np.ravel(regions)) return regions == (np.argmax(region_sizes[1:]) + 1)
def threshold_fiber(img_fish, t_fiber=None, z_first=False, verbose=False): """Segment the muscle fiber from a 3D FISH microscopy image. Return a mask containing the extent of the muscle fiber from a 3D FISH image. If `t_fiber` is provided, use that for thresholding. Otherwise, automatically determine the threshold value using Li's method. Parameters: img_fish: np.array, 3D A 3D numpy array containing signal from the FISH channel, organized as [x, y, z] (unless `z_first` is set to True). Optional: t_fiber: float or str (default None) Threshold to use for binarization of the FISH image, from 0 to 1. If not set, automatically determine this threshold using Li's method. Alternatively, if set to 'last', the final z-slice of the image will be thresholded, and this mask will be used for the entire z-stack. z_first: bool (default False) If True, treat `img_fish` as image with dimensions [z, x, y]. verbose: bool (default False) If True, print progress to stdout. """ if verbose: print('Segmenting fiber...') # image preprocessing if z_first: # switch to (x, y, z) img_fish = img_fish.transpose(1, 2, 0) img_avg = su.normalize_image(img_fish) img_blur = filters.gaussian(img_avg, (10, 10, 1)) # get threshold using method determined from value of t_fiber if t_fiber is None: thresh = filters.threshold_li(img_blur) elif type(t_fiber) == float: thresh = t_fiber elif t_fiber == 'last': thresh = filters.threshold_li(img_blur[:, :, -1]) else: raise TypeError('`t_fiber` argument not recognized. \ Must be either float or "last".') if verbose: print('Fiber threshold: ' + str(thresh)) # binarize bin_fiber = np.where(img_blur > thresh, 1, 0) if t_fiber == 'last': # only use the last frame to define the fiber volume # this is a last resort option to deal with glare in the RNA channel # warning: densities will be underestimated for z in range(bin_fiber.shape[2]): bin_fiber[:, :, z] = bin_fiber[:, :, -1] if verbose: print('OVERRIDE: using final frame mask for entire z-stack.') # keep only largest object in the image fiber_labeled, n_labels = morphology.label(bin_fiber, return_num=True) label_sizes = { i: np.count_nonzero(np.where(fiber_labeled == i, 1, 0)) for i in range(1, n_labels + 1) } fiber_idx = max(label_sizes, key=label_sizes.get) mask = np.where(fiber_labeled == fiber_idx, 1, 0) if z_first: # switch back to (z, x, y) mask = mask.transpose(2, 0, 1) return mask
def detector_callback(self, preprocessed_pc): """ Main callback method of the detector that executes the procedure of automatic thresholding, clustering, volume correction and some calculations to extract the volume, boundaries and centers of the gaps. Parameters ---------- preprocessed_pc : sensor_msgs.pointcloud2 Preprocessed point cloud generated by the preprocessing node. Notes ----- After each procedure step a point cloud is published over the publishers defined in __init__ as well as some visualization Markers for RVIZ. """ points = helpers.PC2_to_numpy_array(preprocessed_pc) self.frame_id = preprocessed_pc.header.frame_id # ----- AUTOMATIC THRESHOLDING TO FIND GAPS ----- depth_axis_pts = points[:, self.depth_axis] if(self.automatic_thresholding == 0): try: threshold = threshold_minimum(depth_axis_pts) except RuntimeError: rospy.logwarn("threshold_minimum was unable to find two " + "maxima in histogram!") return elif(self.automatic_thresholding == 1): threshold = threshold_li(depth_axis_pts) elif(self.automatic_thresholding == 2): threshold = threshold_yen(depth_axis_pts) elif(self.automatic_thresholding == 3): threshold = threshold_otsu(depth_axis_pts, self.otsu_bins) device_surface_pts = points[depth_axis_pts <= threshold] self.surface_height = np.median(device_surface_pts[:, self.depth_axis]) points = points[depth_axis_pts > threshold] # ----- PUBLISHING OF THE THRESHOLDED CLOUD ----- thresholded_cloud = helpers.numpy_array_to_PC2(points, self.frame_id) self.thresholded_cloud_pub.publish(thresholded_cloud) # ----- CLUSTERING THE GAPS ----- clustering_switch = { 0: self.kmeans, 1: self.birch, 2: self.dbscan, 3: self.hdbscan } cluster_algorithm = clustering_switch[self.clustering] labels = cluster_algorithm(points) labels_T = np.array([labels]).T clustered_points = np.append(points, labels_T, axis=1) color_list = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 1.0, 1.0], [0.5, 0.5, 0.5], [1.0, 0.5, 0.5], [0.5, 1.0, 0.5], [0.5, 0.5, 1.0]] clusters = [] colored_clusters = [] # check for each cluster if there are enough points in the cluster for i in set(labels): cluster = clustered_points[clustered_points[:, 3] == float(i)] cluster = cluster[:, [0, 1, 2]] # create seperate list of points to visualize clusters for cluster_point in cluster: try: color = np.array(color_list[i]) except IndexError: color = np.array([0.0, 0.0, 0.0]) point_with_color = np.append(cluster_point, color) colored_clusters.append(point_with_color) # To construct a convex hull a minimum of 4 points is needed num_of_points, dim = cluster.shape if(num_of_points >= 4): clusters.append(cluster) # ----- PUBLISHING OF CLUSTERS----- clustered_cloud = helpers.XYZRGB_to_PC2( colored_clusters, self.frame_id) self.clustered_cloud_pub.publish(clustered_cloud) # ----- VOLUME CORRECTION ----- volume_corrected_clusters = [] num_vol_corrected_pts = 0 volume_corrected_pts_tuple = () for cluster in clusters: hull = ConvexHull(cluster, qhull_options="QJ") # Map from vertex to point in cluster vertices = [] for vertex in hull.vertices: x, y, z = cluster[vertex] vertices.append([x, y, z]) gap = cluster.tolist() for vertex in vertices: # For each vertex, add a new point to the gap with the height # of the surface and the other axes corresponding to the vertex if(self.depth_axis == 0): volume_point = [self.surface_height, vertex[1], vertex[2]] elif(self.depth_axis == 1): volume_point = [vertex[0], self.surface_height, vertex[2]] elif(self.depth_axis == 2): volume_point = [vertex[0], vertex[1], self.surface_height] gap.append(volume_point) num_vol_corrected_pts = num_vol_corrected_pts + 1 volume_corrected_clusters.append(np.array(gap)) volume_corrected_pts_tuple = volume_corrected_pts_tuple + \ (num_vol_corrected_pts,) num_vol_corrected_pts = 0 # ---- CALCULATING CONVEX HULLS OF GAPS AND THEIR CENTER ----- convex_hulls_and_info = helpers.calculate_convex_hulls_and_centers( volume_corrected_clusters) # ---- FILTER BASED ON VOLUME ----- self.gaps = [] for gap_info in convex_hulls_and_info: gap_volume = gap_info[3] # convert cm^3 to m^3 gap_volume = gap_volume * 1000000.0 if(self.min_gap_volume <= gap_volume <= self.max_gap_volume): self.gaps.append(gap_info) # ----- PUBLISHING THE MARKERS TO RVIZ ----- if not len(self.gaps) == 0: gap_info = zip(*self.gaps) centers, vertices, simplices, volumes, num_of_points = gap_info convex_hull_marker = visualization.draw_convex_hull( simplices, self.frame_id) self.convex_hull_marker_pub.publish(convex_hull_marker) centers_marker = visualization.draw_centers(centers, self.frame_id) self.centers_marker_pub.publish(centers_marker) volume_text_marker = visualization.draw_volume_text( volumes, centers, self.frame_id) self.volume_text_marker_pub.publish(volume_text_marker) # ----- EVALUATION ----- if(self.create_evaluation): num_of_points = np.subtract(num_of_points, num_vol_corrected_pts) evaluation_info = zip(num_of_points, volumes, centers) helpers.evaluate_detector(evaluation_info) self.create_evaluation = False
def li_func(img_slice): return filters.threshold_li(img_slice)
matplotlib.rcParams['font.size'] = 9 img_orig = '/home/andrea/Desktop/20160713_NCP_GO_Talos_121.jpg' img_lowpass = '******' out_dir = '/home/andrea/Desktop/test' if not os.path.isdir(out_dir): os.makedirs(out_dir) os.chdir(out_dir) # print('Processing original') # image_orig = imread(img_orig, as_grey=True, flatten = True) # thresh_orig = threshold_isodata(image_orig) # binary_orig = image_orig > thresh_orig print('Processing lowpass isodata') image = imread(img_lowpass, as_grey=True, flatten=True) thresh_isodata = threshold_isodata(image) thresh_otsu = threshold_otsu(image) thresh_li = threshold_li(image) thresh_yen = threshold_yen(image) thresh_adaptive = threshold_adaptive(image, 3) binary_isodata = image > thresh_isodata binary_otsu = image > thresh_otsu binary_li = image > thresh_li binary_adaptive = image > thresh_adaptive binary_yen = image > thresh_yen # edges = canny(image_orig/255.) # fill_image = ndi.binary_fill_holes(edges) imshow(binary_isodata) imshow(binary_otsu) imshow(binary_yen) imshow(binary_li) imshow(binary_adaptive)
dataset = 1 t0 = time() data0 = np.load('data/20190401_GASP_PHANTOM/set%d_tr6_te3.npy' % dataset) data1 = np.load('data/20190401_GASP_PHANTOM/set%d_tr12_te6.npy' % dataset) data2 = np.load('data/20190401_GASP_PHANTOM/set%d_tr24_te12.npy' % dataset) print(time() - t0) print(data0.shape) # [Height, Width, Coil, Avg, PCs] data = np.concatenate( (data0[..., None], data1[..., None], data2[..., None]), axis=-1) data = np.mean(data, axis=3) # [Height, Width, Coil, PCs, TRs] # Create a mask of the phanton band_free = gs_recon(data[:, :, 0, ::4, 0], pc_axis=-1) thresh = threshold_li(np.abs(band_free)) mask = np.abs(band_free) > thresh # Apply mask to data mask0 = np.tile(mask, (data.shape[2:] + ( 1, 1, ))).transpose((3, 4, 0, 1, 2)) data = data * mask0 print(data.shape[:-2]) data = np.reshape(data, data.shape[:-2] + (-1, )) # [Height, Width, Coil, PCs x TRs] data = np.moveaxis(data, 2, 0) # [Coil, Height, Width, PCs x TRs] data = data.transpose((0, 3, 2, 1)) # [Coil, PCs x TRs, Width, Height]
ifft = lambda x0: np.fft.fftshift(np.fft.ifft2( np.fft.ifftshift(x0, axes=(0, 1)), axes=(0, 1)), axes=(0, 1)) # Put into imspace ims = ifft(data) plt_opts = { 'vmin': 0, 'vmax': 2.5, } # Look at only pixels that have strong enough signal sos = np.sqrt(np.sum(np.abs(ims)**2, axis=-2)) # across time thresh = threshold_li(sos) mask = sos > thresh / 2 # Run on each coil # T1s = np.zeros(data.shape[:2]) T1s = [] A, B = 1, -2 for cc in range(ims.shape[-1]): t0 = time() ims0 = ims[..., cc] T1, A, B, niter, err = t1iter(ims0, t, mask=mask[..., cc], T10=1, A0=A,
def get_threshold(self, image): return Threshold.color_in_range(image, threshold_li(image))
def optimize(img): img = gaussian(img) thresh = threshold_li(img) img = img > thresh return img
def binaryMask(image): threshold = skf.threshold_li(image) return image > threshold
def binarize(img): thresh = threshold_li(img) img = img > thresh return img
def bacteria_watershed( segs, maxsize=1000, #uint16((5*2)/(pix2mic**2)) ### max area minsize=200, #uint16((0.5*0.1)/(pix2mic**2)) ### min area absolwidth=1, thr_strength=2., phase_contrast=None, fix_thr=None): min_av_width = 1 segs2 = {} # here images after watershed thresh_array = [] # for ch_n, img0 in segs.items(): # thresh_array.append(skfilt.threshold_minimum(img0.flatten())) # med, mad = get_med_and_mad(thresh_array) # threshold_int = med+3*mad for ch_n, img0 in segs.items(): if fix_thr is None: thresh = skfilt.threshold_li( np.concatenate([s.flatten() for s in segs.values()])) else: thresh_thr = fix_thr bw0 = img0 > thresh bw1 = ndi.morphology.binary_erosion(bw0) bw2 = ndi.morphology.binary_dilation(bw0) bw3 = bw2 ^ bw1 # perform distance transform on filtered image dist = ndi.distance_transform_edt(bw2) # create markers for watershed markers = np.zeros(img0.shape, dtype=bool) markers[dist >= absolwidth] = True markers = ndi.label(markers)[0] #markers[markers>=1]= markers[markers>=1]+1 #markers[bw3] = 0 # Perform watershed labeled_bacteria = skseg.watershed(-dist, markers, mask=bw2) #labeled_bacteria = ndi.binary_fill_holes(segmentation)# != 1) ### now filter bacteria for size and width dist = ndi.distance_transform_edt(labeled_bacteria > 0) newbac = np.zeros(labeled_bacteria.shape, dtype=labeled_bacteria.dtype) stats = dict( num_rejected_av_width=0, num_rejected_area=0, ) label = 0 for region in regionprops(labeled_bacteria): masked_bac = labeled_bacteria == region.label skel = skeletonize(masked_bac) av_width_skel = np.mean(dist[skel]) if av_width_skel < min_av_width: stats["num_rejected_av_width"] += 1 continue if maxsize > region.area > minsize: label += 1 newbac[labeled_bacteria == region.label] = label if region.area > maxsize: stats["num_rejected_area"] += 1 # if stats["num_rejected_area"]>0: segs2[ch_n] = newbac return segs2, thresh_array
def blur_threshold_mask(bmap, threshold=None): if threshold is None: threshold = threshold_li(bmap) elif threshold < 0 or threshold > 1: raise ValueError('Threshold must be a real number between 0 and 1.') return bmap < threshold
greenimgs = sorted(glob.glob(filepath + "*Green -*")) blueimgs = sorted(glob.glob(filepath + "*Blue -*")) uvimgs = sorted(glob.glob(filepath + "*UV -*")) for i in np.arange(len(redimgs)): t1 = time.time() cellImagesRAW = [] vacuoleArr = [] print("Markers from", uvimgs[i], "Cells from", redimgs[i]) r = io.imread(redimgs[i]) g = io.imread(greenimgs[i]) b = io.imread(blueimgs[i]) u = io.imread(uvimgs[i]) thresh = filters.threshold_li(u) mask = u <= thresh labeled = measure.label(mask, background=1) markers = rank.median(labeled, disk(25)) p0, p1 = np.percentile( r, (10, 70) ) # These parameters can be changed to affect the sensitivity of measurement rRescaled = exposure.rescale_intensity(r, in_range=(p0, p1)) thresh = filters.threshold_li(rRescaled) mask = rRescaled <= thresh gradient = rank.gradient(mask == 0, disk(2)) labeled = segmentation.watershed(gradient, markers) labeled = segmentation.clear_border(labeled) # Get rid of border cells
def apply_li_threshold(image): return image > f.threshold_li(image)
file_suffix = '.npy' file_reading = os.path.join( sample_saving_path, file_name + image_name + channel_color + file_suffix) mm = np.load(file_reading) mmm = np.copy(mm) total_pixel_y, total_pixel_x = mmm.shape ### reading mmm_array --- ### filtering_noise_particle --- #from skimage import filters #from skimage.morphology import disk #mmm = filters.median(mmm) ### filtering_noise_particle +++ ### from skimage.filters import threshold_otsu, threshold_yen, threshold_li, threshold_isodata aaa = threshold_li(mmm) bool_mmm = mmm > aaa ### boundary_masking +++ bool_mmm[:, :2] = False bool_mmm[:, -2:] = False bool_mmm[:2, :] = False bool_mmm[-2:, :] = False ### boundary_masking --- from skimage.morphology import remove_small_objects bbb = remove_small_objects(bool_mmm, min_size=2) from skimage.morphology import skeletonize new_mmm = skeletonize(bbb) new_mmm = np.int64(new_mmm) #converting bool into number(1, 0) ### file_suffix = '.png' saving_data_file = file_name + section_name_in
def separate_watershed( vdf_temp, min_distance=1, min_size=1, max_size=np.inf, max_number_of_grains=np.inf, marker_radius=1, threshold=False, exclude_border=False, plot_on=False, ): """Separate segments from one VDF image using edge-detection by the sobel transform and the watershed segmentation implemented in scikit-image. See [1,2] for examples from scikit-image. Parameters ---------- vdf_temp : np.array One VDF image. min_distance: int Minimum distance (in pixels) between markers for them to be considered separate markers for the watershed segmentation. min_size : float Grains with size (i.e. total number of pixels) below min_size are discarded. max_size : float Grains with size (i.e. total number of pixels) above max_size are discarded. max_number_of_grains : int Maximum number of grains included in the returned separated grains. If it is exceeded, those with highest peak intensities will be returned. marker_radius : float If 1 or larger, each marker for watershed is expanded to a disk of radius marker_radius. marker_radius should not exceed 2*min_distance. threshold : bool If True, a mask is calculated by thresholding the VDF image by the Li threshold method in scikit-image. If False (default), the mask is the boolean VDF image. exclude_border : int or True, optional If non-zero integer, peaks within a distance of exclude_border from the boarder will be discarded. If True, peaks at or closer than min_distance of the boarder, will be discarded. plot_on : bool If True, the VDF, the mask, the distance transform and the separated grains will be plotted in one figure window. Returns ------- sep : np.array Array containing segments from VDF images (i.e. separated grains). Shape: (image size x, image size y, number of grains) References ---------- [1] http://scikit-image.org/docs/dev/auto_examples/segmentation/ plot_watershed.html [2] http://scikit-image.org/docs/dev/auto_examples/xx_applications/ plot_coins_segmentation.html#sphx-glr-auto-examples-xx- applications-plot-coins-segmentation-py """ # Create a mask from the input VDF image. if threshold: th = threshold_li(vdf_temp) mask = np.zeros_like(vdf_temp) mask[vdf_temp > th] = True else: mask = vdf_temp.astype("bool") # Calculate the Eucledian distance from each point in the mask to the # nearest background point of value 0. distance = distance_transform_edt(mask) # If exclude_boarder is given, the edge of the distance is removed # by erosion. The distance image is used to find markers, and so the # erosion is done to avoid that markers are located at the edge # of the mask. if exclude_border > 0: distance_mask = binary_erosion(distance, structure=disk(exclude_border)) distance = distance * distance_mask.astype("bool") # Find the coordinates of the local maxima of the distance transform. local_maxi = peak_local_max( distance, indices=False, min_distance=1, num_peaks=max_number_of_grains, exclude_border=exclude_border, threshold_rel=None, ) maxi_coord1 = np.where(local_maxi) # Discard maxima that are found at pixels that are connected to a # smaller number of pixels than min_size. Used as markers, these would lead # to segments smaller than min_size and should therefore not be # considered when deciding which maxima to use as markers. if min_size > 1: labels_check = label(mask)[0] delete_indices = [] for i in np.arange(np.shape(maxi_coord1)[1]): index = np.transpose(maxi_coord1)[i] label_value = labels_check[index[0], index[1]] if len(labels_check[labels_check == label_value]) < min_size: delete_indices.append(i) local_maxi[index[0], index[1]] = False maxi_coord1 = np.delete(maxi_coord1, delete_indices, axis=1) # Cluster the maxima by DBSCAN based on min_distance. For each # cluster, only the maximum closest to the average maxima position is # used as a marker. if min_distance > 1 and np.shape(maxi_coord1)[1] > 1: clusters = DBSCAN( eps=min_distance, metric="euclidean", min_samples=1, ).fit(np.transpose(maxi_coord1)) local_maxi = np.zeros_like(local_maxi) for n in np.arange(clusters.labels_.max() + 1): maxi_coord1_n = np.transpose(maxi_coord1)[clusters.labels_ == n] com = np.average(maxi_coord1_n, axis=0).astype("int") index = distance_matrix([com], maxi_coord1_n).argmin() index = maxi_coord1_n[index] local_maxi[index[0], index[1]] = True # Use the resulting maxima as markers. Each marker should have a # unique label value. For each maximum, generate markers with the same # label value in a radius given by marker_radius centered at the # maximum position. This is done to make the segmentation more robust # to local changes in pixel values around the marker. markers = label(local_maxi)[0] if marker_radius >= 1: disk_mask = disk(marker_radius) for mm in np.arange(1, np.max(markers) + 1): im = np.zeros_like(markers) im[np.where(markers == mm)] = markers[np.where(markers == mm)] markers_temp = convolve2d(im, disk_mask, boundary="fill", mode="same", fillvalue=0) markers[np.where(markers_temp)] = mm markers = markers * mask # Find the edges of the VDF image using the Sobel transform. elevation = sobel(vdf_temp) # 'Flood' the elevation (i.e. edge) image from basins at the marker # positions. Find the locations where different basins meet, i.e. # the watershed lines (segment boundaries). Only search for segments # (labels) in the area defined by mask. labels = watershed(elevation, markers=markers, mask=mask) sep = np.zeros( (np.shape(vdf_temp)[0], np.shape(vdf_temp)[1], (np.max(labels))), dtype="int32") n, i = 1, 0 while (np.max(labels)) > n - 1: sep_temp = labels * (labels == n) / n sep_temp = np.nan_to_num(sep_temp) # Discard a segment if it is too small or too large, or else add # it to the list of separated segments. if (np.sum(sep_temp, axis=(0, 1)) < min_size) or np.sum( sep_temp, axis=(0, 1)) > max_size: sep = np.delete(sep, ((n - i) - 1), axis=2) i = i + 1 else: sep[:, :, (n - i) - 1] = sep_temp n = n + 1 # Put the intensity from the input VDF image into each segmented area. vdf_sep = np.broadcast_to(vdf_temp.T, np.shape(sep.T)) * (sep.T == 1) if plot_on: # pragma: no cover # If segments have been discarded, make new labels that do not # include the discarded segments. if np.max(labels) != (np.shape(sep)[2]) and (np.shape(sep)[2] != 0): labels = sep[:, :, 0] for i in range(1, np.shape(sep)[2]): labels = labels + sep[..., i] * (i + 1) # If no separated particles were found, set all elements in # labels to 0. elif np.shape(sep)[2] == 0: labels = np.zeros(np.shape(labels)) seps_img_sum = np.zeros_like(vdf_temp).astype("float64") for lbl, vdf in zip(np.arange(1, np.max(labels) + 1), vdf_sep): mask_l = np.zeros_like(labels).astype("bool") _idx = np.where(labels == lbl) mask_l[_idx] = 1 seps_img_sum += vdf_temp * mask_l / np.max(vdf_temp[_idx]) seps_img_sum[_idx] += lbl maxi_coord = np.where(local_maxi) fig, axes = plt.subplots(2, 3, sharex=True, sharey=True) ax = axes.ravel() ax[0].imshow(vdf_temp, cmap=plt.cm.magma_r) ax[0].axis("off") ax[0].set_title("VDF") ax[1].imshow(mask, cmap=plt.cm.gray_r) ax[1].axis("off") ax[1].set_title("Mask") ax[2].imshow(distance, cmap=plt.cm.gray_r) ax[2].axis("off") ax[2].set_title("Distance and markers") ax[2].imshow(masked_where(markers == 0, markers), cmap=plt.cm.gist_rainbow) ax[2].plot(maxi_coord1[1], maxi_coord1[0], "k+") ax[2].plot(maxi_coord[1], maxi_coord[0], "gx") ax[3].imshow(elevation, cmap=plt.cm.magma_r) ax[3].axis("off") ax[3].set_title("Elevation") ax[4].imshow(labels, cmap=plt.cm.gnuplot2_r) ax[4].axis("off") ax[4].set_title("Labels") ax[5].imshow(seps_img_sum, cmap=plt.cm.magma_r) ax[5].axis("off") ax[5].set_title("Segments") return vdf_sep
segments.append(collect_gs[y_low:y_high, :]) # contains white background, and have grayscale coords.append([y_low, y_high]) # need to handle the end, i.e. after the last cut print adjusted_cuts """for seg in segments: # want to collect the histograms of each segment # Image.fromarray(seg).show() hist_seg = cv2.calcHist([seg], [0], None, [256], [0, 256]) # segment is gs on white background plt.plot(hist_seg)""" # use some existing global thresholding method for each of the segments (different T for each segment) # inputs should be grayscale (single channel) black_bg = np.zeros((img.shape[0], img.shape[1]), dtype='uint8') y_cur_min = 0 for seg in zip(segments, coords): # is in order of increasing y-value threshglobal = filters.threshold_li(seg[0]) # Should be an integer? seg[0] refers to the first element, i.e. the segment and not the adjusted cut # compute adjustment to the threshold found above based on the ratio of foreground pixels to total pixels in segment # background_pixels background_pixels = np.where(seg[0] == 255) a = len(background_pixels[0]) seg_img = seg[0] b = (seg_img.shape[0])*(seg_img.shape[1]) adjustment_ratio = 1.0*a/b adjustment_value = 35*pow(adjustment_ratio, (1.0/2.0)) # gives a^b print "Adjustment: " + str(adjustment_value) threshglobal = threshglobal - adjustment_value # the larger the ratio, the larger the adjustment effect
def threshcomp(Data): ############################################################################### # Determining Binary Values ############################################################################### binary_local = Data > threshold_local(Data, 3) binary_adaptive = Data > threshold_adaptive(Data, 3) binary_otsu = Data > threshold_otsu(Data) binary_yen = Data > threshold_yen(Data) binary_isodata = Data > threshold_isodata(Data) binary_li = Data > threshold_li(Data) binary_min = Data > threshold_minimum(Data) binary_mean = Data > threshold_mean(Data) binary_triangle = Data > threshold_triangle(Data) binary_niblack = Data > threshold_niblack(Data) binary_sauvola = Data > threshold_sauvola(Data) ############################################################################### # Plots ############################################################################### fig, axes = plt.subplots(nrows=5, ncols=2, figsize=(12, 8)) ax = axes.ravel() ax[0] = plt.subplot(6, 2, 1) ax[1] = plt.subplot(6, 2, 2) ax[2] = plt.subplot(6, 2, 3) ax[3] = plt.subplot(6, 2, 4) ax[4] = plt.subplot(6, 2, 5) ax[5] = plt.subplot(6, 2, 6) ax[6] = plt.subplot(6, 2, 7) ax[7] = plt.subplot(6, 2, 8) ax[8] = plt.subplot(6, 2, 9) ax[9] = plt.subplot(6, 2, 10) ax[0].imshow(Data, cmap=plt.cm.gray, aspect='auto') ax[0].set_title("Original") ax[0].set_ylim([200, 0]) ax[0].set_xlim([100, 400]) ax[0].axis('off') ax[1].imshow(binary_local, cmap=plt.cm.gray, aspect='auto') ax[1].set_title("Local") ax[1].set_ylim([200, 0]) ax[1].set_xlim([100, 400]) ax[1].axis('off') ax[2].imshow(binary_otsu, cmap=plt.cm.gray, aspect='auto') ax[2].set_title("Otsu") ax[2].set_ylim([200, 0]) ax[2].set_xlim([100, 400]) ax[2].axis('off') ax[3].imshow(binary_yen, cmap=plt.cm.gray, aspect='auto') ax[3].set_title("Yen") ax[3].set_ylim([200, 0]) ax[3].set_xlim([100, 400]) ax[3].axis('off') ax[4].imshow(binary_isodata, cmap=plt.cm.gray, aspect='auto') ax[4].set_title("Isodata") ax[4].set_ylim([200, 0]) ax[4].set_xlim([100, 400]) ax[4].axis('off') ax[5].imshow(binary_li, cmap=plt.cm.gray, aspect='auto') ax[5].set_title("Li") ax[5].set_ylim([200, 0]) ax[5].set_xlim([100, 400]) ax[5].axis('off') ax[6].imshow(binary_min, cmap=plt.cm.gray, aspect='auto') ax[6].set_title("Minimum") ax[6].set_ylim([200, 0]) ax[6].set_xlim([100, 400]) ax[6].axis('off') ax[7].imshow(binary_mean, cmap=plt.cm.gray, aspect='auto') ax[7].set_title("Mean") ax[7].set_ylim([200, 0]) ax[7].set_xlim([100, 400]) ax[7].axis('off') ax[8].imshow(binary_triangle, cmap=plt.cm.gray, aspect='auto') ax[8].set_title("Triangle") ax[8].set_ylim([200, 0]) ax[8].set_xlim([100, 400]) ax[8].axis('off') ax[9].imshow(binary_niblack, cmap=plt.cm.gray, aspect='auto') ax[9].set_title("Niblack") ax[9].set_ylim([200, 0]) ax[9].set_xlim([100, 400]) ax[9].axis('off') plt.savefig('thresh_comp.png') plt.show()
def test_acc(image_name): car_id = image_name.split('_')[0] angle_indicator = image_name.split('_')[1] nnet_model = joblib.load('nnet_20_10_5_2_adam_logistic_' + angle_indicator + '.pkl') image = misc.imread('test_sample/' + image_name + '.jpg', flatten=True).astype(float) image_rgb = misc.imread('test_sample/' + image_name + '.jpg') image_float = image_rgb.astype(float) image_mask_all_angles = misc.imread('train_all_masks/' + car_id + '.jpg', flatten=True) / 255. image_mask = misc.imread('train_masks/' + image_name + '_mask.gif', flatten=True) / 255 #io.imshow(image_mask) image_index = np.where(image >= 0) sobel = filters.sobel(image) # working #io.imshow(sobel) sobel_blurred = filters.gaussian(sobel, sigma=1) # Working #io.imshow(sobel_blurred) canny_filter_image = canny(image / 255.) #io.imshow(canny_filter_image) # threshold_niblack_11 = filters.threshold_niblack(sobel_blurred,201) #io.imshow(threshold_niblack) threshold_li = filters.threshold_li(image) mask_li = image > threshold_li #io.imshow(mask) sobel_h = filters.sobel_h(image) sobel_v = filters.sobel_v(image) laplace = filters.laplace(image) threshold_local_51 = filters.threshold_local(image, 51) mask_local_51 = image > threshold_local_51 #io.imshow(mask) df = pd.DataFrame() # df['y'] = (image_index[0] - 639.5)/639.5 # df['x'] = (image_index[1] - 958.5)/958.5 df['l1_dist_y'] = abs((image_index[0] - 639.5) / 639.5) df['l1_dist_x'] = abs((image_index[1] - 958.5) / 958.5) df['l2_dist'] = np.sqrt((df['l1_dist_x'])**2 + (df['l1_dist_y'])**2) / np.sqrt(2) df['grey_values'] = image.reshape((1, 1918 * 1280))[0] / 255. df['red_values'] = image_rgb.reshape((3, 1918 * 1280))[0] / 255. df['blue_values'] = image_rgb.reshape((3, 1918 * 1280))[1] / 255. df['green_values'] = image_rgb.reshape((3, 1918 * 1280))[2] / 255. df['red_float'] = image_float.reshape((3, 1918 * 1280))[0] / 255. df['blue_float'] = image_float.reshape((3, 1918 * 1280))[1] / 255. df['green_float'] = image_float.reshape((3, 1918 * 1280))[2] / 255. df['sobel_blurred'] = sobel_blurred.reshape((1, 1918 * 1280))[0] / 255. df['canny_filter_image'] = canny_filter_image.reshape( (1, 1918 * 1280))[0].astype(int) df['sobel_h'] = sobel_h.reshape((1, 1918 * 1280))[0] / 255. df['sobel_v'] = sobel_v.reshape((1, 1918 * 1280))[0] / 255. df['laplace'] = laplace.reshape((1, 1918 * 1280))[0] / 511. df['threshold_local_51'] = mask_local_51.reshape( (1, 1918 * 1280))[0].astype(int) # df['threshold_niblack_11'] = threshold_niblack_11.reshape((1,1918*1280))[0]#/255. df['threshold_li'] = mask_li.reshape((1, 1918 * 1280))[0].astype(int) df['mask'] = image_mask.reshape((1, 1918 * 1280))[0] df['mask'] = df['mask'].astype('category') df['pred_mask'] = nnet_model.predict( X=df[[col for col in df.columns if col != 'mask']]) z = skm.confusion_matrix(df['mask'], df['pred_mask']) dice_coeff = 2 * (z[1][1]) / float(2 * z[1][1] + z[0][1] + z[1][0]) print 'Dice Coefficient:', dice_coeff accuracy = 100 * (z[0][0] + z[1][1]) / float(sum(sum(z))) print 'Accuracy:', accuracy precision = 100 * (z[1][1]) / float(z[0][1] + z[1][1]) print 'Precision:', precision recall = 100 * (z[1][1]) / float(z[1][0] + z[1][1]) print 'Recall:', recall act_mask = np.array(df['mask']) act_mask = act_mask.reshape((1280, 1918)) pred_mask = np.array(df['pred_mask']).astype(float) pred_mask = pred_mask.reshape((1280, 1918)) return df, pred_mask, image, act_mask
kc = whiten(kc) outside = np.argwhere(np.sqrt(tx**2 + ty**2) > np.max(kx)).squeeze() kc[outside] = 0 # keep region of support same as radial kc = np.reshape(kc, (N, N, nc), order='F') # Make sure we gridded something recognizable ifft = lambda x0: np.fft.fftshift(np.fft.ifft2( np.fft.ifftshift(x0, axes=(0, 1)), axes=(0, 1)), axes=(0, 1)) sos = lambda x0: np.sqrt(np.sum(np.abs(x0)**2, axis=-1)) nx, ny = 1, 3 plt.subplot(nx, ny, 1) true = sos(ifft(kc)) true /= np.max(true.flatten()) thresh = threshold_li(true) mask = convex_hull_image(true > thresh) true *= mask plt.imshow(true) plt.title('Cartesian Sampled') plt.subplot(nx, ny, 2) scgrog = sos(ifft(res)) scgrog /= np.max(scgrog.flatten()) scgrog *= mask plt.imshow(scgrog) plt.title('SC-GROG') plt.subplot(nx, ny, 3) plt.imshow(true - scgrog) plt.title('Residual')
csm = csm[:, :, sl, ..., 0].squeeze() # view(csm) print(im.shape, im.shape) # Adjust for coil sensitivities im0 = np.zeros((im.shape[:3]), dtype='complex') print(im0.shape) for ii in range(4): im0[..., ii] = np.sum(im[..., :, ii]*csm.conj(), axis=-1) # Now do GS recon TR = 6e-3 M = gs_recon(im0, pc_axis=-1) m = int(M.shape[0]/4) M = M[m:-m, :] thresh = threshold_li(np.abs(M)) mask = np.abs(M) > thresh df_est0 = mask*np.angle(M) # df_est = unwrap_phase( # np.ma.array(df_est, mask=np.abs(mask - 1))) # df_est = np.unwrap(df_est, axis=0)*mask # df_est = np.unwrap(df_est, axis=1)*mask # win = np.hamming(M.shape[1]) # win = np.outer(win, win) # df_est = np.fft.fft2(df_est)*win # df_est = np.fft.ifft2(df_est) df_est0 /= np.pi*TR # view(df_est0) # view(df_est/np.max(np.abs(df_est.flatten())))
def walsh(imspace, mask=None, coil_axis=-1): '''Stochastic matched filter coil combine. Parameters ---------- mask : array_like A mask indicating which pixels of the coil sensitivity mask should be computed. If ``None``, this will be computed by applying a threshold to the sum-of-squares coil combination. Must be the same shape as a single coil. coil_axis : int Dimension that has coils. Notes ----- Adapted from [1]_. Based on the paper [2]_. References ---------- .. [1] https://github.com/ismrmrd/ismrmrd-python-tools/ blob/master/ismrmrdtools/coils.py .. [2] Walsh, David O., Arthur F. Gmitro, and Michael W. Marcellin. "Adaptive reconstruction of phased array MR imagery." Magnetic Resonance in Medicine: An Official Journal of the International Society for Magnetic Resonance in Medicine 43.5 (2000): 682-690. ''' imspace = np.moveaxis(imspace, coil_axis, -1) ncoils = imspace.shape[-1] ns = np.prod(imspace.shape[:-1]) if mask is None: sos = np.sqrt(np.sum(np.abs(imspace)**2, axis=-1)) thresh = threshold_li(sos) mask = (sos > thresh).flatten() else: mask = mask.flatten() assert mask.size == ns, 'mask must be the same size as a coil!' # Compute the sample auto-covariances pointwise, will be # Hermitian symmetric, only need lower triangular matrix Rs = np.empty((ncoils, ncoils, ns), dtype=imspace.dtype) for p in range(ncoils): for q in range(p): Rs[q, p, :] = (np.conj(imspace[..., p]) * imspace[..., q]).flatten() # TODO: # # Smooth the covariance # for p in range(ncoils): # for q in range(ncoils): # Rs[p, q] = smooth(Rs[p, q, ...], smoothing) # At each point in the image, find the dominant eigenvector # and corresponding eigenvalue of the signal covariance # matrix using the power method csm = np.zeros((ns, ncoils), dtype=imspace.dtype) for ii in np.nonzero(mask)[0]: R = Rs[..., ii] v = eigh(R, lower=False, eigvals=(ncoils - 1, ncoils - 1))[1].squeeze() csm[ii, :] = v / np.linalg.norm(v) return np.moveaxis(np.reshape(csm, imspace.shape), -1, coil_axis)
#plt.show() #image = data.imread("/Users/exequiel/projects/roots/python/processing/1.15.AVI/selected/frame-54.tiff") block_size = 35 gray = rgb2gray(image) global_thresh = threshold_otsu(gray) print global_thresh global_thresh = 0.65 for t in np.linspace(global_thresh,1.0,20): binary_global = gray > t #binary_global = gray > 0.90 print "threshold_otsu",threshold_otsu(gray) print "threshold_isodata",threshold_isodata(gray) print "threshold_li",threshold_li(gray) print "threshold_yen",threshold_yen(gray) label_img = label(binary_global, connectivity=binary_global.ndim) props = regionprops(label_img) boxes = [] for pp in props: minr, minc, maxr, maxc = pp.bbox boxes += [(minc, minr, maxc - minc, maxr - minr)] valid_boxes = filter_valid_boxes(boxes,6,40,14,24,300,900) if len(valid_boxes) > 0:
def get_lines_and_without_lines_image(img, size=[100, 100]): #img = cv2.imread("Result/bank-0.png") #img = cv2.imread(img) #img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) #img = clahe.apply(img) img = cv2.bitwise_not(img) #element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3)) #img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, element) #img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, element) #th2 = cv2.adaptiveThreshold(img,255, cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,15,-2) #th2 = cv2.adaptiveThreshold(img,255, cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,35,-2) th2 = threshold_li(img) th2 = (img > th2) * 255 th2 = img_as_ubyte(th2) kernel = np.ones((2, 7), np.uint8) th_v = cv2.dilate(th2, kernel, iterations=2) kernel = np.ones((2, 3), np.uint8) th_h = cv2.dilate(th2, kernel, iterations=1) horizontal = th2 vertical = th2 rows, cols = horizontal.shape horizontalsize = size[0] horizontalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (horizontalsize, 1)) horizontal_skel = cv2.erode(th_h, horizontalStructure, (-1, -1)) horizontal_skel = cv2.dilate(horizontal_skel, horizontalStructure, (-1, -1)) horizontal_skel = image_skeleton(horizontal_skel, (2, 1)) horizontal = cv2.erode(horizontal, horizontalStructure, (-1, -1)) horizontal = cv2.dilate(horizontal, horizontalStructure, (-1, -1)) horizontal_inv = cv2.bitwise_not(horizontal) masked_img = cv2.bitwise_and(img, img, mask=horizontal_inv) masked_img_inv = cv2.bitwise_not(masked_img) horizontal_mask = masked_img_inv #cv2.imwrite("horizontal.jpg", masked_img_inv) verticalsize = size[1] verticalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, verticalsize)) vertical_skel = cv2.erode(th_v, verticalStructure, (-1, -1)) vertical_skel = cv2.dilate(vertical_skel, verticalStructure, (-1, -1)) vertical_skel = image_skeleton(vertical_skel, (5, 1)) vertical_skel = cv2.bitwise_not(vertical_skel) vertical = cv2.erode(vertical, verticalStructure, (-1, -1)) vertical = cv2.dilate(vertical, verticalStructure, (-1, -1)) vertical_inv = cv2.bitwise_not(vertical) masked_img = cv2.bitwise_and(img, img, mask=vertical_inv) masked_img_inv = cv2.bitwise_not(masked_img) vertical_mask = masked_img_inv #cv2.imwrite("vertical.jpg", masked_img_inv) final_without_lines = cv2.bitwise_or(horizontal_mask, vertical_mask) final_only_lines = cv2.bitwise_xor(horizontal_mask, vertical_mask) cv2.imwrite("final_without_lines.png", final_without_lines) cv2.imwrite("final_only_lines.png", final_only_lines) cv2.imwrite("final_only_lines_h.png", horizontal_skel) cv2.imwrite("final_only_lines_v.png", vertical_skel) #final_without_lines = cv2.bitwise_not(final_without_lines) #th2 = cv2.adaptiveThreshold(final_without_lines,255, cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,15,-2) ret, final_without_lines = cv2.threshold(final_without_lines, 127, 255, 0) #th2 = threshold_minimum(final_without_lines) #th2 = (img > th2)*255 #th2 = img_as_ubyte(th2) #final_without_lines = cv2.bitwise_not(th2) kernel = np.ones((2, 2), np.uint8) final_without_lines = cv2.morphologyEx(final_without_lines, cv2.MORPH_CLOSE, kernel) cv2.imwrite("final_thresholded.png", final_without_lines) ''' th2 = cv2.medianBlur(th2,7) th2_1 = cv2.bitwise_not(th2) verticalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 5)) th2 = cv2.erode(th2_1, verticalStructure, (-1, -1), iterations=2) horizontalStructure = cv2.getStructuringElement(cv2.MORPH_RECT, (5,1)) th2 = cv2.erode(th2, horizontalStructure, (-1, -1), iterations=1) th2 = cv2.bitwise_not(th2) th2 = cv2.bitwise_or(th2_1,th2) #th2 = cv2.bitwise_xor(th2_1,th2) cv2.imwrite('threshold.png', th2) ''' return horizontal_skel, vertical_skel, final_without_lines, th2
def create_slicemap_config(self): filter = self.filter_name slicemaps_paths = [] for i in range(0, self.slicemaps_number): slicemaps_paths.append( os.path.join( self.relative_path_to_slicemaps_dir, self.slicemap_name_format.format( i, self.row_col[0], self.row_col[1], int(self.slicemap_size[0]), int(self.slicemap_size[1]), self.filter_name, ), ) ) rows_cols = self.row_col slicemap_size = self.slicemap_size slices_range = self.slices_range original_slice_size = self.original_slice_size volume_size = [ self.area_of_slice[1][0] - self.area_of_slice[0][0], self.area_of_slice[1][1] - self.area_of_slice[0][1], self.slices_range[1] - self.slices_range[0], ] area_of_slice = [self.area_of_slice[0], self.area_of_slice[1]] slice_path_to_middle_slice = self.slices_path_list[int((self.slices_range[0] + self.slices_range[1]) / 2)] middle_slice = Image.open(slice_path_to_middle_slice) middle_slice_numpy_array = numpy.array(middle_slice) threshold_otsu_index = threshold_otsu(middle_slice_numpy_array) / 255.0 threshold_isodata_index = threshold_isodata(middle_slice_numpy_array) / 255.0 threshold_yen_index = threshold_yen(middle_slice_numpy_array) / 255.0 threshold_li_index = threshold_li(middle_slice_numpy_array) / 255.0 print("******************************************************************") print("Slicemap size: {0},{1} px".format(self.slicemap_size[0], self.slicemap_size[1])) print("Number of slicemaps: {0}".format(self.slicemaps_number)) print("Rows and cols: {0},{1}".format(rows_cols[0], rows_cols[1])) print("Number of slices: {0}".format(self.number_of_slices)) print( "Original slice size: {0},{1} px".format( int(self.original_slice_size[0]), int(self.original_slice_size[1]) ) ) print( "Slicemap slice size: {0},{1} px".format( int(self.slicemap_slice_size[0]), int(self.slicemap_slice_size[1]) ) ) print( "Proposional slicemap slice size: {0},{1} px".format( self.proposional_slicemap_slice_size[0], self.proposional_slicemap_slice_size[1] ) ) print("Volume proportions: {0},{1},{2}".format(volume_size[0], volume_size[1], volume_size[2])) print("Interpolation filter name: {0}".format(self.filter_name)) print("Number of rows and cols: {0},{1}".format(self.row_col[0], self.row_col[1])) print( "Global path to slicemaps: {0}".format( os.path.join( self.global_path_to_slicemaps_dir, self.slicemap_name_format.format( "n", self.row_col[0], self.row_col[1], int(self.slicemap_size[0]), int(self.slicemap_size[1]), self.filter_name, ), ) ) ) print( "Relative path to slicemaps: {0}".format( os.path.join( self.relative_path_to_slicemaps_dir, self.slicemap_name_format.format( "n", self.row_col[0], self.row_col[1], int(self.slicemap_size[0]), int(self.slicemap_size[1]), self.filter_name, ), ) ) ) print("Path to slices: {0}".format(self.path_to_slices)) print("Name of fisrt slice: {0}".format(self.files_list[0])) print( "Name of fisrt slicemaps: {0}".format( self.slicemap_name_format.format( 0, self.row_col[0], self.row_col[1], int(self.slicemap_size[0]), int(self.slicemap_size[1]), self.filter_name, ) ) ) print("Area_of_slice: {0},{1} px".format(self.area_of_slice[0], self.area_of_slice[1])) print("threshold_otsu_index: {0}".format(threshold_otsu_index)) print("threshold_isodata_index: {0}".format(threshold_isodata_index)) print("threshold_yen_index: {0}".format(threshold_yen_index)) print("threshold_li_index: {0}".format(threshold_li_index)) data = {} data["filter"] = self.filter_name data["slicemaps_paths"] = [] for i in range(0, self.slicemaps_number): data["slicemaps_paths"].append( os.path.join( self.relative_path_to_slicemaps_dir, self.slicemap_name_format.format( i, self.row_col[0], self.row_col[1], int(self.slicemap_size[0]), int(self.slicemap_size[1]), self.filter_name, ), ) ) data["row_col"] = rows_cols data["slicemap_size"] = slicemap_size data["slices_range"] = slices_range data["original_slice_size"] = original_slice_size data["slicemap_slice_size"] = self.slicemap_slice_size data["volume_size"] = volume_size data["area_of_slice"] = area_of_slice data["threshold_indexes"] = { "otsu": threshold_otsu_index, "isodata": threshold_isodata_index, "yen": threshold_yen_index, "li": threshold_li_index, } jsonString = json.dumps(data) print("************ CONFIG BEGIN ************ ") print(jsonString) print("************ CONFIG END ************** ") if not (os.path.exists(self.path_to_configs_dir)): os.makedirs(self.path_to_configs_dir) config_file = open(self.path_to_config, "w") config_file.write(jsonString) config_file.close()
plt.figure('thresh',figsize=(8,12)) plt.subplot(321) plt.title('original image') plt.imshow(image,plt.cm.gray) plt.subplot(322) plt.title('binary_otsu image') thresh = filters.threshold_otsu(image) #返回一个阈值 dst = (image <= thresh)*1.0 #根据阈值进行分割 plt.imshow(dst,plt.cm.gray) plt.subplot(323) plt.title('binary_yen image') dst = (image <= filters.threshold_yen(image) )*1.0 plt.imshow(dst,plt.cm.gray) plt.subplot(324) plt.title('binary_li image') dst = (image <= filters.threshold_li(image) )*1.0 plt.imshow(dst,plt.cm.gray) '''2、基于isodata的阈值分割方法''' plt.subplot(325) plt.title('binary_isodata image') dst = (image <= filters.threshold_isodata(image) )*1.0 plt.imshow(dst,plt.cm.gray) '''2、基于local的阈值分割方法''' plt.subplot(326) plt.title('binary_local image') dst = filters.threshold_local(image, 15, method='gaussian') #返回一个阈值图像 plt.imshow(dst,plt.cm.gray) plt.show() # ============================================================================= print('''十、基本图形的绘制''') # =============================================================================
def processImage(captchaPath, report=None, backgroundLayerPath=None, canny_sigma=0.1, corner_min_dist=2, debug = False): """ Processes the given image and returns a number of feature points. These feature points are presumably corner points of the tetragon. """ image = io.imread(captchaPath, True); image_without_bg = None # remove background, if available if not None == backgroundLayerPath: bgl = io.imread(backgroundLayerPath, True) image_without_bg = (image - bgl) else: image_without_bg = image # applying threshold operators thresh = threshold_otsu(image_without_bg) thrs_image = image_without_bg > thresh thresh_li = threshold_li(image_without_bg) thrs_image_li = image_without_bg > thresh_li thresh_yen = threshold_yen(image_without_bg) thrs_image_yen = image_without_bg > thresh_yen # thrs_image = thrs_image * thrs_image_li * thrs_image_yen thrs_image = image_without_bg * thrs_image thrs_image = thrs_image * thrs_image_li thrs_image = thrs_image * thrs_image_yen # thrs_image = ndi.gaussian_filter(thrs_image, 0.8) # take the gray image gray_result = rgb2gray(thrs_image) # find edges # canny_result = feature.canny(gray_result, sigma=0.5, low_threshold=1.8) canny_result = gray_result # store image processedImageName = captchaPath[0:len(captchaPath)-4] + "_processed.png" io.imsave(processedImageName, canny_result.clip(-1, 1)) if not None == report: report.setProcessedImage(processedImageName) coords = feature.corner_peaks(feature.corner_harris(canny_result), min_distance=corner_min_dist) if debug: fig, axes = plt.subplots(nrows=6, figsize=(8, 3)) ax0, ax1, ax2, ax3, ax4, ax5 = axes ax0.imshow(image, cmap=plt.cm.gray) ax0.set_title('Original image') ax0.axis('off') ax1.imshow(image_without_bg, cmap=plt.cm.gray) ax1.set_title('Image without background') ax1.axis('off') ax2.imshow(thrs_image, cmap=plt.cm.gray) ax2.set_title('Thresholded image') ax2.axis('off') ax3.imshow(gray_result, cmap=plt.cm.gray) ax3.set_title('After RGB -> Gray') ax3.axis('off') ax4.imshow(canny_result, cmap=plt.cm.gray) ax4.set_title('After Canny') ax4.axis('off') ax5.imshow(canny_result, cmap=plt.cm.gray) ax5.plot(coords[:, 1], coords[:, 0], '+r', markersize=15) ax5.set_title('Detected Features') ax5.axis('off') plt.show() return coords
def segmentation(image, method='otsu'): if (method == 'region'): sobel_image = filters.sobel(image) makers = sobel_image < sobel_image.max()*0.1 makers = ndi.label(makers)[0] labels = watershed(sobel_image,makers) elif (method == 'edge'): edges = canny(image,3) fill = ndi.binary_fill_holes(edges) labels = remove_small_objects(fill,10) elif (method == 'self_design'): width = 100; scale = 0.72; [m, n] = image.shape thre = np.zeros((m,n)) for i in range(0,n): ind_s = max(0,int(np.ceil(i-width/2))) ind_e = min(n-1,ind_s+width) current_image = image[0:m-1, ind_s:ind_e] thre[0:m-1, i] = filters.threshold_otsu(current_image)*0.8 labels = (image - thre) >=0 elif (method == 'thre_cons'): global_thre = image.max() * 0.3 labels = image > global_thre elif (method == 'global_otsu'): global_thre = filters.threshold_otsu(image) labels = image > global_thre elif (method == 'local_otsu'): selem=disk(80) local_otsu = filters.rank.otsu(image, selem) labels = image > (np.true_divide(local_otsu,255)) elif (method == 'yen'): global_thre = filters.threshold_yen(image) labels = image > (global_thre*2.5) elif (method == 'li'): global_thre = filters.threshold_li(image) labels = image > global_thre elif (method == 'isodata'): global_thre = filters.threshold_isodata(image) labels = image > global_thre elif (method == 'adaptive'): block_size = 100 image = np.true_divide(image,image.max()+np.spacing(1)) * 255 labels = filters.threshold_adaptive(image, block_size, offset=10) elif (method == 'R_Walker'): data = image + 0.35 * np.random.randn(*image.shape) markers = np.zeros(data.shape, dtype=np.uint) markers[data < -0.3] = 1 markers[data > 1.3] = 2 labels = random_walker(data, markers, beta=10, mode='cg_mg') return labels
> Import the appropriate thresholding and rgb2gray() functions. > Turn the image to grayscale. > Obtain the optimal thresh. > Obtain the binary image by applying thresholding. """ import sys from skimage.filters import try_all_threshold, threshold_li from skimage.color import rgb2gray from matplotlib import pyplot as plt sys.path.append('./helpers') from settings import nda_import_image, show_image str_tools_image_path = './dataset/chapter 1/shapes52.jpg' img_tools = nda_import_image(str_tools_image_path) def apply_thresholding_test(img): img_grayscale = rgb2gray(img) fig, ax = try_all_threshold(img_grayscale, verbose=False) plt.show() apply_thresholding_test(img_tools) img_tools_grayscale = rgb2gray(img_tools) li_thresh = threshold_li(img_tools_grayscale) img_tools_binary = img_tools_grayscale > li_thresh show_image(img_tools_binary)
import matplotlib.pyplot as plt import numpy as np from scipy import ndimage as ndi from skimage import morphology, color, data, filters, io, feature, exposure img = io.imread('Image/011.png') image = color.rgb2gray(img) img_c = exposure.equalize_hist(image) denoised = filters.rank.median(img_c, morphology.disk(5)) #过滤噪声 thresh = filters.threshold_li(denoised) binary = denoised > thresh for i in range(10): binary = morphology.binary_erosion(binary) classes = ndi.label(binary)[0] gradient = filters.rank.gradient(denoised, morphology.disk(5)) gradient_inv = gradient.max() - gradient local_min = feature.peak_local_max(gradient_inv, indices=False, min_distance=35, num_peaks_per_label=1, labels=classes) gradient_selected = np.ones(np.shape(image)) * gradient.max() gradient_selected[local_min == True] = gradient[local_min == True] markers = ndi.label(local_min)[0] labels = morphology.watershed(gradient, markers, watershed_line=True,
def test_sample1(): ROOT = os.path.abspath(os.path.dirname(__file__)) filename = os.path.join(ROOT, "samples", "coins1.jpg") data = load_data(filename) data = sktrans.rescale(data, 0.1) plt.figure() plt.title("Original data") plt.imshow(data) plt.figure() filt = data[...,0].astype(float)#.mean(axis=-1) filt-=filt.min() filt/=filt.max() plt.imshow(filt, cmap='jet') plt.title("Red channel") edges = skfilt.sobel(skfilt.gaussian_filter(filt, 4.0)) plt.figure() plt.title("Edges (Sobel)") plt.imshow(edges) markers = np.zeros(filt.shape, dtype=int) med = np.median(filt) mad = np.median(np.abs(filt - med)) markers[filt < med] = 1 markers[filt > (med + 3*mad)] = 2 ws = skmo.watershed(edges, markers) plt.figure() plt.title("Watershed using edges") plt.imshow(filt, cmap='gray') plt.imshow(np.ma.masked_where(ws==0, ws), alpha=0.4) plt.figure() plt.imshow(skfilt.median(filt, np.ones((5,5), dtype=bool))) plt.title("Median filtered image") # Let's try scale space representation scales=np.arange(5, 40) if jmfilt: lg = jmfilt.scale_space_LoG(filt, scales=scales) med,mad = jmfilt.getMedMad(lg) bw = lg > (med + 3*mad) # Automatic thresholding based on # median absolute deviation # Method 1 ## Have to use maximum filter, one scale at a time? #maxim = np.zeros_like(lg) #for i,s in enumerate(scales): # lgnow = np.zeros_like(lg) # lgnow[...,i] = lg[...,i] # lgmax = ndi.maximum_filter(lg, footprint=skmo.ball(s)) # maxim = np.maximum(lgmax, maxim) # Method 2 # Find local maxima, then operate on peaks to suppress lgmax = ndi.maximum_filter(lg, size=3) peaks = np.array(((lgmax == lg)&bw).nonzero()).T peak_ints = lg[peaks.T.tolist()] # Now sort the peaks by the intensities order = np.argsort(peak_ints)[::-1] peak_ints = peak_ints[order] peaks = peaks[order] # Now suppress active = np.ones(peaks.shape[0], dtype=bool) for i, p in enumerate(peaks): if not active[i]: continue # Silence any nearby peaks dists = np.sqrt(np.sum( (peaks[:,:2]-p[:2])**2, axis=-1)) nearby = dists < (2*scales[p[2]]) nearby[i] = False # Ignore self active[nearby] = False suppressed = peaks[~active] peaks = peaks[active] print("Peaks after non-maximal suppression:", len(peaks)) plt.imshow(filt, cmap='gray') #plt.scatter(peaks[:,1], peaks[:,0], s=10*np.array(peaks[:,2]), # marker='o', color="y", facecolor="none") #plt.scatter(suppressed[:,1], suppressed[:,0], # s=10*np.array(suppressed[:,2]), # marker='o', color="r", facecolor="none") # Add circles instead to get proper sizes ax = plt.gca() for p in peaks: c = plt.Circle(p[[1,0]], scales[p[2]], color='y', fill=False) ax.add_artist(c) for p in suppressed: c = plt.Circle(p[[1,0]], scales[p[2]], color='r', fill=False) ax.add_artist(c) plt.title("Scale space peaks") # Lastly, good old Hough bw_edges = edges > skfilt.threshold_li(edges) bw_edges = skmo.skeletonize(bw_edges) bw_edges = skmo.binary_dilation(bw_edges) hough_radii = scales hough_res = sktrans.hough_circle(bw_edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): num_peaks = 20 peaks = skfeat.peak_local_max(h, num_peaks=num_peaks) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * num_peaks) # Draw the most prominent 5 circles image = skcolor.gray2rgb(filt) print(image.shape) for idx in np.argsort(accums)[::-1][:20]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = skdraw.circle_perimeter(center_y, center_x, radius) image[cy, cx] = (220, 20, 20) plt.figure() plt.imshow(filt, cmap='gray') plt.imshow(np.ma.masked_where(bw_edges==0, bw_edges), cmap='hsv', alpha=0.4) plt.title("Binary edges (input to hough)") plt.figure() plt.imshow(image) plt.title("Hough circle transform results") plt.show() return labels = process_file(filename) show_results(filename, labels) plt.show()
# run dilation reconstruction on image. This contains the background. dilated = reconstruction(seed, mask, method='dilation') # subtract the dilated background image from the image subtracted = image - dilated # init disk kernel for dialtion selem = disk(3) # dilate the subtracted image dilated = dilation(subtracted, selem) # perform threshold on the image using triangle thresh = threshold_li(dilated) binary = dilated > thresh # label discrete objects and assign each labeled area a number. label_image = label(binary) # remove small (artifactual) objects from the image label_image = remove_small_objects(label_image, 300) # init disk kernel for dilationg to get neuropils kernel = disk(45) # perform dilation on the image to get the neuron and the surrounding neuropil neuropils = dilation(label_image, kernel) # subtract neuron from dilation to get just the neuron neuropils = neuropils - label_image
def experiment_thresholding(votes_min=3): from skimage.filters import threshold_otsu from skimage.filters import threshold_li from skimage.filters import threshold_yen from skimage.filters import threshold_adaptive from scipy.ndimage import median_filter images = image_generator() for fn, im in images: print("inspecting image: ", fn) print("computing otsu threshold") otsu = threshold_otsu(im) otsu_ch1 = np.zeros(im.shape) otsu_ch2 = np.zeros(im.shape) otsu_ch3 = np.zeros(im.shape) otsu_ch1[im[:, :, 0] > otsu, 0] = 255 otsu_ch2[im[:, :, 1] > otsu, 1] = 255 otsu_ch3[im[:, :, 2] > otsu, 2] = 255 otsu_ch1 = smallest_partition(otsu_ch1, 0) otsu_ch2 = smallest_partition(otsu_ch2, 1) otsu_ch3 = smallest_partition(otsu_ch3, 2) print("computing yen threshold") yen = threshold_yen(im) yen_ch1 = np.zeros(im.shape) yen_ch2 = np.zeros(im.shape) yen_ch3 = np.zeros(im.shape) yen_ch1[im[:, :, 0] > yen, 0] = 255 yen_ch2[im[:, :, 1] > yen, 1] = 255 yen_ch3[im[:, :, 2] > yen, 2] = 255 yen_ch1 = smallest_partition(yen_ch1, 0) yen_ch2 = smallest_partition(yen_ch2, 1) yen_ch3 = smallest_partition(yen_ch3, 2) print("computing li threshold") li = threshold_li(im) li_ch1 = np.zeros(im.shape) li_ch2 = np.zeros(im.shape) li_ch3 = np.zeros(im.shape) li_ch1[im[:, :, 0] > li, 0] = 255 li_ch2[im[:, :, 1] > li, 1] = 255 li_ch3[im[:, :, 2] > li, 2] = 255 li_ch1 = smallest_partition(li_ch1, 0) li_ch2 = smallest_partition(li_ch2, 1) li_ch3 = smallest_partition(li_ch3, 2) print("computing average threshold") av_ch1 = np.zeros(im.shape) av_ch2 = np.zeros(im.shape) av_ch3 = np.zeros(im.shape) votes1 = otsu_ch1 + yen_ch1 + li_ch1 votes1 = otsu_ch1 + yen_ch1 + li_ch1 votes2 = otsu_ch2 + yen_ch2 + li_ch2 votes3 = otsu_ch3 + yen_ch3 + li_ch3 av_ch1[votes1[:, :, 0] >= (255 * votes_min), 0] = 255 av_ch2[votes2[:, :, 1] >= (255 * votes_min), 1] = 255 av_ch3[votes3[:, :, 2] >= (255 * votes_min), 2] = 255 thresholded_images = [ otsu_ch1, otsu_ch2, otsu_ch3, yen_ch1, yen_ch2, yen_ch3, li_ch1, li_ch2, li_ch3, av_ch1, av_ch2, av_ch3, ] print("filtering out specks") for idx, im in enumerate(thresholded_images): thresholded_images[idx] = median_filter(im, size=3) titles = [ "Channel 1 Otsu", "Channel 2 Otsu", "Channel 3 Otsu", "Channel 1 Yen", "Channel 2 Yen", "Channel 3 Yen", "Channel 1 Li", "Channel 2 Li", "Channel 3 Li", "Channel 1 Avg", "Channel 2 Avg", "Channel 3 Avg", ] print("plotting") plot_images(thresholded_images, titles=titles, suptitle=fn.split("/")[-1])
ax[1].imshow(camera > optimal_camera_threshold, cmap='gray') ax[1].set_title('thresholded') ax[1].set_axis_off() ax[2].plot(thresholds, entropies) ax[2].set_xlabel('thresholds') ax[2].set_ylabel('cross-entropy') ax[2].vlines(optimal_camera_threshold, ymin=np.min(entropies) - 0.05 * np.ptp(entropies), ymax=np.max(entropies) - 0.05 * np.ptp(entropies)) ax[2].set_title('optimal threshold') fig.tight_layout() print('The brute force optimal threshold is:', optimal_camera_threshold) print('The computed optimal threshold is:', filters.threshold_li(camera)) plt.show() ############################################################################### # Next, let's use the ``iter_callback`` feature of ``threshold_li`` to examine # the optimization process as it happens. iter_thresholds = [] optimal_threshold = filters.threshold_li(camera, iter_callback=iter_thresholds.append) iter_entropies = [_cross_entropy(camera, t) for t in iter_thresholds] print('Only', len(iter_thresholds), 'thresholds examined.')
c = center[1] + radius*np.cos(rads) r = center[0] + radius*np.sin(rads) return np.array([c, r]).T """# Optimization in unsupervised segmentation:""" text = data.page() image_show(text) text_threshold = filters.threshold_otsu(text) image_show(text > text_threshold); text_threshold = filters.threshold_li(text) image_show(text > text_threshold); text_threshold = filters.threshold_local(text,block_size=51, offset=10) image_show(text > text_threshold); """# Optimization in snake based contour segmentation:""" points = generate_circle(200, [160, 120], 60)[:-1] fig, ax = image_show(image_gray) ax.plot(points[:, 0], points[:, 1], '--r', lw=3) """**Generating snake based on circle:**""" import skimage.segmentation as seg
matplotlib.rcParams['font.size'] = 9 img_orig = '/home/andrea/Desktop/20160713_NCP_GO_Talos_121.jpg' img_lowpass = '******' out_dir = '/home/andrea/Desktop/test' if not os.path.isdir(out_dir): os.makedirs(out_dir) os.chdir(out_dir) # print('Processing original') # image_orig = imread(img_orig, as_grey=True, flatten = True) # thresh_orig = threshold_isodata(image_orig) # binary_orig = image_orig > thresh_orig print('Processing lowpass isodata') image = imread(img_lowpass, as_grey=True, flatten = True) thresh_isodata = threshold_isodata(image) thresh_otsu = threshold_otsu(image) thresh_li = threshold_li(image) thresh_yen = threshold_yen(image) thresh_adaptive = threshold_adaptive(image, 3) binary_isodata = image > thresh_isodata binary_otsu = image > thresh_otsu binary_li = image > thresh_li binary_adaptive = image > thresh_adaptive binary_yen = image > thresh_yen # edges = canny(image_orig/255.) # fill_image = ndi.binary_fill_holes(edges) imshow(binary_isodata) imshow(binary_otsu) imshow(binary_yen) imshow(binary_li) imshow(binary_adaptive)