def biuld_multispace(cnts): """Extract some contours features (mean_int & circularity) and return a multivariable space""" # circularity = [4 * np.pi * np.divide(cv2.contourArea(c), cv2.arcLength(c, True) ** 2) for c in cnts] # mean_int = [np.mean(gg[np.ravel(c).reshape([len(c), 2])[:, 1], np.ravel(c).reshape([len(c), 2])[:, 0]]) for c in cnts] global circularity, cnts_area, approx circularity = np.zeros(len(cnts)) mean_int = np.zeros(len(cnts)) cnts_area = np.zeros(len(cnts)) cnts_perim = np.zeros(len(cnts)) approx = np.zeros(len(cnts)) gg = gaussian_gradient_magnitude(img, sigma=1) gg = np.array( Image.fromarray(gg).resize(scale * np.array(np.transpose(img).shape))) for ii in range(len(cnts)): cnts_area[ii] = cv2.contourArea(cnts[ii]) cnts_perim[ii] = cv2.arcLength(cnts[ii], True) approx[ii] = len( cv2.approxPolyDP(cnts[ii], 0.01 * cnts_perim[ii], True)) circularity[ii] = 4 * np.pi * np.divide(cnts_area[ii], cnts_perim[ii]** 2) coor = cnts[ii].reshape((len(cnts[ii]), 2)) mean_int[ii] = np.mean(gg[np.array(coor[:, 1]), np.array(coor[:, 0])]) features = np.column_stack( (mean_int, circularity)) # Mean intensity, circularity multi_space = np.reshape(features, (len(cnts), 1, features.shape[1])) return multi_space
def find_significant(self): def convert_to_polar(x_coord, y_coord): magnitude = np.sqrt(x_coord**2 + y_coord**2) angle = np.arctan2(x_coord, y_coord) return magnitude, angle def convert_to_decart(magnitude, angle): x_coord = magnitude * np.cos(angle) y_coord = magnitude * np.sin(angle) return x_coord, y_coord f_i = np.fft.fft2(self.im) rho, phi = convert_to_polar(np.real(f_i), np.imag(f_i)) l_f = np.log10(rho.clip(min=1e-9)) h = 1 / 9 * np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) h_l = convolve(l_f, h) r_p = np.exp(l_f - h_l) imag_part, real_part = convert_to_decart(r_p, phi) img_combined = np.fft.ifft2(real_part + 1j * imag_part) s_f, _ = convert_to_polar(np.real(img_combined), np.imag(img_combined)) s_f = gaussian_gradient_magnitude(s_f, (8, 0)) s_f = s_f**2 s_f = np.float32(s_f) / np.max(s_f) # s_f = np.flipud(s_f) # s_f = np.fliplr(s_f) th = 3 * np.mean(s_f) o_f = np.where(s_f > th, 1, 0) o_f = scipy.ndimage.binary_dilation(o_f).astype(o_f.dtype) o_f = scipy.ndimage.binary_erosion(o_f).astype(o_f.dtype) return o_f
def getGradientThresholdAndImage(image, center, d, res): gradient_img = flt.gaussian_gradient_magnitude(image, 1) th = npy.max( gradient_img[npy.ceil(center[0] - d / res[0]):npy.floor(center[0] + d / res[0]), npy.ceil(center[1] - d / res[1]):npy.floor(center[1] + d / res[1])]) return th * 0.75, gradient_img
def general_cc_var_num_channels(img, diff_order=0, mink_norm=1, sigma=1, mask_im=None, saturation_threshold=255, dilation_size=3, clip_range=True): # img must have first dim color channel! img[c, x, y(, z, ...)] dim_img = len(img.shape[1:]) if clip_range: minm = img.min() maxm = img.max() img_internal = np.array(img) if mask_im is None: mask_im = np.zeros(img_internal.shape[1:], dtype=bool) img_dil = deepcopy(img_internal) for c in range(img.shape[0]): img_dil[c] = grey_dilation(img_internal[c], tuple([dilation_size] * dim_img)) mask_im = mask_im | np.any(img_dil >= saturation_threshold, axis=0) if sigma != 0: mask_im[:sigma, :] = 1 mask_im[mask_im.shape[0] - sigma:, :] = 1 mask_im[:, mask_im.shape[1] - sigma:] = 1 mask_im[:, :sigma] = 1 if dim_img == 3: mask_im[:, :, mask_im.shape[2] - sigma:] = 1 mask_im[:, :, :sigma] = 1 output_img = deepcopy(img_internal) if diff_order == 0 and sigma != 0: for c in range(img_internal.shape[0]): img_internal[c] = gaussian_filter(img_internal[c], sigma, diff_order) elif diff_order == 1: for c in range(img_internal.shape[0]): img_internal[c] = gaussian_gradient_magnitude(img_internal[c], sigma) elif diff_order > 1: raise ValueError("diff_order can only be 0 or 1. 2 is not supported (ToDo, maybe)") img_internal = np.abs(img_internal) white_colors = [] if mink_norm != -1: kleur = np.power(img_internal, mink_norm) for c in range(kleur.shape[0]): white_colors.append(np.power((kleur[c][mask_im != 1]).sum(), 1. / mink_norm)) else: for c in range(img_internal.shape[0]): white_colors.append(np.max(img_internal[c][mask_im != 1])) som = np.sqrt(np.sum([i ** 2 for i in white_colors])) white_colors = [i / som for i in white_colors] for c in range(output_img.shape[0]): output_img[c] /= (white_colors[c] * np.sqrt(3.)) if clip_range: output_img[output_img < minm] = minm output_img[output_img > maxm] = maxm return white_colors, output_img
def __call__(self,image): if image.ndim==1: image = image.reshape(*self.tsize) left = 0.0+image[:,0] image[:,0] = 0 deriv = filters.gaussian_gradient_magnitude(image,self.dsigma,mode='constant') if self.spread>0: deriv = filters.maximum_filter(image,(self.spread,self.spread)) deriv /= 1e-6+amax(deriv) result = self.alpha*deriv + (1.0-self.alpha)*image result[:,0] = left return result
def multidim_gauss_grad(array, sigma=1): starttime = time.time() arrayofimages = [array] for i in range(3): arrayofimages.append( filters.gaussian_gradient_magnitude(copy.deepcopy(array), sigma=i)) arrayofimages = list(map(normalize, arrayofimages)) print("Multidimensional Gaussian Gradient Execution Time:\t" + str(time.time() - starttime)) return arrayofimages
def __extract_guassian_gradient_magnitude(image, mask = slice(None), sigma = 1, voxelspacing = None): """ Internal, single-image version of @see guassian_gradient_magnitude """ # set voxel spacing if voxelspacing is None: voxelspacing = [1.] * image.ndim # determine gaussian kernel size in voxel units sigma = __create_structure_array(sigma, voxelspacing) return __extract_intensities(gaussian_gradient_magnitude(image, sigma), mask)
def find_significant_region(file_name): # filter_h = np.array([[0.04, 0.12, 0.04], [0.12, 0.36, 0.12], [0.04, 0.12, 0.04]]) img = Image.open(file_name) channel = np.zeros(img.size) for i in range(img.size[0]): for j in range(img.size[1]): channel[i, j] = img.getpixel((i, j)) f_i = np.fft.fft2(channel) # print(f_i[0, 0]) # print(f_i.ndim) magnitude, angle = convert_to_polar(np.real(f_i), np.imag(f_i)) # print(magnitude) # print(angle) l_f = np.log10(magnitude.clip(min=1e-9)) # print(l_f) h = 1 / 9 * np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]) h_l = convolve(l_f, h) # print(h_l) r_p = np.exp(l_f - h_l) # print(r_p) imag_part, real_part = convert_to_decart(r_p, angle) # print(imag_part) # print(real_part) img_combined = np.fft.ifft2(real_part + 1j * imag_part) s_f, _ = convert_to_polar(np.real(img_combined), np.imag(img_combined)) s_f = gaussian_gradient_magnitude(s_f, (8, 0)) # img2 = img.copy() # print(s_f) s_f = s_f ** 2 s_f = np.float32(s_f) / np.max(s_f) s_f = np.flipud(s_f) s_f = np.fliplr(s_f) th = np.mean(s_f) o_f = np.zeros(s_f.shape) for i in range(s_f.shape[0]): for j in range(s_f.shape[1]): if s_f[i, j] > th: o_f[i, j] = 1 else: o_f[i, j] = 0 o_f = scipy.ndimage.binary_erosion(o_f).astype(o_f.dtype) o_f = scipy.ndimage.binary_dilation(o_f).astype(o_f.dtype) '''for i in range(s_f.shape[0]): for j in range(s_f.shape[1]): if o_f[i, j] == 0: img2.putpixel((i, j), 0) else: img2.putpixel((i, j), 255) img2.save(new_img_file_name)''' return o_f
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 getGradientThresholdAndImage(image, center, d, res): gradient_img = flt.gaussian_gradient_magnitude(image, 1) th = npy.max(gradient_img[npy.ceil(center[0] - d / res[0]) : npy.floor(center[0] + d / res[0]), npy.ceil(center[1] - d / res[1]) : npy.floor(center[1] + d / res[1])]) return th * 0.75, gradient_img
def image_search(asm_model, image, test_image, threshold=70): # image[0] = x # image = y mean, var_matrix, principal_axis, comp_variance = asm_model # differentiate the image image_tmp = np.array(image, dtype=np.float) sigma = 2 image_diff = sigma * gaussian_gradient_magnitude(image_tmp, sigma=sigma) # normalizing of the differentiated image image_diff = normalize_image(image_diff) # The landmarks within the model is the meanshape model_x = np.copy(mean ) # normalize model_x to align the leaf in the image as close as possible a_x, a_y, lower_x, lower_y, upper_x, upper_y = normalize_model(model_x, image_diff, threshold, image) # rotate model_x rotation_matrix = build_matrix(a_x, a_y) model_x_rotated = scale_and_rotate(model_x, rotation_matrix) # find initial translation of model_x t_x = lower_x - model_x_rotated[0] t_y = lower_y - model_x_rotated[1] length = len(model_x)/2 t_vector = get_translation(t_x, t_y, length) # initial landmarks within the image image_x = model_x_rotated + t_vector # initial b vector b = np.array((0.0)) b = np.tile(b, len(principal_axis)) # instantiate the approximation of dx approx_dx = np.array((0)) approx_dx = np.tile(approx_dx, len(model_x)) # this loop should ideally run until the landmarks reach a fix point for i in range(50): # while True print('iteration ', i) # find dX -> the suggested changes in the image frame diff_image_x = adjustments_along_normal(image_x, image_diff, threshold) # all points are placed at the same coordinates if not diff_image_x.any(): print('damn, all points are at the same coordinates') return (np.array(()), np.array(())) # align X o be as close to the new points as possible # alignment_parameters = a_x, a_y, t_x, t_y diff_alignment_parameters = aligner.solve_x(image_x+diff_image_x, image_x, var_matrix) diff_matrix = build_matrix(diff_alignment_parameters[0], diff_alignment_parameters[1]) length = len(image_x)/2 diff_vector = get_translation(diff_alignment_parameters[2], diff_alignment_parameters[3], length) # y from eq. 19 #y = image_x + diff_image_x - image_x_c y = scale_and_rotate(model_x + approx_dx, rotation_matrix) + diff_image_x - diff_vector # calculate new s, theta, t_x, t_y #alignment_parameters = np.dot(alignment_parameters, diff_alignment_parameters) rotation_matrix = np.dot(rotation_matrix, diff_matrix) t_vector = t_vector + diff_vector # suggested movements of the points in the model space # dx = M((s(1+ds))^-1, -(theta + dtheta)) [y] - x diff_model_x = scale_and_rotate(y, np.linalg.inv(rotation_matrix)) - model_x #apply the shape contraints and approximate new model parameter x + dx # 0: x + dx ~ x + P*(b+db) <- allowable shape # 1: db = P^t * dx # 2: x + dx ~ x + P*(b+P^t * dx) # 3: b = b + db = b + P^t * dx # obs! PC's is 'transposed' so inverse the transposion # update b (3) db = np.dot(principal_axis, diff_model_x) # since b = [0,..,0] for mean, and x is mean -> b + db = db b = db # limit b to be 3 standard deviations from the mean (eq 15) for k in range(len(b)): if b[k] > 3 * math.sqrt(comp_variance[k][0]): print('b was bigger than allowable shape domain') print('b index: ', k) b[k] = 3 * math.sqrt(comp_variance[k][0]) if b[k] < (-3) * math.sqrt(comp_variance[k][0]): print('b was smaller than allowable shape domain') print('b index: ', k) b[k] = (-3) * math.sqrt(comp_variance[k][0]) # b coordinats in the model space approx_dx = np.dot(np.array(principal_axis).transpose(), db) # store the old suggestion of landmark to test if any change has happend image_x_old = image_x image_x = scale_and_rotate(model_x+approx_dx, rotation_matrix) + t_vector if sum(abs(image_x-image_x_old)) < 100: break return b, (model_x + approx_dx)
def get_gaussian_gradient_magnitude(image, sigma=cfg.sigma): image_gradient = gaussian_gradient_magnitude(image, sigma) return image_gradient
def computeStructureFeatures(Xdata, isTraining, path): path = path + '/structFeatures' print("\nComputing: All Structure Features") print("is Training? %r" %isTraining) start = time.time() # Separate color channel RChannel = Xdata[:,:,0] GChannel = Xdata[:,:,1] BChannel = Xdata[:,:,2] # Calculate Laplacian of Gaussian (sigma = 1.6) print("Computing: Laplacian of Gaussian") gaussianLF_R = gaussian_laplace(RChannel, 1.6) gaussianLF_G = gaussian_laplace(GChannel, 1.6) gaussianLF_B = gaussian_laplace(BChannel, 1.6) gaussianLF = np.dstack((gaussianLF_R, gaussianLF_G, gaussianLF_B)) gaussianLF = np.resize(gaussianLF, (gaussianLF.shape[0]*gaussianLF.shape[1], gaussianLF.shape[2])) end = time.time() if (isTraining): print("Computed: gaussianLapFeatures_Tr in %f seconds" %(end-start)) # with open('gaussianLapFeatures_Tr.pkl','wb') as outfile: # pickle.dump(gaussianLF, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianLapFeatures_Tr.csv", # gaussianLF, delimiter=",") else: print("Computed: gaussianLapFeatures_Ts in %f seconds" %(end-start)) # with open('gaussianLapFeatures_Ts.pkl','wb') as outfile: # pickle.dump(gaussianLF, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianLapFeatures_Ts.csv", # gaussianLF, delimiter=",") # Calculate eigenvalues of structure tensor (sigma =1.6, 3.5) print("Computing: eigenvalues of structure tensor") start = time.time() Axx_R1, Axy_R1, Ayy_R1 = structure_tensor(RChannel, sigma = 1.6) larger_R1, smaller_R1 = structure_tensor_eigvals(Axx_R1, Axy_R1, Ayy_R1) Axx_R2, Axy_R2, Ayy_R2 = structure_tensor(RChannel, sigma = 3.5) larger_R2, smaller_R2 = structure_tensor_eigvals(Axx_R2, Axy_R2, Ayy_R2) Axx_G1, Axy_G1, Ayy_G1 = structure_tensor(GChannel, sigma = 1.6) larger_G1, smaller_G1 = structure_tensor_eigvals(Axx_G1, Axy_G1, Ayy_G1) Axx_G2, Axy_G2, Ayy_G2 = structure_tensor(GChannel, sigma = 3.5) larger_G2, smaller_G2 = structure_tensor_eigvals(Axx_G2, Axy_G2, Ayy_G2) Axx_B1, Axy_B1, Ayy_B1 = structure_tensor(BChannel, sigma = 1.6) larger_B1, smaller_B1 = structure_tensor_eigvals(Axx_B1, Axy_B1, Ayy_B1) Axx_B2, Axy_B2, Ayy_B2 = structure_tensor(BChannel, sigma = 3.5) larger_B2, smaller_B2 = structure_tensor_eigvals(Axx_B2, Axy_B2, Ayy_B2) eigenST = np.dstack((larger_R1, smaller_R1, larger_R2, smaller_R2, larger_G1, smaller_G1, larger_G2, smaller_G2, larger_B1, smaller_B1, larger_B2, smaller_B2)) eigenST = np.resize(eigenST, (eigenST.shape[0]*eigenST.shape[1], eigenST.shape[2])) end = time.time() if (isTraining): print("Computed: eigenStructFeatures_Tr in %f seconds" %(end-start)) # with open('eigenStructFeatures_Tr.pkl','wb') as outfile: # pickle.dump(eigenST, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenStructFeatures_Tr.csv", # eigenST, delimiter=",") else: print ("Computed: eigenStructFeatures_Ts in %f seconds" %(end-start)) # with open('eigenStructFeatures_Ts.pkl','wb') as outfile: # pickle.dump(eigenST, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenStructFeatures_Ts.csv", # eigenST, delimiter=",") # Calculate eigenvalues of Hessian matrix print("Computing: eigenvalues of Hessian matrix") start = time.time() Hrr_R1, Hrc_R1, Hcc_R1 = hessian_matrix(RChannel, sigma = 1.6, order='rc') larger_R1, smaller_R1 = hessian_matrix_eigvals(Hrr_R1, Hrc_R1, Hcc_R1) Hrr_R2, Hrc_R2, Hcc_R2 = hessian_matrix(RChannel, sigma = 3.5, order='rc') larger_R2, smaller_R2 = hessian_matrix_eigvals(Hrr_R2, Hrc_R2, Hcc_R2) Hrr_G1, Hrc_G1, Hcc_G1 = hessian_matrix(GChannel, sigma = 1.6, order='rc') larger_G1, smaller_G1 = hessian_matrix_eigvals(Hrr_G1, Hrc_G1, Hcc_G1) Hrr_G2, Hrc_G2, Hcc_G2 = hessian_matrix(GChannel, sigma = 3.5, order='rc') larger_G2, smaller_G2 = hessian_matrix_eigvals(Hrr_G2, Hrc_G2, Hcc_G2) Hrr_B1, Hrc_B1, Hcc_B1 = hessian_matrix(BChannel, sigma = 1.6, order='rc') larger_B1, smaller_B1 = hessian_matrix_eigvals(Hrr_B1, Hrc_B1, Hcc_B1) Hrr_B2, Hrc_B2, Hcc_B2 = hessian_matrix(BChannel, sigma = 3.5, order='rc') larger_B2, smaller_B2 = hessian_matrix_eigvals(Hrr_B2, Hrc_B2, Hcc_B2) eigenHess = np.dstack((larger_R1, smaller_R1, larger_R2, smaller_R2, larger_G1, smaller_G1, larger_G2, smaller_G2, larger_B1, smaller_B1, larger_B2, smaller_B2)) eigenHess = np.resize(eigenHess, (eigenHess.shape[0]*eigenHess.shape[1], eigenHess.shape[2])) end = time.time() if (isTraining): print("Computed: eigenHessFeatures_Tr in %f seconds" % (end-start)) # with open('eigenHessFeatures_Tr.pkl','wb') as outfile: # pickle.dump(eigenHess, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenHessFeatures_Tr.csv", # eigenHess, delimiter=",") else: print("Computed: eigenHessFeatures_Ts in %f seconds" % (end-start)) # with open('eigenHessFeatures_Ts.pkl','wb') as outfile: # pickle.dump(eigenHess, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenHessFeatures_Ts.csv", # eigenHess, delimiter=",") # Calculate Gaussian gradient magnitude (sigma = 1.6) print("Computing: Gaussian gradient magnitude") start = time.time() gaussian_grad_R = gaussian_gradient_magnitude(RChannel, sigma = 1.6) gaussian_grad_G = gaussian_gradient_magnitude(GChannel, sigma = 1.6) gaussian_grad_B = gaussian_gradient_magnitude(BChannel, sigma = 1.6) gaussian_grad = np.dstack((gaussian_grad_R, gaussian_grad_G, gaussian_grad_B)) gaussian_grad = np.resize(gaussian_grad, (gaussian_grad.shape[0]*gaussian_grad.shape[1], gaussian_grad.shape[2])) end = time.time() if (isTraining): print("Computed: gaussianGradFeatures_Tr in %f seconds" % (end-start)) # with open('gaussianGradFeatures_Tr.pkl','wb') as outfile: # pickle.dump(gaussian_grad, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianGradFeatures_Tr.csv", # gaussian_grad, delimiter=",") else: print("Computed: gaussianGradFeatures_Ts in %f seconds" % (end-start)) # with open('gaussianGradFeatures_Ts.pkl','wb') as outfile: # pickle.dump(gaussian_grad, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianGradFeatures_Ts.csv", # gaussian_grad, delimiter=",") All = np.concatenate((gaussianLF, eigenST, eigenHess, gaussian_grad),axis = 1) if (isTraining): path = path + '_Tr' np.savez_compressed(path, data = All) print("\nFINISHED: Structure Features for Training data\n") else: path = path + '_Ts' np.savez_compressed(path, data = All) print("\nFINISHED: Structure Features for Testing data\n")
def distort(imgae, config): """ 向图像中添加噪声 这个函数修改自gqcnn的源程序中,具体原理参考论文 """ imgae_ = imgae.copy() # config = self._config im_height = imgae_.shape[0] im_width = imgae_.shape[1] im_center = np.array([float(im_height-1)/2, float(im_width-1)/2]) # denoising and synthetic data generation if config['multiplicative_denoising']: gamma_shape = config['gamma_shape'] gamma_scale = 1.0 / gamma_shape mult_samples = ss.gamma.rvs(gamma_shape, scale=gamma_scale) imgae_ = imgae_ * mult_samples # randomly dropout regions of the image for robustness if config['image_dropout']: if np.random.rand() < config['image_dropout_rate']: nonzero_px = np.where(imgae_ > 0) nonzero_px = np.c_[nonzero_px[0], nonzero_px[1]] num_nonzero = nonzero_px.shape[0] num_dropout_regions = ss.poisson.rvs( config['dropout_poisson_mean']) # sample ellipses dropout_centers = np.random.choice( num_nonzero, size=num_dropout_regions) x_radii = ss.gamma.rvs( config['dropout_radius_shape'], scale=config['dropout_radius_scale'], size=num_dropout_regions) y_radii = ss.gamma.rvs( config['dropout_radius_shape'], scale=config['dropout_radius_scale'], size=num_dropout_regions) # set interior pixels to zero for j in range(num_dropout_regions): ind = dropout_centers[j] dropout_center = nonzero_px[ind, :] x_radius = x_radii[j] y_radius = y_radii[j] dropout_px_y, dropout_px_x = sd.ellipse( dropout_center[0], dropout_center[1], y_radius, x_radius, shape=imgae_.shape) imgae_[dropout_px_y, dropout_px_x] = 0.0 # dropout a region around the areas of the image with high gradient if config['gradient_dropout']: if np.random.rand() < config['gradient_dropout_rate']: grad_mag = sf.gaussian_gradient_magnitude( imgae_, sigma=config['gradient_dropout_sigma']) thresh = ss.gamma.rvs( config['gradient_dropout_shape'], config['gradient_dropout_scale'], size=1) high_gradient_px = np.where(grad_mag > thresh) imgae_[high_gradient_px[0], high_gradient_px[1]] = 0.0 # add correlated Gaussian noise if config['gaussian_process_denoising']: gp_rescale_factor = config['gaussian_process_scaling_factor'] gp_sample_height = int(im_height / gp_rescale_factor) gp_sample_width = int(im_width / gp_rescale_factor) gp_num_pix = gp_sample_height * gp_sample_width if np.random.rand() < config['gaussian_process_rate']: gp_noise = ss.norm.rvs(scale=config['gaussian_process_sigma'], size=gp_num_pix).reshape( gp_sample_height, gp_sample_width) # sm.imresize 有警告将被弃用 # gp_noise = sm.imresize( # gp_noise, gp_rescale_factor, interp='bicubic', mode='F') # st.resize 用来替用将被弃用的sm.imresize # gp_noise = st.resize(gp_noise, (im_height, im_width)) gp_noise = cv2.resize( gp_noise, (im_height, im_width), interpolation=cv2.INTER_CUBIC) imgae_[imgae_ > 0] += gp_noise[imgae_ > 0] # run open and close filters to if config['morphological']: sample = np.random.rand() morph_filter_dim = ss.poisson.rvs( config['morph_poisson_mean']) if sample < config['morph_open_rate']: imgae_ = snm.grey_opening( imgae_, size=morph_filter_dim) else: closed_imgae_ = snm.grey_closing( imgae_, size=morph_filter_dim) # set new closed pixels to the minimum depth, mimicing the table new_nonzero_px = np.where( (imgae_ == 0) & (closed_imgae_ > 0)) closed_imgae_[new_nonzero_px[0], new_nonzero_px[1]] = np.min( imgae_[imgae_ > 0]) imgae_ = closed_imgae_.copy() # randomly dropout borders of the image for robustness if config['border_distortion']: grad_mag = sf.gaussian_gradient_magnitude( imgae_, sigma=config['border_grad_sigma']) high_gradient_px = np.where( grad_mag > config['border_grad_thresh']) high_gradient_px = np.c_[ high_gradient_px[0], high_gradient_px[1]] num_nonzero = high_gradient_px.shape[0] num_dropout_regions = ss.poisson.rvs( config['border_poisson_mean']) # sample ellipses dropout_centers = np.random.choice( num_nonzero, size=num_dropout_regions) x_radii = ss.gamma.rvs( config['border_radius_shape'], scale=config['border_radius_scale'], size=num_dropout_regions) y_radii = ss.gamma.rvs( config['border_radius_shape'], scale=config['border_radius_scale'], size=num_dropout_regions) # set interior pixels to zero or one for j in range(num_dropout_regions): ind = dropout_centers[j] dropout_center = high_gradient_px[ind, :] x_radius = x_radii[j] y_radius = y_radii[j] dropout_px_y, dropout_px_x = sd.ellipse( dropout_center[0], dropout_center[1], y_radius, x_radius, shape=imgae_.shape) if np.random.rand() < 0.5: imgae_[dropout_px_y, dropout_px_x] = 0.0 else: imgae_[dropout_px_y, dropout_px_x] = imgae_[ dropout_center[0], dropout_center[1]] # randomly replace background pixels with constant depth if config['background_denoising']: if np.random.rand() < config['background_rate']: imgae_[imgae_ > 0] = config['background_min_depth'] + ( config['background_max_depth'] - config['background_min_depth']) * np.random.rand() # symmetrize images if config['symmetrize']: # rotate with 50% probability if np.random.rand() < 0.5: theta = 180.0 rot_map = cv2.getRotationMatrix2D( tuple(im_center), theta, 1) imgae_ = cv2.warpAffine( imgae_, rot_map, (im_height, im_width), flags=cv2.INTER_NEAREST) # reflect left right with 50% probability if np.random.rand() < 0.5: imgae_ = np.fliplr(imgae_) # reflect up down with 50% probability if np.random.rand() < 0.5: imgae_ = np.flipud(imgae_) return imgae_
def nuclei_active_region_segmentation(input_img, positions, omega_energies=dict(intensity=1.0, gradient=1.5, smoothness=10000.0), intensity_min=20000., iterations=10, display=False): """ 3D extension of the multiple region extension of the binary level set implementation """ segmentation_start_time = time() print "--> Active region segmentation (", len(positions), " regions )" from copy import deepcopy reference_img = deepcopy(input_img) size = np.array(reference_img.shape) voxelsize = np.array(reference_img.voxelsize) if display: from openalea.core.world import World world = World() if omega_energies.has_key('gradient'): from scipy.ndimage.filters import gaussian_gradient_magnitude start_time = time() print " --> Computing image gradient" gradient = gaussian_gradient_magnitude( np.array(reference_img, np.float64), sigma=0.5 / np.array(reference_img.voxelsize)) gradient_img = SpatialImage(np.array(gradient, np.uint16), voxelsize=reference_img.voxelsize) end_time = time() print " <-- Computing image gradient [", end_time - start_time, " s]" start_time = time() print " --> Creating seed image" print positions.keys() seed_img = seed_image_from_points(size, voxelsize, positions, point_radius=1.0) regions_img = np.copy(seed_img) end_time = time() print " <-- Creating seed image (", len(np.unique( regions_img)) - 1, " regions ) [", end_time - start_time, " s]" if display: world.add(seed_img, 'active_regions_seeds', colormap='glasbey', voxelsize=voxelsize, alphamap='constant', volume=False, cut_planes=True) raw_input() for iteration in xrange(iterations): start_time = time() print " --> Active region energy gradient descent : iteration", iteration, " (", len( np.unique(regions_img)) - 1, " regions )" previous_regions_img = np.copy(regions_img) regions_img = active_regions_energy_gradient_descent( regions_img, reference_img, omega_energies=omega_energies, intensity_min=intensity_min, gradient_img=gradient) change = ((regions_img - previous_regions_img) != 0.).sum() / float( (regions_img > 1.).sum()) end_time = time() print " --> Active region energy gradient descent : iteration", iteration, " (Evolution : ", int( 100 * change), " %) ", "[", end_time - start_time, " s]" if display: world.add(regions_img, 'active_regions', colormap='invert_grey', voxelsize=voxelsize, intensity_range=(1, 2)) segmented_img = SpatialImage(regions_img, voxelsize=reference_img.voxelsize) if display: world.add(segmented_img, 'active_regions', colormap='glasbey', voxelsize=voxelsize, alphamap='constant') raw_input() segmentation_end_time = time() print "<-- Active region segmentation (", len( np.unique(segmented_img) ) - 1, " regions ) [", segmentation_end_time - segmentation_start_time, " s]" return segmented_img