def sharpen(Xs,ys,sigma1=3,sigma2=1,alpha=30,ratio=0.6,t=None): print "sharpening images..." if ratio > 1.0: print "Do you really want a ratio of %f for sharpen?" % ratio print "Every images produced will always be similar" rand_list = randomindex(Xs.shape[0]*ratio,Xs.shape[0]) Xs = Xs[rand_list] ys = ys[rand_list] tx = [] ty = [] for X, y in zip(Xs,ys): blurred_l = ndimage.gaussian_filter(X, sigma1) filter_blurred_l = ndimage.gaussian_filter(blurred_l, sigma2) sharpened = blurred_l + alpha * (blurred_l - filter_blurred_l) tx.append(sharpened) ty.append(y) if t: t.print_update(1) return np.array(tx), np.array(ty)
def _compute_auto_correlation(image, sigma): """Compute auto-correlation matrix using sum of squared differences. Parameters ---------- image : ndarray Input image. sigma : float Standard deviation used for the Gaussian kernel, which is used as weighting function for the auto-correlation matrix. Returns ------- Axx : ndarray Element of the auto-correlation matrix for each pixel in input image. Axy : ndarray Element of the auto-correlation matrix for each pixel in input image. Ayy : ndarray Element of the auto-correlation matrix for each pixel in input image. """ if image.ndim == 3: image = img_as_float(rgb2grey(image)) imx, imy = _compute_derivatives(image) # structure tensore Axx = ndimage.gaussian_filter(imx * imx, sigma, mode='constant', cval=0) Axy = ndimage.gaussian_filter(imx * imy, sigma, mode='constant', cval=0) Ayy = ndimage.gaussian_filter(imy * imy, sigma, mode='constant', cval=0) return Axx, Axy, Ayy
def roysam_watershed(dna,thresh=None,blur_factor=3): ''' Run watershed on mixed gradient & intensity image as suggested by Lin et al. -Input dna: DNA image thresh: Gray value threshold (default: computed using Murphy's RC) blur_factor: Blur factor (default: 3) REFERENCE Gang Lin, Umesh Adiga, Kathy Olson, John F. Guzowski, Carol A. Barnes, and Badrinath Roysam "A Hybrid 3-D Watershed Algorithm Incorporating Gradient Cues & Object Models for Automatic Segmentation of Nuclei in Confocal Image Stacks" Vol. 56A, No. 1, pp. 23-36 Cytometry Part A, November 2003. ''' if thresh is None: thresh = 'murphy_rc' M = (ndimage.gaussian_filter(dna,4) > thresholding.threshold(dna,thresh)) G = pymorph.gradm(dna) D = ndimage.distance_transform_edt(M) D *= np.exp(1-G/float(G.max())) T = ndimage.gaussian_filter(D.max() - D,blur_factor) if T.max() < 256: T = pymorph.to_uint8(T) else: T = pymorph.to_uint8(T*(256.0/T.max())) T *= M R = pymorph.regmin(T) R *= M R,N = ndimage.label(R) R[(R==0)&(M==0)] = N+1 W,WL = mahotas.cwatershed(T,R,return_lines=True) W *= M return W,WL
def whiten(image): #return image tmp = image - image.mean() return tmp / numpy.std(tmp) if image.ndim > 3: raise TypeError('Not more than 3 dimensions supported') if image.ndim == 3: tmp = numpy.empty_like(image) for c in range(image.shape[2]): tmp[:, :, c] = whiten(image[:, :, c]) result = numpy.zeros_like(image) for c1 in range(image.shape[2]): for c2 in range(image.shape[2]): if c1 == c2: result[:, :, c1] += tmp[:, :, c2] else: result[:, :, c1] -= tmp[:, :, c2] return result sigma1 = 0.2 img1 = ndimage.gaussian_filter(image, sigma1) sigma2 = 5 * sigma1 img2 = ndimage.gaussian_filter(image, sigma2) result = img1 - img2 return result
def test_multiple_modes(): # Test that the filters with multiple mode cababilities for different # dimensions give the same result as applying a single mode. arr = np.array([[1., 0., 0.], [1., 1., 0.], [0., 0., 0.]]) mode1 = 'reflect' mode2 = ['reflect', 'reflect'] assert_equal(sndi.gaussian_filter(arr, 1, mode=mode1), sndi.gaussian_filter(arr, 1, mode=mode2)) assert_equal(sndi.prewitt(arr, mode=mode1), sndi.prewitt(arr, mode=mode2)) assert_equal(sndi.sobel(arr, mode=mode1), sndi.sobel(arr, mode=mode2)) assert_equal(sndi.laplace(arr, mode=mode1), sndi.laplace(arr, mode=mode2)) assert_equal(sndi.gaussian_laplace(arr, 1, mode=mode1), sndi.gaussian_laplace(arr, 1, mode=mode2)) assert_equal(sndi.maximum_filter(arr, size=5, mode=mode1), sndi.maximum_filter(arr, size=5, mode=mode2)) assert_equal(sndi.minimum_filter(arr, size=5, mode=mode1), sndi.minimum_filter(arr, size=5, mode=mode2)) assert_equal(sndi.gaussian_gradient_magnitude(arr, 1, mode=mode1), sndi.gaussian_gradient_magnitude(arr, 1, mode=mode2)) assert_equal(sndi.uniform_filter(arr, 5, mode=mode1), sndi.uniform_filter(arr, 5, mode=mode2))
def test_gaussian_filter(): # Test gaussian filter with np.float16 # gh-8207 data = np.array([1],dtype = np.float16) sigma = 1.0 with assert_raises(RuntimeError): sndi.gaussian_filter(data,sigma)
def gaussian_filter(image,sigma,derivative_sequence=None): if( derivative_sequence != None and numpy.array(derivative_sequence).any() ): array = image.getArray(data.image_types.FLOAT) return data.Image(ndimage.gaussian_filter(array,sigma,order=derivative_sequence),image) else: array = image.getArray() return data.Image(ndimage.gaussian_filter(array,sigma,order=derivative_sequence),image)
def mkData(): global data, cache, ui dtype = (ui.dtypeCombo.currentText(), ui.rgbCheck.isChecked()) if dtype not in cache: if dtype[0] == 'uint8': dt = np.uint8 loc = 128 scale = 64 mx = 255 elif dtype[0] == 'uint16': dt = np.uint16 loc = 4096 scale = 1024 mx = 2**16 elif dtype[0] == 'float': dt = np.float loc = 1.0 scale = 0.1 if ui.rgbCheck.isChecked(): data = np.random.normal(size=(20,512,512,3), loc=loc, scale=scale) data = ndi.gaussian_filter(data, (0, 6, 6, 0)) else: data = np.random.normal(size=(20,512,512), loc=loc, scale=scale) data = ndi.gaussian_filter(data, (0, 6, 6)) if dtype[0] != 'float': data = np.clip(data, 0, mx) data = data.astype(dt) cache[dtype] = data data = cache[dtype] updateLUT()
def gmm_fit_kb(data_raw, init_sigma): data = np.copy(data_raw) data_smooth_b = gaussian_filter(data, 10) B_e_x = data_smooth_b.mean() data_smooth_s = gaussian_filter(data, 1) sort_indexes = data_smooth_s.argsort() data[data < B_e_x] = B_e_x data = data - B_e_x data[data < 0] = 0 bin_centres_x = np.array(list(range(0, len(data_raw)))) sub_bin_centres_x = np.linspace(0, len(data_raw), 2 * len(data_raw)) Mu_e_x_1 = sort_indexes[0] A_e_x_1 = data[Mu_e_x_1] Sigma_e_x_1 = np.abs(init_sigma) Mu_e_x_2 = sort_indexes[1] A_e_x_2 = data[Mu_e_x_2] Sigma_e_x_2 = np.abs(init_sigma) p0_x = np.array([A_e_x_1, Mu_e_x_1, Sigma_e_x_1, A_e_x_2, Mu_e_x_2, Sigma_e_x_2]) opt_fun = lambda x, *p: p[0] * np.exp(-(x - p[1]) ** 2 / (2. * p[2] ** 2)) + p[ 3 ] * np.exp(-(x - p[4]) ** 2 / (2. * p[5] ** 2)) try: coeff_x, var_matrix_x = curve_fit(opt_fun, bin_centres_x, data, p0=p0_x) except RuntimeError: print("optimal parameters not found") coeff_x = p0_x data_fit = opt_fun(sub_bin_centres_x, *coeff_x) print("Fit centromere position (bp) = ", (coeff_x[1] + coeff_x[4]) / 2.) print("Fit std 1 = ", coeff_x[2]) print("Fit std 2 = ", coeff_x[5]) return coeff_x, data_fit, sub_bin_centres_x, data
def _process(self, img): for c in xrange(3): channel = img[:, :, c] gaussian_filter(channel, output=channel, sigma=self._sigma) img[:, :, c] = channel return img
def __init__(self, sigma, mode="wrap"): self.sigma = sigma self.mode = mode size = 1 + 2 * int(round(3 * self.sigma)) # шесть сигм ) self.kernel = np.zeros(size, np.float64) self.kernel[size // 2] = 1. ndimage.gaussian_filter(self.kernel, self.sigma, mode="constant", output=self.kernel)
def smooth_corrected(z, mask, w_smooth): mask1=snd.gaussian_filter(np.float32(mask), w_smooth, mode="constant", cval=0) ztemp=np.nan_to_num(z) ztemp[mask==0]=0.0 zs=snd.gaussian_filter(ztemp, w_smooth, mode="constant", cval=0) zs[mask1>0]=zs[mask1>0]/mask1[mask1>0] return zs, mask1
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 loss(self, H): if not hasattr(self, 'sigma'): self.sigma = .05*np.array(H.shape) npts = nonzero(self.npoints(H)) Hs = H/npts gaussian_filter(Hs, sigma=self.sigma, mode='constant', output=Hs) return dist2loss(Hs)
def __init__(self, location, fig, ax): self.location = location self.fig = fig self.ax = ax # get alignment data for given location # try: self.afm_data_exists = 1 self.afm_data = afm_alignment_data(location) except IOError: self.afm_data_exists = 0 if self.afm_data_exists: # smooth data # self.afm_data.amplitude = ndimage.gaussian_filter(self.afm_data.amplitude, 0.7) self.afm_data.phase = ndimage.gaussian_filter(self.afm_data.phase, 0.7) # make afm data subplots # gs = gridspec.GridSpecFromSubplotSpec(1, 2, self.ax.get_subplotspec(), wspace=0.3) r_ax = plt.subplot(gs[0]) theta_ax = plt.subplot(gs[1]) # plot on subplot axes # self.add_alignment_subplot(self.afm_data.amplitude, r_ax, x=None, y=None, name='$r$') self.add_alignment_subplot(self.afm_data.phase, theta_ax, x=None, y=None, name=r'$\theta$') for tl in theta_ax.get_yticklabels(): tl.set_visible(False) r_ax.set_ylabel('y position (nm)') r_ax.set_xlabel('x position (nm)')
def density_to_sim_data(density, out=None): """ Takes a 2D image input, returns a 4D SIM dataset output """ if out == None: sim_data = np.zeros( (num_rotations, num_phases) + density.shape, dtype=np.float64) else: sim_data = out """ Construct the illumination pattern """ illumination = generate_illumination(density) sim_data_to_visualization(illumination, 'illumination.tif') """ Simulate the imaging process: multiply by the illumination, and blur """ for t in range(num_rotations): for p in range(num_phases): sim_data[t, p, :, :] = illumination[t, p, :, :] * density gaussian_filter(sim_data[t, p, :, :], sigma=emission_sigma, output=sim_data[t, p, :, :]) return sim_data
def rgb2grey(imgrgb): imgrey = np.zeros((imgrgb.shape[0],imgrgb.shape[1]), dtype=np.uint8) for i in range(imgrgb.shape[0]): for j in range(imgrgb.shape[1]): imgrey[i,j] = (imgrgb[i,j,0] /3 + imgrgb[i,j,1] /3 + imgrgb[i,j,2]/3) ndimage.gaussian_filter(l2, sigma=5) return imgrey
def PlotProfile(label1, label2, data1, data2, filename, smooth, binsz): plt.clf() plt.figure(figsize=(5,4)) plt.rc('text', usetex=True) plt.rc('font', family='serif') counts1 = np.append(data1['FLUX'].data/(EXPOSURE*PIXEL_SA), 0) glats1 = np.append(data1['GLAT_MIN'][0], data1['GLAT_MAX'].data) profile1 = np.histogram(glats1, bins=np.sort(glats1), weights=counts1) xstep=binsz y_smooth_1 = gaussian_filter(profile1[0], smooth / xstep) print y_smooth_1.mean() counts2 = np.append(data2['FLUX'].data/(EXPOSURE*PIXEL_SA*(data2['FLUX'].data.size())), 0) glats2 = np.append(data2['GLAT_MIN'][0], data2['GLAT_MAX'].data) profile2 = np.histogram(glats2, bins=np.sort(glats2), weights=counts2) xstep=binsz y_smooth_2 = gaussian_filter(profile2[0], smooth / xstep) print y_smooth_2.mean() x1 = 0.5 * (glats1[1:] + glats1[:-1]) plt.plot(x1, y_smooth_1, label='{0}'.format(label1)) plt.plot(x1, y_smooth_2, label='{0}'.format(label2)) plt.hlines(0, LatLow+binsz, LatHigh-binsz) plt.xlabel(r'Galactic Latitude/$deg$', fontsize=10) plt.ylabel(r'Surface Brightness/ph cm$^{-2}$ s$^{-1} sr^{-1}$', fontsize=10) plt.xlim([LatLow+binsz, LatHigh-binsz]) plt.tick_params(axis='x', labelsize=10) plt.grid(b=True, which='major', color='0.75', linewidth=0.5) plt.legend(prop={'size':8}) plt.savefig(filename)
def LocalSNR(self,pSrc, sigma,bksigma = None, uiobject=None): """ Local SNR: [ mean(x,y) ]/stdev(x,y) Can be approximated as [ Gauss{I,sigma}] / sqrt[ Gauss{I-Gauss{I,sigma},sigma}^2] """ if uiobject: uiobject.pbar.startProgress(3,"Calculating LocSNR") blurIm = scind.gaussian_filter(pSrc,sigma,order=[0,0]) if uiobject: print "[LocalSNR] 1/4 blur'd" devIm = pSrc-blurIm if uiobject: uiobject.pbar.doProgress("dev'd") print "[LocalSNR] 2/4 dev'd" sdIm = np.sqrt(scind.gaussian_filter(devIm**2,sigma,order=[0,0])) sdIm[sdIm<1.e-6]=1. # prevent div by zero if uiobject: uiobject.pbar.doProgress("std'd") print "[LocalSNR] 3/4 std'd" locnormIm = blurIm/sdIm if uiobject: print "[LocalSNR] 4/4 snr'd" if bksigma is not None: blurIm = scind.gaussian_filter(locnormIm,bksigma,order=[0,0]) locnormIm -= blurIm if uiobject: print "[LocalSNR] 5/4 trend removed" if uiobject: uiobject.pbar.endProgress() # blurIm = scind.gaussian_filter(locnormIm,sigma,order=[2,0])**2+scind.gaussian_filter(locnormIm,sigma,order=[0,2])**2 # return blurIm return locnormIm
def process_frames(self, data): if len(data[0].shape)>2: sino = np.mean(data[0],axis=1) else: sino = data[0] (nrow, ncol) = sino.shape dsp_row = 1 dsp_col = 1 if ncol>2000: dsp_col = 4 if nrow>2000: dsp_row = 2 # Denoising # There's a critical reason to use different window sizes # between coarse and fine search. sino_csearch = ndi.gaussian_filter(sino, (3,1), mode='reflect') sino_fsearch = ndi.gaussian_filter(sino, (2,2), mode='reflect') sino_dsp = self._downsample(sino_csearch, dsp_row, dsp_col) fine_srange = max(self.search_radius, dsp_col) off_set = 0.5*dsp_col if dsp_col>1 else 0.0 if self.est_cor is None: self.est_cor = (ncol-1.0)/2.0 else: self.est_cor = np.float32(self.est_cor) start_cor = np.int16( np.floor(1.0 * (self.est_cor + self.smin) / dsp_col)) stop_cor = np.int16( np.ceil(1.0 * (self.est_cor + self.smax) / dsp_col)) raw_cor = self._coarse_search(sino_dsp, start_cor, stop_cor, self.ratio, self.drop) cor = self._fine_search( sino_fsearch, raw_cor*dsp_col + off_set, fine_srange, self.search_step, self.ratio, self.drop) return [np.array([cor]), np.array([cor])]
def __sharpner(self, image_data): blurred_f = ndimage.gaussian_filter(image_data, 3) filter_blurred_f = ndimage.gaussian_filter(blurred_f, 1) alpha = 30 image_sharpened = blurred_f + alpha * (blurred_f - filter_blurred_f) return image_sharpened
def faceNorm(im, contrast = 0.2) : """ Calculates a lighting neutral image Input: im [numpy.ndarray] Image in whatever format Output: [numpy.ndarray] UINT version of image """ alpha = 0.1 tau = 10.0 gamma = 0.2 sigma1 = 1.0 sigma2 = 3.0 im = stretch(im) c = ndimage.gaussian_filter(im, sigma1) s = ndimage.gaussian_filter(im, sigma2) q = numpy.asarray(c - s) w = numpy.asarray(c+s+0.000001) nDoG = q/w A = contrast # The smaller the greater the enhancement B = 1 w = nDoG*(A+B) ww = numpy.abs(nDoG)+A cenDoG = w/ww return toUInt(cenDoG)
def _plot_path_energy(self, experiment_results): Tmax = 6000 for repetition in experiment_results: nodes = experiment_results.nodes_have_metric("routeEnergy") for node in nodes: data = experiment_results.get_tuple_metric_per_node("routeEnergy", node, repetition) T = [float(pair[0]) for pair in data] R = [float(pair[1]) for pair in data] bw = 0.5 trange = [0, Tmax] bins = 5000 dx = (trange[1] - trange[0]) / bins # compute sum_i K(x - x_i) y_i hist_R, edges = np.histogram(T, range=trange, bins=bins, weights=R) kde_R = gaussian_filter(hist_R, bw / dx) # compute sum_i K(x - x_i) hist_T, edges = np.histogram(T, range=trange, bins=bins) kde_T = gaussian_filter(hist_T, bw / dx) # compute the Nadaraya-Watson estimate interpolated_R = kde_R / kde_T # computer x-axis domain = (edges[1:] + edges[:-1]) / 2.0 if self.draw: plt.plot(domain, interpolated_R) file_name = "alternative_path-energy_node-" + str(node) plt.savefig(os.path.join(self.location, self.scenario + "_" + file_name + ".png")) plt.close()
def preproc_dog(bg): """test low level image filter """ #special dependencies from scipy.ndimage import gaussian_filter from pyrankfilter import rankfilter,__version__ bg = bg.astype(float) f1 = gaussian_filter(bg,sigma=14.5) f2 = gaussian_filter(bg,sigma=15) f = ((f1-f2+3)*10).astype('uint8') loc_max = rankfilter(f,'highest',20,infSup=[0,0]) r = bg.copy() r[loc_max>0]=0 plt.figure() plt.subplot(2,2,1) plt.imshow(bg) plt.subplot(2,2,2) plt.imshow(f) plt.colorbar() plt.subplot(2,2,3) plt.imshow(loc_max) plt.subplot(2,2,4) plt.imshow(r) plt.show()
def blur_image(img): '''Return the blurred image that's used when sampling''' blur = np.zeros(list(img.shape)+[2], img.dtype) for z in range(img.shape[2]): blur[:,:,z, 0] = laplace(gaussian_filter(img[:,:,z], 3)) blur[:,:,z, 1] = gaussian_filter(img[:,:,z], 5) return blur
def tantriggs(self, x, alpha=0.1,gamma=0.2,sigma0=1,sigma1=2,tau=10.0): x = np.array(x, dtype=np.float32) x = np.power(x, gamma) s0 = 3*sigma0 s1 = 3*sigma1 if ((s0%2)==0): s0+=1 if ((s1%2)==0): s1+=1 x = np.asarray( ndimage.gaussian_filter(x, sigma0) - ndimage.gaussian_filter(x, sigma1) ) x = x / np.power( np.mean(np.power(np.abs(x), alpha)), 1.0 / alpha ) x = x / np.power( np.mean( np.power( np.minimum(np.abs(x), tau), alpha ) ), 1.0 / alpha ) x = np.tanh(x / tau) * tau x = cv2.normalize(x,x,-220,0,cv2.NORM_MINMAX) return np.array(x, np.uint8)
def generate_surface_from_stack(stack, sd=(10, 10, 10), surface_blur_sd=5): """Return a 2D image encoding a height map, generated from the input stack. The image is generated by first blurring the stack, then taking the z index of the brightest point for each X, Y location. The resultant surface is then smoothed with a gaussian filter. sd: standard deviation in each direction surface_blur_sd: standard deviation of smoothing applied to 2D surface.""" ydim, xdim, zdim = stack.shape pad_val = 5 padding = pad_val * 2 padded_stack = np.zeros((ydim + padding, xdim + padding, zdim + padding), dtype=stack.dtype) start = pad_val end_add = pad_val padded_stack[start:ydim+end_add, start:xdim+end_add, start:zdim+end_add] = stack smoothed_stack = nd.gaussian_filter(padded_stack, sd) cropped_stack = smoothed_stack[start:ydim+end_add, start:xdim+end_add, start:zdim+end_add] raw_surface = np.argmax(cropped_stack, 2) raw_surface[np.logical_and(raw_surface==0, cropped_stack[:,:,0] == 0)] = zdim-1 smoothed_surface = nd.gaussian_filter(raw_surface, surface_blur_sd) return smoothed_surface
def get_M(self, X, mode='reflect', cval=0.): '''Get the Harris-Laplace scale-adapted second moment matrix''' # Compute the gaussian smoothed image # N.B.: using ndimage for speed; could replace with gaussian filter # class above G = ndimage.gaussian_filter(X, self.sigma_d, mode=mode, cval=cval) # Compute derivatives of gaussian-smoothed image in x and y directions Lx, Ly = self.get_grads_xy(G, mode=mode, cval=cval) # Compute second derivatives from first derivatives in x and y # directions Lxx, Lxy = self.get_grads_xy(Lx, mode=mode, cval=cval) _, Lyy = self.get_grads_xy(Ly, mode=mode, cval=cval) # Convolve each second derivative matrix with the integration gaussian # N.B.: using ndimage for speed; could replace with gaussian filter # class above Lxx = ndimage.gaussian_filter(Lxx, self.sigma_i, mode=mode, cval=cval) Lxy = ndimage.gaussian_filter(Lxy, self.sigma_i, mode=mode, cval=cval) Lyy = ndimage.gaussian_filter(Lyy, self.sigma_i, mode=mode, cval=cval) # Get an empty matrix and store the second derivatives M = np.empty((*X.shape, 2, 2)) M[:, :, 0, 0] = Lxx M[:, :, 1, 0] = Lxy M[:, :, 0, 1] = Lxy M[:, :, 1, 1] = Lyy # Apply scale correction M = (self.sigma_d ** 2.) * M return M
def nan_gaussian_filter(X, sigma, keep_nans=False, gf_kwargs=dict()): """Equivalent to scipy.ndimage.gaussian_filter, but allows NaNs For inputs see original function if keep_nans is True, then output has NaNs everywhere input had nans http://stackoverflow.com/questions/18697532/ gaussian-filtering-a-image-with-nan-in-python""" nanX = np.isnan(X) X1 = X.copy() X1[nanX] = 0 X1_filtered = gaussian_filter(X1, sigma, **gf_kwargs) X2 = np.ones_like(X) X2[nanX] = 0 X2_filtered = gaussian_filter(X2, sigma, **gf_kwargs) out = X1_filtered/X2_filtered if keep_nans: out[nanX] = np.nan return out
def compute_harris_response(image, eps=1e-6): """ compute the Harris corner detector response function for each pixel in the image""" # derivatives image = ndimage.gaussian_filter(image, 1) imx = ndimage.sobel(image, axis=0, mode='constant') imy = ndimage.sobel(image, axis=1, mode='constant') Wxx = ndimage.gaussian_filter(imx * imx, 1.5, mode='constant') Wxy = ndimage.gaussian_filter(imx * imy, 1.5, mode='constant') Wyy = ndimage.gaussian_filter(imy * imy, 1.5, mode='constant') # determinant and trace Wdet = Wxx * Wyy - Wxy ** 2 Wtr = Wxx + Wyy harris = Wdet / (Wtr + eps) # Non maximum filter of size 3 harris_max = ndimage.maximum_filter(harris, 3, mode='constant') harris *= harris == harris_max # Remove the image corners harris[:3] = 0 harris[-3:] = 0 harris[:, :3] = 0 harris[:, -3:] = 0 return harris
def filter_(z, n): from scipy.ndimage import gaussian_filter return gaussian_filter(z, n)
def augment_gaussian_filt_2d(iq_mat, label): iq_mat = gaussian_filter(iq_mat, sigma=1) return iq_mat, label
def filter(original_images, transformation): """ :param original_images: :param transformation: :return: """ nb_images, img_rows, img_cols, nb_channels = original_images.shape transformed_images = [] if (transformation == TRANSFORMATION.filter_sobel): for img in original_images: if (nb_channels == 3): img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) img = img.reshape(img_rows, img_cols) img_trans = filters.sobel(img) if (nb_channels == 3): img_trans = cv2.cvtColor(img_trans, cv2.COLOR_GRAY2RGB) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_median): for img in original_images: img_trans = ndimage.median_filter(img, size=3) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_minimum): for img in original_images: img_trans = ndimage.minimum_filter(img, size=3) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_maximum): for img in original_images: img_trans = ndimage.maximum_filter(img, size=3) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_gaussian): for img in original_images: img_trans = ndimage.gaussian_filter(img, sigma=1) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_rank): for img in original_images: img_trans = ndimage.rank_filter(img, rank=15, size=3) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_entropy): for img in original_images: radius = 2 if (nb_channels == 3): radius = 1 img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) img = img.reshape(img_rows, img_cols) """ requires values in range [-1., 1.] """ img = (img - 0.5) * 2. """ skimage-entropy function returns values in float64, however opencv only supports float32. """ img_trans = np.float32( filters.rank.entropy(img, disk(radius=radius))) """ rescale back into range [0., 1.] """ img_trans = (img_trans / 2.) + 0.5 if (nb_channels == 3): img_trans = cv2.cvtColor(img_trans, cv2.COLOR_GRAY2RGB) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_roberts): for img in original_images: if (nb_channels == 3): img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) img = img.reshape(img_rows, img_cols) img_trans = roberts(img) if (nb_channels == 3): img_trans = cv2.cvtColor(img_trans, cv2.COLOR_GRAY2RGB) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_scharr): for img in original_images: if (nb_channels == 3): img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) img = img.reshape(img_rows, img_cols) img_trans = scharr(img) if (nb_channels == 3): img_trans = cv2.cvtColor(img_trans, cv2.COLOR_GRAY2RGB) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_prewitt): for img in original_images: if (nb_channels == 3): img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) img = img.reshape(img_rows, img_cols) img_trans = prewitt(img) if (nb_channels == 3): img_trans = cv2.cvtColor(img_trans, cv2.COLOR_GRAY2RGB) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_meijering): for img in original_images: if nb_channels == 1: img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) img_trans = meijering(img, sigmas=[0.01]) if nb_channels == 1: img_trans = img_trans[:, :, 1] transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_sato): for img in original_images: img_trans = sato(img) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_frangi): for img in original_images: img_trans = frangi(img) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_hessian): for img in original_images: img_trans = hessian(img) transformed_images.append(img_trans) elif (transformation == TRANSFORMATION.filter_skeletonize): for img in original_images: img = invert(img) img = img.reshape((img_rows, img_cols)) img = skeletonize(img) transformed_images.append(img) elif (transformation == TRANSFORMATION.filter_thin): for img in original_images: img = img.reshape(img_rows, img_cols) img = thin(img, max_iter=100) transformed_images.append(img) else: raise ValueError('{} is not supported.'.format(transformation)) transformed_images = np.stack(transformed_images, axis=0) if (nb_channels == 1): # reshape a 3d to a 4d transformed_images = transformed_images.reshape( (nb_images, img_rows, img_cols, nb_channels)) return transformed_images
def slic(image, n_segments=100, compactness=10., max_iter=10, sigma=0, spacing=None, multichannel=True, convert2lab=None, enforce_connectivity=False, min_size_factor=0.5, max_size_factor=3, slic_zero=False): """Segments image using k-means clustering in Color-(x,y,z) space. Parameters ---------- image : 2D, 3D or 4D ndarray Input image, which can be 2D or 3D, and grayscale or multichannel (see `multichannel` parameter). n_segments : int, optional The (approximate) number of labels in the segmented output image. compactness : float, optional Balances color-space proximity and image-space proximity. Higher values give more weight to image-space. As `compactness` tends to infinity, superpixel shapes become square/cubic. In SLICO mode, this is the initial compactness. max_iter : int, optional Maximum number of iterations of k-means. sigma : float or (3,) array-like of floats, optional Width of Gaussian smoothing kernel for pre-processing for each dimension of the image. The same sigma is applied to each dimension in case of a scalar value. Zero means no smoothing. Note, that `sigma` is automatically scaled if it is scalar and a manual voxel spacing is provided (see Notes section). spacing : (3,) array-like of floats, optional The voxel spacing along each image dimension. By default, `slic` assumes uniform spacing (same voxel resolution along z, y and x). This parameter controls the weights of the distances along z, y, and x during k-means clustering. multichannel : bool, optional Whether the last axis of the image is to be interpreted as multiple channels or another spatial dimension. convert2lab : bool, optional Whether the input should be converted to Lab colorspace prior to segmentation. The input image *must* be RGB. Highly recommended. This option defaults to ``True`` when ``multichannel=True`` *and* ``image.shape[-1] == 3``. enforce_connectivity: bool, optional (default False) Whether the generated segments are connected or not min_size_factor: float, optional Proportion of the minimum segment size to be removed with respect to the supposed segment size ```depth*width*height/n_segments``` max_size_factor: float, optional Proportion of the maximum connected segment size. A value of 3 works in most of the cases. slic_zero: bool, optional Run SLIC-zero, the zero-parameter mode of SLIC. [2]_ Returns ------- labels : 2D or 3D array Integer mask indicating segment labels. Raises ------ ValueError If ``convert2lab`` is set to ``True`` but the last array dimension is not of length 3. Notes ----- * If `sigma > 0`, the image is smoothed using a Gaussian kernel prior to segmentation. * If `sigma` is scalar and `spacing` is provided, the kernel width is divided along each dimension by the spacing. For example, if ``sigma=1`` and ``spacing=[5, 1, 1]``, the effective `sigma` is ``[0.2, 1, 1]``. This ensures sensible smoothing for anisotropic images. * The image is rescaled to be in [0, 1] prior to processing. * Images of shape (M, N, 3) are interpreted as 2D RGB images by default. To interpret them as 3D with the last dimension having length 3, use `multichannel=False`. References ---------- .. [1] Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua, and Sabine Süsstrunk, SLIC Superpixels Compared to State-of-the-art Superpixel Methods, TPAMI, May 2012. .. [2] http://ivrg.epfl.ch/research/superpixels#SLICO Examples -------- >>> from skimage.segmentation import slic >>> from skimage.data import astronaut >>> img = astronaut() >>> segments = slic(img, n_segments=100, compactness=10) Increasing the compactness parameter yields more square regions: >>> segments = slic(img, n_segments=100, compactness=20) """ if enforce_connectivity is None: warnings.warn('Deprecation: enforce_connectivity will default to' ' True in future versions.') enforce_connectivity = False image = img_as_float(image) is_2d = False if image.ndim == 2: # 2D grayscale image image = image[np.newaxis, ..., np.newaxis] is_2d = True elif image.ndim == 3 and multichannel: # Make 2D multichannel image 3D with depth = 1 image = image[np.newaxis, ...] is_2d = True elif image.ndim == 3 and not multichannel: # Add channel as single last dimension image = image[..., np.newaxis] if spacing is None: spacing = np.ones(3) elif isinstance(spacing, (list, tuple)): spacing = np.array(spacing, dtype=np.double) if not isinstance(sigma, coll.Iterable): sigma = np.array([sigma, sigma, sigma], dtype=np.double) sigma /= spacing.astype(np.double) elif isinstance(sigma, (list, tuple)): sigma = np.array(sigma, dtype=np.double) if (sigma > 0).any(): # add zero smoothing for multichannel dimension sigma = list(sigma) + [0] image = ndi.gaussian_filter(image, sigma) if multichannel and (convert2lab or convert2lab is None): if image.shape[-1] != 3 and convert2lab: raise ValueError("Lab colorspace conversion requires a RGB image.") elif image.shape[-1] == 3: image = rgb2lab(image) depth, height, width = image.shape[:3] # initialize cluster centroids for desired number of segments grid_z, grid_y, grid_x = np.mgrid[:depth, :height, :width] slices = regular_grid(image.shape[:3], n_segments) step_z, step_y, step_x = [int(s.step) for s in slices] segments_z = grid_z[slices] segments_y = grid_y[slices] segments_x = grid_x[slices] segments_color = np.zeros(segments_z.shape + (image.shape[3],)) segments = np.concatenate([segments_z[..., np.newaxis], segments_y[..., np.newaxis], segments_x[..., np.newaxis], segments_color], axis=-1).reshape(-1, 3 + image.shape[3]) segments = np.ascontiguousarray(segments) # we do the scaling of ratio in the same way as in the SLIC paper # so the values have the same meaning step = float(max((step_z, step_y, step_x))) ratio = 1.0 / compactness image = np.ascontiguousarray(image * ratio) labels = _slic_cython(image, segments, step, max_iter, spacing, slic_zero) if enforce_connectivity: segment_size = depth * height * width / n_segments min_size = int(min_size_factor * segment_size) max_size = int(max_size_factor * segment_size) labels = _enforce_label_connectivity_cython(labels, n_segments, min_size, max_size) if is_2d: labels = labels[0] return labels
import numpy as np import scipy.ndimage as ndi import matplotlib.pyplot as plt img = np.zeros((516, 516)) img[128:-128, 128:-128] = 1 img = ndi.gaussian_filter(img, 8) rotated = ndi.rotate(img, -20) noisy = rotated + 0.09 * np.random.random(rotated.shape) sx = ndi.sobel(noisy, axis=0) sy = ndi.sobel(noisy, axis=1) sob = np.hypot(sx, sy) titles = ['Original', 'Rotated', 'Noisy', 'Sobel (X-axis)', 'Sobel (Y-axis)', 'Sobel'] output = [img, rotated, noisy, sx, sy, sob] for i in range(6): plt.subplot(2, 3, i+1) plt.imshow(output[i]) plt.title(titles[i]) plt.axis('off') plt.show()
plt.subplot(1, 2, 2) plt.imshow(flor_rotate_shape) #%% Filtering Filtering # min/max/median filters flor_min = ndi.minimum_filter(flor_gray, size=(3, 3)) flor_max = ndi.maximum_filter(flor_gray, size=(3, 3)) flor_med = ndi.median_filter(flor_gray, size=(3, 3)) flor_max_rgb = ndi.maximum_filter(flor_rgb, size=(3, 3, 3)) # Gaussian blurring flor_gauss = ndi.gaussian_filter(flor_gray, sigma=3) # Convolution Filtering # Using a custom kernel to manipulate an image and enhance or blur an image k = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]) # 3x3 sharpening flor_sharp = ndi.convolve(flor_gray, k) k = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]) # 3x3 vertical edges flor_vert = ndi.convolve(flor_gray, k) plt.imshow(flor_vert, cmap='seismic') k = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]]) # 3x3 horz edges flor_horz = ndi.convolve(flor_gray, k) plt.imshow(flor_horz, cmap='PuOr')
# Surface-based Lifted Index # # The axis of the 300-hPa, 500-hPa, and 850-hPa jets # # Surface dewpoint # # 700-hPa dewpoint depression # # 12-hr surface pressure falls and 500-hPa height changes # 500 hPa CVA dx, dy = mpcalc.lat_lon_grid_spacing(lon, lat) vort_adv_500 = mpcalc.advection(avor_500, [u_500.to('m/s'), v_500.to('m/s')], (dx, dy), dim_order='yx') * 1e9 vort_adv_500_smooth = gaussian_filter(vort_adv_500, 4) #################################### # For the jet axes, we will calculate the windspeed at each level, and plot the highest values wspd_300 = gaussian_filter(mpcalc.get_wind_speed(u_300, v_300), 5) wspd_500 = gaussian_filter(mpcalc.get_wind_speed(u_500, v_500), 5) wspd_850 = gaussian_filter(mpcalc.get_wind_speed(u_850, v_850), 5) ################################# # 850-hPa dewpoint will be calculated from RH and Temperature_isobaric Td_850 = mpcalc.dewpoint_rh(tmp_850, rh_850 / 100.) ################################ # 700-hPa dewpoint depression will be calculated from Temperature_isobaric and RH Td_dep_700 = tmp_700 - mpcalc.dewpoint_rh(tmp_700, rh_700 / 100.)
def _smooth_flat_field(image): image = ndimage.gaussian_filter(image.astype(numpy.float32), 15, mode='nearest') image = image[::2, ::2] image = ndimage.median_filter(image, footprint=_m9) image = ndimage.zoom(image, 2) return ndimage.gaussian_filter(image, 5)
def visualise_orientational_distribution(self, axes_to_return=None, cbar=True): """ Creates a plot of the orientational distribution of the unit cells. :param axes_to_return: if None, print to screen, otherwise, requires 3 axes objects, and will return them. :param cbar: boolean to specify if a color bar should be used. """ import matplotlib.pyplot as plt import matplotlib.patheffects as patheffects from mpl_toolkits.basemap import Basemap import scipy.ndimage as ndi def cart2sph(x, y, z): # cctbx (+z to source, y to ceiling) to # lab frame (+x to source, z to ceiling) z, x, y = x, y, z dxy = np.sqrt(x ** 2 + y ** 2) r = np.sqrt(dxy ** 2 + z ** 2) theta = np.arctan2(y, x) phi = np.arctan2(z, dxy) # angle of the z axis relative to xy plane theta, phi = np.rad2deg([theta, phi]) return theta % 360, phi, r def xy_lat_lon_from_orientation(orientation_array, axis_id): logger.debug("axis_id: {}".format(axis_id)) dist = math.sqrt(orientation_array[axis_id][0] ** 2 + orientation_array[axis_id][1] ** 2 + orientation_array[axis_id][2] ** 2) flon, flat, bla = cart2sph(orientation_array[axis_id][0] / dist, orientation_array[axis_id][1] / dist, orientation_array[axis_id][2] / dist) x, y = euler_map(flon, flat) return x, y, flon, flat orientations = [flex.vec3_double(flex.double( image.orientation.direct_matrix())) for image in self.members] space_groups = [image.orientation.unit_cell().lattice_symmetry_group() for image in self.members] # Now do all the plotting if axes_to_return is None: plt.figure(figsize=(10, 14)) axes_to_return = [plt.subplot2grid((3, 1), (0, 0)), plt.subplot2grid((3, 1), (1, 0)), plt.subplot2grid((3, 1), (2, 0))] show_image = True else: assert len(axes_to_return) == 3, "If using axes option, must hand" \ " 3 axes to function." show_image = False axis_ids = [0, 1, 2] labels = ["a", "b", "c"] for ax, axis_id, label in zip(axes_to_return, axis_ids, labels): # Lists of x,y,lat,long for the master orientation, and for all # symmetry mates. x_coords = [] y_coords = [] lon = [] lat = [] sym_x_coords = [] sym_y_coords = [] sym_lon = [] sym_lat = [] euler_map = Basemap(projection='eck4', lon_0=0, ax=ax) for orientation, point_group_type in zip(orientations, space_groups): # Get position of main spots. main_x, main_y, main_lon, main_lat \ = xy_lat_lon_from_orientation(list(orientation), axis_id) x_coords.append(main_x) y_coords.append(main_y) lon.append(main_lon) lat.append(main_lat) # Get position of symetry mates symmetry_operations = list(point_group_type.smx())[1:] for mx in symmetry_operations: rotated_orientation = list(mx.r().as_double() * orientation) # <-- # should make sense if orientation was a vector, not clear what is # going on since orientation is a matrix. Or, make some test cases # with 'orientation' and see if the behave as desired. sym_x, sym_y, sym_lo, sym_la \ = xy_lat_lon_from_orientation(rotated_orientation, axis_id) #assert (sym_x, sym_y) != (main_x, main_y) sym_x_coords.append(sym_x) sym_y_coords.append(sym_y) sym_lon.append(sym_lo) sym_lat.append(sym_la) # Plot each image as a yellow sphere logger.debug(len(x_coords)) euler_map.plot(x_coords, y_coords, 'oy', markersize=4, markeredgewidth=0.5) # Plot the symetry mates as black crosses #euler_map.plot(sym_x_coords, sym_y_coords, 'kx') # Use a histogram to bin the data in lattitude/longitude space, smooth it, # then plot this as a contourmap. This is for all the symetry-related # copies #density_hist = np.histogram2d(lat + sym_lat, lon + sym_lon, # bins=[range(-90, 91), range(0, 361)]) # No symmetry mates until we can verify what the cctbx libs are doing density_hist = np.histogram2d(lat, lon, bins=[list(range(-90, 91)), list(range(0, 361))]) smoothed = ndi.gaussian_filter(density_hist[0], (15, 15), mode='wrap') local_intensity = [] x_for_plot = [] y_for_plot = [] for _lat in range(0, 180): for _lon in range(0, 360): _x, _y = euler_map(density_hist[2][_lon], density_hist[1][_lat]) x_for_plot.append(_x) y_for_plot.append(_y) local_intensity.append(smoothed[_lat, _lon]) cs = euler_map.contourf(np.array(x_for_plot), np.array(y_for_plot), np.array(local_intensity), tri=True) # Pretty up graph if cbar: _cbar = plt.colorbar(cs, ax=ax) _cbar.ax.set_ylabel('spot density [AU]') middle = euler_map(0, 0) path_effect = [patheffects.withStroke(linewidth=3, foreground="w")] euler_map.plot(middle[0], middle[1], 'o', markersize=10, mfc='none') euler_map.plot(middle[0], middle[1], 'x', markersize=8) ax.annotate("beam", xy=(0.52, 0.52), xycoords='axes fraction', size='medium', path_effects=path_effect) euler_map.drawmeridians(np.arange(0, 360, 60), labels=[0, 0, 1, 0], fontsize=10) euler_map.drawparallels(np.arange(-90, 90, 30), labels=[1, 0, 0, 0], fontsize=10) ax.annotate(label, xy=(-0.05, 0.9), xycoords='axes fraction', size='x-large', weight='demi') if show_image: plt.show() return axes_to_return
# Only use argument 3 if it exists. try: plotPath = sys.argv[3] if (plotPath.split('.')[-1] != 'png'): raise ValueError('Output path for the plot must end with \".png\"') except ValueError: print('Something') except: pass # Transform the original image using a median filter of radius 22px. img = ndimage.imread(inputPath1, flatten=True) img2 = ndimage.imread(inputPath2, flatten=True) # img = median(img, disk((60))) img = ndimage.gaussian_filter(img, sigma=3) img2 = ndimage.gaussian_filter(img2, sigma=3) # Get the profile for each axis. vProfile = sumProfile(img, 0) # Horizontal profile hProfile = sumProfile(img, 1) # Vertical profile vProfile2 = sumProfile(img2, 0) # Horizontal profile hProfile2 = sumProfile(img2, 1) # Vertical profile # TODO: switch the axes and superimpose image behind it. # Horizontal plot 1 plt.figure(0) plt.plot(hProfile, label='original 1') plt.plot(hProfile2, label='original 2')
def slic(image, n_segments=100, compactness=10., max_iter=10, sigma=0, spacing=None, multichannel=True, convert2lab=None, enforce_connectivity=True, min_size_factor=0.5, max_size_factor=3, slic_zero=False, start_label=None, mask=None): """Segments image using k-means clustering in Color-(x,y,z) space. Parameters ---------- image : 2D, 3D or 4D ndarray Input image, which can be 2D or 3D, and grayscale or multichannel (see `multichannel` parameter). n_segments : int, optional The (approximate) number of labels in the segmented output image. compactness : float, optional Balances color proximity and space proximity. Higher values give more weight to space proximity, making superpixel shapes more square/cubic. In SLICO mode, this is the initial compactness. This parameter depends strongly on image contrast and on the shapes of objects in the image. We recommend exploring possible values on a log scale, e.g., 0.01, 0.1, 1, 10, 100, before refining around a chosen value. max_iter : int, optional Maximum number of iterations of k-means. sigma : float or (3,) array-like of floats, optional Width of Gaussian smoothing kernel for pre-processing for each dimension of the image. The same sigma is applied to each dimension in case of a scalar value. Zero means no smoothing. Note, that `sigma` is automatically scaled if it is scalar and a manual voxel spacing is provided (see Notes section). spacing : (3,) array-like of floats, optional The voxel spacing along each image dimension. By default, `slic` assumes uniform spacing (same voxel resolution along z, y and x). This parameter controls the weights of the distances along z, y, and x during k-means clustering. multichannel : bool, optional Whether the last axis of the image is to be interpreted as multiple channels or another spatial dimension. convert2lab : bool, optional Whether the input should be converted to Lab colorspace prior to segmentation. The input image *must* be RGB. Highly recommended. This option defaults to ``True`` when ``multichannel=True`` *and* ``image.shape[-1] == 3``. enforce_connectivity : bool, optional Whether the generated segments are connected or not min_size_factor : float, optional Proportion of the minimum segment size to be removed with respect to the supposed segment size ```depth*width*height/n_segments``` max_size_factor : float, optional Proportion of the maximum connected segment size. A value of 3 works in most of the cases. slic_zero : bool, optional Run SLIC-zero, the zero-parameter mode of SLIC. [2]_ start_label: int, optional The labels' index start. Should be 0 or 1. mask : 2D ndarray, optional If provided, superpixels are computed only where mask is True, and seed points are homogeneously distributed over the mask using a K-means clustering strategy. Returns ------- labels : 2D or 3D array Integer mask indicating segment labels. Raises ------ ValueError If ``convert2lab`` is set to ``True`` but the last array dimension is not of length 3. ValueError If ``start_label`` is not 0 or 1. Notes ----- * If `sigma > 0`, the image is smoothed using a Gaussian kernel prior to segmentation. * If `sigma` is scalar and `spacing` is provided, the kernel width is divided along each dimension by the spacing. For example, if ``sigma=1`` and ``spacing=[5, 1, 1]``, the effective `sigma` is ``[0.2, 1, 1]``. This ensures sensible smoothing for anisotropic images. * The image is rescaled to be in [0, 1] prior to processing. * Images of shape (M, N, 3) are interpreted as 2D RGB images by default. To interpret them as 3D with the last dimension having length 3, use `multichannel=False`. * `start_label` is introduced to handle the issue [4]_. The labels indexing starting at 0 will be deprecated in future versions. If `mask` is not `None` labels indexing starts at 1 and masked area is set to 0. References ---------- .. [1] Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua, and Sabine Süsstrunk, SLIC Superpixels Compared to State-of-the-art Superpixel Methods, TPAMI, May 2012. :DOI:`10.1109/TPAMI.2012.120` .. [2] https://www.epfl.ch/labs/ivrl/research/slic-superpixels/#SLICO .. [3] Irving, Benjamin. "maskSLIC: regional superpixel generation with application to local pathology characterisation in medical images.", 2016, :arXiv:`1606.09518` .. [4] https://github.com/scikit-image/scikit-image/issues/3722 Examples -------- >>> from skimage.segmentation import slic >>> from skimage.data import astronaut >>> img = astronaut() >>> segments = slic(img, n_segments=100, compactness=10) Increasing the compactness parameter yields more square regions: >>> segments = slic(img, n_segments=100, compactness=20) """ image = img_as_float(image) use_mask = mask is not None dtype = image.dtype is_2d = False if image.ndim == 2: # 2D grayscale image image = image[np.newaxis, ..., np.newaxis] is_2d = True elif image.ndim == 3 and multichannel: # Make 2D multichannel image 3D with depth = 1 image = image[np.newaxis, ...] is_2d = True elif image.ndim == 3 and not multichannel: # Add channel as single last dimension image = image[..., np.newaxis] if multichannel and (convert2lab or convert2lab is None): if image.shape[-1] != 3 and convert2lab: raise ValueError("Lab colorspace conversion requires a RGB image.") elif image.shape[-1] == 3: image = rgb2lab(image) if start_label is None: if use_mask: start_label = 1 else: warnings.warn("skimage.measure.label's indexing starts from 0. " + "In future version it will start from 1. " + "To disable this warning, explicitely " + "set the `start_label` parameter to 1.", FutureWarning, stacklevel=2) start_label = 0 if start_label not in [0, 1]: raise ValueError("start_label should be 0 or 1.") # initialize cluster centroids for desired number of segments update_centroids = False if use_mask: mask = np.ascontiguousarray(mask, dtype=np.bool).view('uint8') if mask.ndim == 2: mask = np.ascontiguousarray(mask[np.newaxis, ...]) if mask.shape != image.shape[:3]: raise ValueError("image and mask should have the same shape.") centroids, steps = _get_mask_centroids(mask, n_segments) update_centroids = True else: centroids, steps = _get_grid_centroids(image, n_segments) if spacing is None: spacing = np.ones(3, dtype=dtype) elif isinstance(spacing, (list, tuple)): spacing = np.ascontiguousarray(spacing, dtype=dtype) if not isinstance(sigma, coll.Iterable): sigma = np.array([sigma, sigma, sigma], dtype=dtype) sigma /= spacing.astype(dtype) elif isinstance(sigma, (list, tuple)): sigma = np.array(sigma, dtype=dtype) if (sigma > 0).any(): # add zero smoothing for multichannel dimension sigma = list(sigma) + [0] image = ndi.gaussian_filter(image, sigma) n_centroids = centroids.shape[0] segments = np.ascontiguousarray(np.concatenate( [centroids, np.zeros((n_centroids, image.shape[3]))], axis=-1)) # Scaling of ratio in the same way as in the SLIC paper so the # values have the same meaning step = max(steps) ratio = 1.0 / compactness image = np.ascontiguousarray(image * ratio, dtype=np.double) if update_centroids: # Step 2 of the algorithm [3]_ _slic_cython(image, mask, segments, step, max_iter, spacing, slic_zero, ignore_color=True, start_label=start_label) labels = _slic_cython(image, mask, segments, step, max_iter, spacing, slic_zero, ignore_color=False, start_label=start_label) if enforce_connectivity: if use_mask: segment_size = mask.sum() / n_centroids else: segment_size = np.prod(image.shape[:3]) / n_centroids min_size = int(min_size_factor * segment_size) max_size = int(max_size_factor * segment_size) labels = _enforce_label_connectivity_cython( labels, min_size, max_size, start_label=start_label) if is_2d: labels = labels[0] return labels
def get_low_pass(self, img): img = img.astype(np.float32) return ndimage.gaussian_filter(img, sigma=5)
def generate_shepplogan_phantom(img_size: int, label: int = 0, smoothing: bool = True) -> np.ndarray: """ Generate 2D Shepp-Logan phantom with random regions size. Phantoms also simulate different kind of AD by generating smaller ROIs. Args: img_size: Size of the generated image (img_size x img_size). label: Take 0 or 1 or 2. Label of the generated image. If 0, the ROIs simulate a CN subject. If 1, the ROIs simulate type 1 of AD. if 2, the ROIs simulate type 2 of AD. smoothing: Default True. Apply Gaussian smoothing to the image. Returns: img: 2D Sheep Logan phantom with specified label. """ img = np.zeros((img_size, img_size)) center = (img_size + 1.0) / 2.0 a = center - 2 b = center * 2 / 3 - 2 color = random.uniform(0.4, 0.6) if label == 0: roi1, roi2 = "large", "large" elif label == 1: roi1, roi2 = "large", "small" elif label == 2: roi1, roi2 = "small", "large" else: raise NotImplementedError(f"Subtype {label} was not implemented.") # Skull rr, cc = ellipse(center, center, a, b, (img_size, img_size)) img[rr, cc] = 1 # Brain offset = random.uniform(1, img_size / 32) rr, cc = ellipse(center + offset / 2, center, a - offset, b - offset, (img_size, img_size)) img[rr, cc] = 0.2 # Central offset1 = random.uniform(1, img_size / 32) offset2 = random.uniform(1, img_size / 32) scale1, scale2 = generate_scales("large") phi = random.uniform(-np.pi, np.pi) rr, cc = ellipse( center + offset1, center + offset2, b / 6 * scale1, b / 6 * scale2, (img_size, img_size), rotation=phi, ) img[rr, cc] = color # ROI 1 offset1 = random.uniform(1, img_size / 32) offset2 = random.uniform(1, img_size / 32) scale1, scale2 = generate_scales(roi1) phi = random.uniform(-np.pi, np.pi) rr, cc = ellipse( center * 0.6 + offset1, center + offset2, b / 3 * scale1, b / 4 * scale2, (img_size, img_size), rotation=phi, ) img[rr, cc] = color # ROI 2 offset1 = random.uniform(1, img_size / 32) offset2 = random.uniform(1, img_size / 32) scale1, scale2 = generate_scales(roi2) phi = random.uniform(-np.pi, np.pi) rr, cc = ellipse( center * 1.5 + offset1, center + offset2, b / 10 * scale1, b / 10 * scale2, (img_size, img_size), rotation=phi, ) img[rr, cc] = color offset1 = random.uniform(1, img_size / 32) offset2 = random.uniform(1, img_size / 32) scale1, scale2 = generate_scales(roi2) phi = random.uniform(-np.pi, np.pi) rr, cc = ellipse( center * 1.5 + offset1, center * 1.1 + offset2, b / 10 * scale1, b / 10 * scale2, (img_size, img_size), rotation=phi, ) img[rr, cc] = color offset1 = random.uniform(1, img_size / 32) offset2 = random.uniform(1, img_size / 32) scale1, scale2 = generate_scales(roi2) phi = random.uniform(-np.pi, np.pi) rr, cc = ellipse( center * 1.5 + offset1, center * 0.9 + offset2, b / 10 * scale1, b / 10 * scale2, (img_size, img_size), rotation=phi, ) img[rr, cc] = color # Ventricle 1 a_roi = a * random.uniform(0.8, 1.2) phi = np.random.uniform(-np.pi / 16, np.pi / 16) rr, cc = ellipse( center, center * 0.75, a_roi / 3, a_roi / 6, (img_size, img_size), rotation=np.pi / 8 + phi, ) img[rr, cc] = 0.0 # Ventricle 2 a_roi = a * random.uniform(0.8, 1.2) phi = np.random.uniform(-np.pi / 16, np.pi / 16) rr, cc = ellipse( center, center * 1.25, a_roi / 3, a_roi / 6, (img_size, img_size), rotation=-np.pi / 8 + phi, ) img[rr, cc] = 0.0 # Random smoothing if smoothing: sigma = random.uniform(0, 1) img = gaussian_filter(img, sigma * img_size / 100.0) # smoothing of data img.clip(0, 1) return img
from scipy import misc, ndimage import numpy as np from IPython.display import display import matplotlib.pyplot as plt %matplotlib inline try: my_image = Image.open('img\\monarch_testimage.png') except: print('Error: Could not load test image!') else: # PIL and NumPy print(f'Loaded image (PIL):\n' f'Format: {my_image.format}\n' f'Size: {my_image.size}\n' f'Mode: {my_image.mode}') my_image_np = np.asarray(my_image) print(f'Image as NumPy array:\n' f'Shape: {my_image_np.shape}\n' f'Mean: {my_image_np.mean()}\n' f'StdDev: {my_image_np.std()}\n') display(my_image.filter(ImageFilter.FIND_EDGES)) # scikit-image moon_image = data.moon() fig, ax = filters.try_all_threshold(moon_image, figsize=(12, 10), verbose=False) plt.show() # SciPy racoon_face = misc.face() blurred_racoon_face = ndimage.gaussian_filter(racoon_face, sigma=6) plt.imshow(blurred_racoon_face)
pitch = Pitch(pitch_type='uefa', figsize=(6.8, 10.5), line_zorder=2, line_color='white', orientation='vertical') # draw fig, ax = pitch.draw() from matplotlib.colors import ListedColormap, LinearSegmentedColormap cmaplist = ['#082630', '#0682fe', "#eff3ff"] cmap = LinearSegmentedColormap.from_list("", cmaplist) bin_statistic = pitch.bin_statistic(barcamoves.x, barcamoves.y, values=barcamoves.xT_value, statistic='sum', bins=(38, 25)) bin_statistic['statistic'] = gaussian_filter(bin_statistic['statistic'], 1) vm = bin_statistic['statistic'].min() vma = bin_statistic['statistic'].max() pitch.heatmap(bin_statistic, ax=ax, cmap='inferno', edgecolors=None, vmin=bin_statistic['statistic'].min(), vmax=bin_statistic['statistic'].max()) ax.set_title('Barcelona' + '\n' + 'Open-play Threat-generation hotspots', fontsize=25) fig.set_facecolor('white') plt.savefig('xt.png', dpi=600) def binnings(df):
def smooth(v, sigma): assert sigma > 0 return SN.gaussian_filter(input=v, sigma=sigma)
def _gaussian(edge, nn): return ndimage.gaussian_filter(edge, sigma=nn * 2 + 1)
os.chdir( '/home/jinho93/new/oxides/perobskite/lanthanum-aluminate/periodic_step/vasp/my015/from-gulp/lvhar' ) os.chdir( '/home/jinho93/new/oxides/perobskite/lanthanum-aluminate/periodic_step/vasp/stengel/015/4/lvhar' ) loc = Locpot.from_file('LOCPOT') #%% dat = np.sum(loc.data['total'], axis=0) / loc.dim[0] dat = np.roll(dat, int(loc.dim[1] * 0.8) // 2, axis=0) dat = np.roll(dat, -10, axis=1) # %% import scipy.ndimage as nd fft = np.fft.fft2(dat) gaus = nd.gaussian_filter(fft.imag, sigma=10) plt.imshow(gaus) #%% criteria = 1e-4 fft2 = np.where(np.abs(fft.real) > np.max(fft.real) * criteria, 0, fft) fft2 = np.where(np.abs(fft.imag) > np.max(fft.imag) * criteria, 0, fft2) # print(np.where(np.abs(fft.imag) > np.max(fft.imag) * 0.7)) ifft = np.fft.ifft2(fft2) plt.imshow(ifft.real) # %%
def smooth_3d( X, quantity_sum=[False], quantity_average=[False], res=1., upper_threshold=False, extent=False, lower_threshold=False, njobs=8, nsteps=250, k=5, n_resample=500, projection='xy', verbose=True, antialias=True, ): ''' purpose: adaptively smooths sparsely sampled particles according to their local density. Similar to the approach described in Merritt+2020, Section 3.1 (https://ui.adsabs.harvard.edu/abs/2020MNRAS.495.4570M/abstract) inputs: X: particle co-ordinates: array shape=(3, Nparticles) quantity_sum: particle quantities to be summed: array shape=(Nquantities, Nparticles); ignore if [False] quantity_average: particle quantities to be averaged: array shape=(Nquantities, Nparticles); ignore if [False] res: desired size of resolution unit in same units as X extent: desired size of the image in the same units as X upper_threshold: number density of particles above which they will no longer be smoothed lower_threshold: number density of particles below which they will no longer be smoothed njobs: number of workers to assign nsteps: total number of density bins to do smoothing over, keep this fairly large or the result will lose accuracy k: k nearest neighbour density estimate n_resample: number of sub-particles to split each particle into for smoothing projection: axis of projection used to produce the images antialias: specifies whether the final image is antialiased outputs: img: smoothed image for each summed quantity: shape = (Nquantities, Npixels, Npixels) average_img: smoothed image for each averaged quantity: shape = (Nquantities, Npixels, Npixels) ''' assert quantity_sum[0] is not False or quantity_average[0] \ is not False, \ 'both quantity_sum and quantity_average cannot be false' from multiprocessing import Pool, sharedctypes import tqdm import numpy as np from fast_histogram import histogram2d from scipy.ndimage import gaussian_filter (x, y) = project(X, projection=projection) if extent is False: extent = img_extent(x, y) hsize = int(extent * 2. / res) if verbose: print(' calculating local density of each particle...') (rho, dist) = nearest_neighbour_density(X.T, k=k, njobs=njobs) d_element = rho / res**3 if (upper_threshold is not False) & (lower_threshold is not False): pick = (d_element < upper_threshold) & (d_element > lower_threshold) if (upper_threshold is not False) & (lower_threshold is False): pick = d_element < upper_threshold if (upper_threshold is False) & (lower_threshold is not False): pick = d_element > lower_threshold if (upper_threshold is False) & (lower_threshold is False): pick = d_element > 0 sort = np.argsort(rho[pick]) sample_points = np.asarray([ np.random.normal(scale=np.median(s), size=n_resample * 10) for s in np.array_split(dist[pick][sort], nsteps) ]) Ds = np.asarray( [np.median(s) for s in np.array_split(dist[pick][sort], nsteps)]) Xs = np.array_split(np.vstack([x[pick], y[pick]])[:, sort], nsteps, axis=-1) if quantity_sum[0] is not False: Qs = np.array_split(quantity_sum[:, pick][:, sort], nsteps, axis=-1) else: Qs = [False] * nsteps if quantity_average[0] is not False: Qs2 = np.array_split(quantity_average[:, pick][:, sort], nsteps, axis=-1) else: Qs2 = [False] * nsteps args = [] for (Xi, Qi, Qi2, Si) in zip(Xs, Qs, Qs2, Ds): args.append([ Xi, Qi, Qi2, Si, extent, res, n_resample, ]) if verbose: print(' smoothing particle distribution...') if quantity_sum[0] is not False: global shared_h result = \ np.ctypeslib.as_ctypes(np.zeros((quantity_sum.shape[0], hsize - 1, hsize - 1))) shared_h = sharedctypes.RawArray(result._type_, result) if quantity_average[0] is not False: global shared_h_2 result_2 = \ np.ctypeslib.as_ctypes(np.zeros((quantity_average.shape[0], hsize - 1, hsize - 1))) shared_h_2 = sharedctypes.RawArray(result_2._type_, result_2) global shared_h_3 result_3 = \ np.ctypeslib.as_ctypes(np.zeros((quantity_average.shape[0], hsize - 1, hsize - 1))) shared_h_3 = sharedctypes.RawArray(result_3._type_, result_3) pool = Pool(processes=njobs) with pool as p: if verbose: job = \ np.asarray(list(tqdm.tqdm(p.imap_unordered(resample_particles, args), total=len(args)))) else: job = np.asarray(list(p.imap_unordered(resample_particles, args))) # now put the images together sigma = (1. if antialias else 0.) if quantity_sum[0] is not False: h = np.ctypeslib.as_array(shared_h) img = [] for i in range(Qs[0].shape[0]): h_ld = h[i] if np.count_nonzero(~pick) > 0: h_hd = histogram2d(x[~pick], y[~pick], weights=quantity_sum[i][~pick], bins=int(extent * 2. / res) - 1, range=[[-extent, extent], [-extent, extent]]) h_ld[~np.isfinite(h_ld)] = 0. h_hd[~np.isfinite(h_hd)] = 0. img.append(gaussian_filter(h_ld + h_hd, sigma)) else: h_ld[~np.isfinite(h_ld)] = 0. img.append(gaussian_filter(h_ld, sigma)) else: img = np.nan if quantity_average[0] is not False: h2 = np.ctypeslib.as_array(shared_h_2) h3 = np.ctypeslib.as_array(shared_h_3) average_img = [] for i in range(Qs2[0].shape[0]): h_ld = h2[i] if np.count_nonzero(~pick) > 0: h_hd = histogram2d(x[~pick], y[~pick], weights=quantity_average[i][~pick], bins=int(extent * 2. / res) - 1, range=[[-extent, extent], [-extent, extent]]) n_hd = histogram2d(x[~pick], y[~pick], bins=int(extent * 2. / res) - 1, range=[[-extent, extent], [-extent, extent]]) h_ld[~np.isfinite(h_ld)] = 0. h_hd[~np.isfinite(h_hd)] = 0. average_img.append( gaussian_filter((h_ld + h_hd) / (h3[i] + n_hd), sigma)) else: h_ld[~np.isfinite(h_ld)] = 0. average_img.append(gaussian_filter(h_ld / h3[i], sigma)) else: average_img = np.nan return (img, average_img)
def fill_error_gaps(): res = pd.read_csv('/work/GLEAM/errors/result.csv', index_col=0) gpis_valid = get_valid_gpis(latmin=24., latmax=51., lonmin=-128., lonmax=-64.) ind_valid = np.unravel_index(gpis_valid, (720,1440)) res_gapfilled = pd.DataFrame(index=gpis_valid) r_min = 0.0 ind = (res['R_GLEAM_ASCAT'] <= r_min) | \ (res['R_GLEAM_AMSR2'] <= r_min) | \ (res['R_ASCAT_AMSR2'] <= r_min) res.loc[ind, ['TC1_R2_GLEAM', 'TC1_R2_ASCAT', 'TC1_R2_AMSR2']] = np.nan res.loc[ind, ['TC1_RMSE_GLEAM', 'TC1_RMSE_ASCAT', 'TC1_RMSE_AMSR2']] = np.nan # ind = (res['p_GLEAM_ASCAT'] >= 0.05) | \ # (res['p_GLEAM_AMSR2'] >= 0.05) | \ # (res['p_ASCAT_AMSR2'] >= 0.05) # # res.loc[ind, ['TC1_R2_GLEAM', 'TC1_R2_ASCAT', 'TC1_R2_AMSR2']] = np.nan # res.loc[ind, ['TC1_RMSE_GLEAM', 'TC1_RMSE_ASCAT', 'TC1_RMSE_AMSR2']] = np.nan ind = (res['R_GLEAM_ASCAT'] <= r_min) | \ (res['R_GLEAM_SMAP'] <= r_min) | \ (res['R_ASCAT_SMAP'] <= r_min) res.loc[ind, ['TC2_R2_GLEAM', 'TC2_R2_ASCAT', 'TC2_R2_SMAP']] = np.nan res.loc[ind, ['TC2_RMSE_GLEAM', 'TC2_RMSE_ASCAT', 'TC2_RMSE_SMAP']] = np.nan # ind = (res['p_GLEAM_ASCAT'] >= 0.05) | \ # (res['p_GLEAM_SMAP'] >= 0.05) | \ # (res['p_ASCAT_SMAP'] >= 0.05) # # res.loc[ind, ['TC2_R2_GLEAM', 'TC2_R2_ASCAT', 'TC2_R2_SMAP']] = np.nan # res.loc[ind, ['TC2_RMSE_GLEAM', 'TC2_RMSE_ASCAT', 'TC2_RMSE_SMAP']] = np.nan # --------------------- # tags = ['TC1_R2_GLEAM',] tags = ['TC1_R2_GLEAM', 'TC1_R2_ASCAT', 'TC1_R2_AMSR2', 'TC2_R2_GLEAM', 'TC2_R2_ASCAT', 'TC2_R2_SMAP', 'TC1_RMSE_GLEAM', 'TC1_RMSE_ASCAT', 'TC1_RMSE_AMSR2', 'TC2_RMSE_GLEAM', 'TC2_RMSE_ASCAT', 'TC2_RMSE_SMAP'] imp = IterativeImputer(max_iter=10, random_state=0) ind = np.unravel_index(res.index.values, (720,1440)) for tag in tags: img = np.full((720,1440), np.nan) img[ind] = res[tag] # find all non-zero values idx = np.where(~np.isnan(img)) vmin, vmax = np.percentile(img[idx], [2.5, 97.5]) img[img<vmin] = vmin img[img>vmax] = vmax # calculate fitting parameters imp.set_params(min_value=vmin, max_value=vmax) imp.fit(img) # Define an anchor pixel to infer fitted image dimensions tmp_img = img.copy() tmp_img[idx[0][100],idx[1][100]] = 1000000 # transform image with and without anchor pixel tmp_img_fitted = imp.transform(tmp_img) img_fitted = imp.transform(img) # # Get indices of fitted image idx_anchor = np.where(tmp_img_fitted == 1000000)[1][0] start = idx[1][100] - idx_anchor end = start + img_fitted.shape[1] # write output img[:,start:end] = img_fitted img = gaussian_filter(img, sigma=0.7, truncate=1) res_gapfilled.loc[:, tag] = img[ind_valid] # np.save('/work/GLEAM/test', img) print(tag, 'finished.') res_gapfilled.to_csv('/work/GLEAM/errors/result_gapfilled_sig07.csv')
imgtl.DisplayImage(IMG) plt.title('raw data::' + FilenameBeam, fontsize=FTsize) plt.axis('off') print('size raw:', np.shape(IMG)) # crop image # plt.figure() plt.subplot(2, 2, 2) IMGc = imgtl.RemoveEdge(IMG, 100) print('size removed:', np.shape(IMGc)) imgtl.DisplayCalibratedProj(IMGc, cal, fudge) plt.title('cropped' + FilenameBeam, fontsize=FTsize) plt.axis('off') # threshold image # plt.figure() plt.subplot(2, 2, 3) IMGt = ndimage.gaussian_filter(IMGc, 0) # imgtl.Threshold(IMGc, threshold) imgtl.DisplayCalibratedProj(IMGt, cal, fudge) plt.title('cropped::' + FilenameBeam, fontsize=FTsize) plt.axis('off') # compute profiles histx, histy, x, y = imgtl.GetImageProjection(IMGt, cal) # plt.figure() plt.subplot(2, 2, 4) x = x - x[np.argmax(histx)] y = y - y[np.argmax(histy)] plt.plot(x, histx, '-') plt.plot(y, histy, '-') plt.xlabel('distance') plt.ylabel('population') plt.title('profiles::' + FilenameBeam, fontsize=FTsize)
def distortions(lensModel, kwargs_lens, num_pix=100, delta_pix=0.05, center_ra=0, center_dec=0, differential_scale=0.0001, smoothing_scale=None, **kwargs): """ :param lensModel: LensModel instance :param kwargs_lens: lens model keyword argument list :param num_pix: number of pixels per axis :param delta_pix: pixel scale per axis :param center_ra: center of the grid :param center_dec: center of the grid :param differential_scale: scale of the finite derivative length in units of angles :param smoothing_scale: float or None, Gaussian FWHM of a smoothing kernel applied before plotting :return: matplotlib instance with different panels """ kwargs_grid = sim_util.data_configure_simple(num_pix, delta_pix, center_ra=center_ra, center_dec=center_dec) _coords = ImageData(**kwargs_grid) _frame_size = num_pix * delta_pix ra_grid, dec_grid = _coords.pixel_coordinates extensions = LensModelExtensions(lensModel=lensModel) ra_grid1d = util.image2array(ra_grid) dec_grid1d = util.image2array(dec_grid) lambda_rad, lambda_tan, orientation_angle, dlambda_tan_dtan, dlambda_tan_drad, dlambda_rad_drad, dlambda_rad_dtan, dphi_tan_dtan, dphi_tan_drad, dphi_rad_drad, dphi_rad_dtan = extensions.radial_tangential_differentials( ra_grid1d, dec_grid1d, kwargs_lens=kwargs_lens, center_x=center_ra, center_y=center_dec, smoothing_3rd=differential_scale, smoothing_2nd=None) lambda_rad2d, lambda_tan2d, orientation_angle2d, dlambda_tan_dtan2d, dlambda_tan_drad2d, dlambda_rad_drad2d, dlambda_rad_dtan2d, dphi_tan_dtan2d, dphi_tan_drad2d, dphi_rad_drad2d, dphi_rad_dtan2d = util.array2image(lambda_rad), \ util.array2image(lambda_tan), util.array2image(orientation_angle), util.array2image(dlambda_tan_dtan), util.array2image(dlambda_tan_drad), util.array2image(dlambda_rad_drad), util.array2image(dlambda_rad_dtan), \ util.array2image(dphi_tan_dtan), util.array2image(dphi_tan_drad), util.array2image(dphi_rad_drad), util.array2image(dphi_rad_dtan) if smoothing_scale is not None: lambda_rad2d = ndimage.gaussian_filter(lambda_rad2d, sigma=smoothing_scale / delta_pix) dlambda_rad_drad2d = ndimage.gaussian_filter(dlambda_rad_drad2d, sigma=smoothing_scale / delta_pix) lambda_tan2d = np.abs(lambda_tan2d) # the magnification cut is made to make a stable integral/convolution lambda_tan2d[lambda_tan2d > 100] = 100 lambda_tan2d = ndimage.gaussian_filter(lambda_tan2d, sigma=smoothing_scale / delta_pix) # the magnification cut is made to make a stable integral/convolution dlambda_tan_dtan2d[dlambda_tan_dtan2d > 100] = 100 dlambda_tan_dtan2d[dlambda_tan_dtan2d < -100] = -100 dlambda_tan_dtan2d = ndimage.gaussian_filter(dlambda_tan_dtan2d, sigma=smoothing_scale / delta_pix) orientation_angle2d = ndimage.gaussian_filter(orientation_angle2d, sigma=smoothing_scale / delta_pix) dphi_tan_dtan2d = ndimage.gaussian_filter(dphi_tan_dtan2d, sigma=smoothing_scale / delta_pix) def _plot_frame(ax, map, vmin, vmax, text_string): """ :param ax: matplotlib.axis instance :param map: 2d array :param vmin: minimum plotting scale :param vmax: maximum plotting scale :param text_string: string to describe the label :return: """ font_size = 10 _arrow_size = 0.02 im = ax.matshow(map, extent=[0, _frame_size, 0, _frame_size], vmin=vmin, vmax=vmax) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax.autoscale(False) divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.05) cb = plt.colorbar(im, cax=cax, orientation='vertical') #cb.set_label(text_string, fontsize=10) #plot_util.scale_bar(ax, _frame_size, dist=1, text='1"', font_size=font_size) plot_util.text_description(ax, _frame_size, text=text_string, color="k", backgroundcolor='w', font_size=font_size) #if 'no_arrow' not in kwargs or not kwargs['no_arrow']: # plot_util.coordinate_arrows(ax, _frame_size, _coords, # color='w', arrow_size=_arrow_size, # font_size=font_size) f, axes = plt.subplots(3, 4, figsize=(12, 8)) _plot_frame(axes[0, 0], lambda_rad2d, vmin=0.6, vmax=1.4, text_string=r"$\lambda_{rad}$") _plot_frame(axes[0, 1], lambda_tan2d, vmin=-20, vmax=20, text_string=r"$\lambda_{tan}$") _plot_frame(axes[0, 2], orientation_angle2d, vmin=-np.pi / 10, vmax=np.pi / 10, text_string=r"$\phi$") _plot_frame(axes[0, 3], util.array2image(lambda_tan * lambda_rad), vmin=-20, vmax=20, text_string='magnification') _plot_frame(axes[1, 0], dlambda_rad_drad2d / lambda_rad2d, vmin=-.1, vmax=.1, text_string='dlambda_rad_drad') _plot_frame(axes[1, 1], dlambda_tan_dtan2d / lambda_tan2d, vmin=-20, vmax=20, text_string='dlambda_tan_dtan') _plot_frame(axes[1, 2], dlambda_tan_drad2d / lambda_tan2d, vmin=-20, vmax=20, text_string='dlambda_tan_drad') _plot_frame(axes[1, 3], dlambda_rad_dtan2d / lambda_rad2d, vmin=-.1, vmax=.1, text_string='dlambda_rad_dtan') _plot_frame(axes[2, 0], dphi_rad_drad2d, vmin=-.1, vmax=.1, text_string='dphi_rad_drad') _plot_frame(axes[2, 1], dphi_tan_dtan2d, vmin=0, vmax=20, text_string='dphi_tan_dtan: curvature radius') _plot_frame(axes[2, 2], dphi_tan_drad2d, vmin=-.1, vmax=.1, text_string='dphi_tan_drad') _plot_frame(axes[2, 3], dphi_rad_dtan2d, vmin=0, vmax=20, text_string='dphi_rad_dtan') return f, axes
def augment_data_with_masks(data, masks, labels, augm_nb_samples, transforms): """ DESCRIPTION: ----------- This function takes all the data and increases the number of samples by randomly selecting a transformation to be done. Returns: ------- data: TYPE np.ndarray Array with images labels: TYPE nd.ndarray Array with the labels """ # Record the number of samples before augmentation. nb_samples_start = data.shape[0] # Make two lists for augmented samples and labels augmented_data = [] augmented_masks = [] augmented_labels = [] # Determine the possible values for the different transformations reflect_options = [-1, 1] scale_options = np.arange(1, 2, 0.05) rotate_options = np.arange(-np.pi, np.pi, 0.05 * np.pi) shear_options = np.arange(-1, 1, 0.05) gaussian_options = np.arange(0.5, 5.5, 0.5) while len(augmented_data) <= augm_nb_samples: # Select image to be transformed: index = np.random.randint(nb_samples_start) im = data[index, :, :, 0] msk = data[index, :, :, 0] im_label = labels[index] # Select random transformation: transformation = np.random.choice(transforms) if transformation == 'reflect': # Reflection: rx, ry = 1, 1 while rx == 1 and ry == 1: rx = np.random.choice(reflect_options) ry = np.random.choice(reflect_options) T = reflect(rx, ry) if transformation == 'scale': # Scaling: sx = np.random.choice(scale_options) sy = np.random.choice(scale_options) T = scale(sx, sy) if transformation == 'rotate': # Rotation: angle = np.random.choice(rotate_options) Th = make_rotation(angle, im.shape) im_T = image_transform(im, Th) msk_T = image_transform(msk, Th) if transformation == 'shear': # Shearing: cx = np.random.choice(shear_options) cy = np.random.choice(shear_options) T = shear(cx, cy) if transformation == 'gaussblur': # Gaussian blur: sigma = np.random.choice(gaussian_options) im_T = ndimage.gaussian_filter(im, sigma=sigma) if transformation != 'gaussblur' and transformation != 'rotate': # Do some steps which are not required in Gaussian blurring # Check for singularity. When the matrix is singular, it cannot be # inverted or applied to the image and this step is reset. det = T[0, 0] * T[1, 1] - T[0, 1] * T[1, 0] if det == 0: continue # Converts the 2D-transformation matrix to the homogenous form: Th = t2h(T) # Transform the image using the homogenous transformation matrix. im_T = image_transform(im, Th) msk_T = image_transform(msk, Th) # Add a new axis to be able to append to the data array im_T = im_T[..., np.newaxis] msk_T = msk_T[..., np.newaxis] # Append data and labels to the augmented data lists augmented_data.append(im_T) augmented_masks.append(msk_T) augmented_labels.append(im_label) # Convert the lists to arrays print('{} samples augmented'.format(len(augmented_data))) augmented_data = np.array(augmented_data) augmented_masks = np.array(augmented_data) augmented_labels = np.array(augmented_labels) # Remove duplicate augmented samples augmented_data_unique, i_unique = np.unique(augmented_data, return_index=True, axis=0) augmented_masks_unique = augmented_masks[i_unique] augmented_labels_unique = augmented_labels[i_unique] print('{} augmented samples left after removing duplicates'.format( augmented_data_unique.shape[0])) # Return augmented samples return augmented_data_unique, augmented_masks_unique, augmented_labels_unique
def main(argv): if len(argv) == 0: print('count_colonies_interactive.py usage:') print( ' count_colonies_interactive.py [filename] [optional arguments]' ) print(' e.g. count_colonies_interactive.py petridish.tif') print(' optional arguments:') print(' plot') print( ' - shows the plot at the end of the analysis (saves regardless)' ) print(' colorspace') print( ' - change the default colorspace (default is L channel from LAB' ) print( ' - if you use colorspace, you must have two additional arguments' ) print( ' - the first must be the colorspace, a choice of either RGB, LAB, HSV' ) print( ' - the second is the channel to use in that colorspace, a choice of either 0, 1, 2' ) print( ' - e.g. count_colonies_interactive.py petridish.tif colorspace RGB 1' ) print( ' - this will use the green channel from the RGB colorspace for the analysis' ) print( ' - if you are uncertain about the best colorspace, use the best_color_chooser.py program' ) print(' calc_dists') print( ' - calculates a number of distance metrics using R and the spatstat package' ) print( ' - only do this if you have those installed, and Rscript is visible by your system' ) return if not os.path.isfile(argv[0]): print('first argument must be path to image file') return #default arguments show_plot = False color_space = "LAB" color_channel = 0 calc_dists = False if len(argv) > 1: for i in range(1, len(argv)): if argv[i] == "plot": show_plot = True if argv[i] == 'colorspace': color_space = argv[i + 1] color_channel = int(argv[i + 2]) if argv[i] == 'calc_dists': calc_dists = True # read file #file = "20170601_low_buffer_1.tif" #file = '20170605_higlu_E_1.tif' file = argv[0] cells = io.imread(file) im_for_viewing = cells cells = skimage.img_as_float(cells) # change to chosen color channel if color_space == "LAB": img = skimage.color.rgb2lab(cells) elif color_space == "RGB": img = cells elif color_space == "HSV": img = skimage.color.rgb2hsv(cells) else: print("colorspace first argument must be LAB, RGB, or HSV, quitting") quit() #plt.imshow(lab[:,:,1]) # filter img1 = ndi.gaussian_filter(img, 5) # normalize to 0-1 img1 = img1[:, :, color_channel] - np.min(img1[:, :, color_channel]) img1 /= np.max(img1) # click to see if colony is lighter than or darker than background pos = get_clicks( im_for_viewing, caption="click on one colony then on background then exit window", window_width=640) # average clicked area over 9 pixel square foreground = 0 background = 0 for i in [-1, 0, 1]: for j in [-1, 0, 1]: foreground += img1[pos[0][0] + i, pos[0][1] + j] background += img1[pos[1][0] + i, pos[1][1] + j] foreground /= 9 background /= 9 # invert if background is brighter if background > foreground: img1 = 1 - img1 # find center and half-width center = img1.shape[0] / 2 radius = img1.shape[0] / 2 # mask dish circle = make_circle_selection(im_for_viewing) center = (int(circle[0]), int(circle[1])) radius = int(circle[2]) masked = round_mask(img1, center, radius) # apply threshold thresh = get_nonzero_otsu(masked) threshed = masked > thresh # opened to erase teeny things strel = skimage.morphology.disk(7) opened = skimage.morphology.binary_opening(threshed, selem=strel) #smooth smoothed, then mask with the opened image smoothed = ndi.gaussian_filter(img1, 4) smoothed[~opened] = 0 # find the local peaks coordinates = skimage.feature.peak_local_max(smoothed, min_distance=5) coordinates = [(x[0], x[1]) for x in coordinates] # let the user add additional points coordinates = add_or_remove_locs_with_clicks( im_for_viewing, coordinates, caption="click to add colonies, left-shift+click to de-select") coordinates = np.asarray(coordinates) # separate connected colonies bw = smoothed > 0 distance = ndi.distance_transform_edt(bw) coordinates_in_im = skimage.feature.peak_local_max(smoothed, indices=False, min_distance=5) markers = skimage.measure.label(coordinates_in_im) labels_ws = skimage.morphology.watershed(-distance, markers, mask=bw) rp = skimage.measure.regionprops(labels_ws) # find the objects that don't have clicks in them rp_not_clicked = [] for curr_rp in rp: coords = curr_rp.coords any_coordinate_in_object = False for i in range(len(coordinates)): if coordinates[i][0] in coords[:, 0] and coordinates[i][ 1] in coords[:, 1]: any_coordinate_in_object = True break rp_not_clicked.append(any_coordinate_in_object) # remove those objects from rp rp = [rp[i] for i in range(len(rp)) if rp_not_clicked[i]] centroids = [rp[i].centroid for i in range(len(rp))] eccentricity = [rp[i].eccentricity for i in range(len(rp))] x = [c[1] for c in centroids] y = [c[0] for c in centroids] areas = np.asarray([rp[i].area for i in range(len(rp))]) colony = [str(c) for c in range(len(x))] #plt.scatter(x, y, np.sqrt(areas)) df = pd.DataFrame({ 'x': x, 'y': y, 'area': areas, 'eccentricity': eccentricity, 'colony': range(len(x)), 'petri_x': circle[0], 'petri_y': circle[1], 'petri_radius': circle[2] }) # plot f, axarr = plt.subplots(1, 2) axarr[0].axis("off") axarr[0].imshow(im_for_viewing) axarr[0].hold(True) axarr[0].plot(x, y, 'r.', markersize=1) for i, txt in enumerate(colony): axarr[0].annotate(txt, (x[i] + 9, y[i] - 9), color='#FFFFFF', size=2) axarr[1].axis("off") axarr[1].imshow(labels_ws) axarr[1].hold(True) axarr[1].plot(x, y, 'r.', markersize=1) for i, txt in enumerate(colony): axarr[1].annotate(txt, (x[i] + 9, y[i] - 9), color='#FFFFFF', size=2) plt.savefig('{}_result_img.png'.format(file), dpi=300, bbox_inches='tight') df.to_csv('{}_results.csv'.format(file)) # use R to calculate Voronoi in a circle (no python package does this!) if calc_dists: subprocess.call(["Rscript", "./distance_metrics_calc.R", file]) if show_plot: plt.show()
from skimage import io, util, color, feature import sys from scipy import ndimage as nd import numpy as np img = util.img_as_float(color.rgb2gray(io.imread(sys.argv[1]))) # Canny edge detecor gaussian_img = nd.gaussian_filter(img, int(sys.argv[2])) canny = feature.canny(gaussian_img) # io.imsave(sys.argv[3], util.img_as_uint(canny)) # Prewitt operators prk_x = np.asarray([[-1, -1, -1], [0, 0, 0], [1, 1, 1]]) prk_y = np.asarray([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]]) """ # Sobel prk_x = np.asarray([[-1, -2, -1], [0, 0, 0], [1, 2, 1]]) prk_y = np.asarray([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) """ grad_x = nd.convolve(gaussian_img, prk_x, mode='nearest') grad_y = nd.convolve(gaussian_img, prk_y, mode='nearest') grad_x_y = np.sqrt(grad_x**2 + grad_y**2) io.imsave('prewitt.png', util.img_as_uint(grad_x_y))
def process_image(self, image): image = image - gaussian_filter(image, self.nuclear_blur) image[image < 0] = 0 return image
TC_basin=da.read_nc('data/Allstorms.ibtracs_all.v03r10.nc')['basin'] tc_sel=da.read_nc('data/Allstorms.ibtracs_all.v03r10.nc').ix[np.where((TC_season==int(identifier)) & (TC_basin[:,0]==0))[0]] plt.close('all') plate_carree = ccrs.PlateCarree() fig,ax=plt.subplots(nrows=1,ncols=1,figsize=(10,5)) ax = plt.axes(projection=plate_carree) ax.set_global() ax.coastlines() ax.add_feature(cartopy.feature.LAND, facecolor='darkgreen') ax.add_feature(cartopy.feature.OCEAN,facecolor='darkblue') ax.set_xlim(np.min(lons),np.max(lons)) ax.set_ylim(np.min(lats),np.max(lats)) working_dir='detection/JRA55/'+str(identifier)+'_JRA55/' found_tcs=tc_detection.tc_tracks(Wind10=Wind10,MSLP=MSLP,MSLP_smoothed=ndimage.gaussian_filter(MSLP,sigma=(0,3,3)),land_mask=land_mask,SST=None,VO=VO,T=T_ana,T_diff=T_diff,lats=lats,lons=lons,time_=time_,dates=dates,identifier=identifier,working_dir=working_dir) found_tcs.init_map(ax=ax,transform=plate_carree) found_tcs.init_obs_tcs(tc_sel) elapsed = time.time() - start; print('Done with preparations %.3f seconds.' % elapsed) # # hybrid method # found_tcs.detect_hybrid(overwrite=False,p_radius=27,dis_mslp_min=3,warm_core_size=4,dis_cores=1) # found_tcs.plot_detect_summary(thr_wind=10) # found_tcs.combine_tracks(overwrite=True,thr_wind=0,search_radius=6,strong_steps=8,total_steps=8,warm_steps=4,consecutive_warm_strong_steps=4,plot=False) # found_tcs.plot_season() # elapsed = time.time() - start; print('Done with preparations %.3f seconds.' % elapsed) # # # contours method # found_tcs.detect_contours(overwrite=True,p_radius=27,dis_mslp_min=3,warm_core_size=3,dis_cores=1) # found_tcs.plot_detect_summary(thr_wind=10)
# ax=ax, colorbar_label='Reflectivity (dB)', antialiased=True) # get data start = radar.get_start(sweep) end = radar.get_end(sweep) + 1 data = radar.get_field(sweep, 'differential_reflectivity') x, y, z = radar.get_gate_x_y_z(sweep, edges=False) x /= 1000.0 y /= 1000.0 z /= 1000.0 # apply a gaussian blur to the data set for nice smooth lines: # sigma adjusts the distance effect of blending each cell, # 4 is arbirarly set for visual impact. data = ndimage.gaussian_filter(data, sigma=4) # calculate (R)ange R = np.sqrt(x ** 2 + y ** 2) * np.sign(y) R = -R display.set_limits(xlim=[0, 40], ylim=[0, 15]) # add contours # creates steps 35 to 100 by 5 levels = np.arange(-3, 4, 0.25) # levels_rain = np.arange(1, 4, 0.5) levels_ice = np.arange(-2, -0, 0.5) levels_rain = [0.75] # adds contours to plot contours = ax.contour(R, z, data, levels, linewidths=1, colors='k',
def estimate(heat_mat, paf_mat): if heat_mat.shape[2] == 19: heat_mat = np.rollaxis(heat_mat, 2, 0) if paf_mat.shape[2] == 38: paf_mat = np.rollaxis(paf_mat, 2, 0) if PoseEstimator.heatmap_supress: heat_mat = heat_mat - heat_mat.min(axis=1).min(axis=1).reshape( 19, 1, 1) heat_mat = heat_mat - heat_mat.min(axis=2).reshape( 19, heat_mat.shape[1], 1) if PoseEstimator.heatmap_gaussian: heat_mat = gaussian_filter(heat_mat, sigma=0.5) if PoseEstimator.adaptive_threshold: _NMS_Threshold = max( np.average(heat_mat) * 4.0, PoseEstimator.NMS_Threshold) _NMS_Threshold = min(_NMS_Threshold, 0.3) else: _NMS_Threshold = PoseEstimator.NMS_Threshold # extract interesting coordinates using NMS. coords = [] # [[coords in plane1], [....], ...] for plain in heat_mat[:-1]: nms = PoseEstimator.non_max_suppression(plain, 5, _NMS_Threshold) coords.append(np.where(nms >= _NMS_Threshold)) # score pairs pairs_by_conn = list() for (part_idx1, part_idx2), (paf_x_idx, paf_y_idx) in zip(CocoPairs, CocoPairsNetwork): pairs = PoseEstimator.score_pairs( part_idx1, part_idx2, coords[part_idx1], coords[part_idx2], paf_mat[paf_x_idx], paf_mat[paf_y_idx], heatmap=heat_mat, rescale=(1.0 / heat_mat.shape[2], 1.0 / heat_mat.shape[1])) pairs_by_conn.extend(pairs) # merge pairs to human # pairs_by_conn is sorted by CocoPairs(part importance) and Score between Parts. humans = [Human([pair]) for pair in pairs_by_conn] while True: merge_items = None for k1, k2 in itertools.combinations(humans, 2): if k1 == k2: continue if k1.is_connected(k2): merge_items = (k1, k2) break if merge_items is not None: merge_items[0].merge(merge_items[1]) humans.remove(merge_items[1]) else: break # reject by subset count humans = [ human for human in humans if human.part_count() >= PoseEstimator.PAF_Count_Threshold ] # reject by subset max score humans = [ human for human in humans if human.get_max_score() >= PoseEstimator.Part_Score_Threshold ] return humans
path_out+f_out, 'w', driver='GTiff', height=mdt.shape[0], width=mdt.shape[1], count=1, dtype=mdt.dtype, crs=raster.crs, transform=raster.transform, ) as dst: dst.write(mdt_delta, 1) #%% 6. Blurring final from scipy.ndimage import gaussian_filter gauss=gaussian_filter(mdt,15)*delta_mask if plotear: plt.imshow(gauss,vmin=17,vmax=22) #%% 7. Guardado en GTiff el blureado with rasterio.open( path_out+f_out2, 'w', driver='GTiff', height=mdt.shape[0], width=mdt.shape[1], count=1, dtype=mdt.dtype, crs=raster.crs, transform=raster.transform,