def show_qzr_map( qr, qz, inc_x0, data=None, Nzline=10,Nrline=10 ): import matplotlib.pyplot as plt import copy import matplotlib.cm as mcm cmap='viridis' _cmap = copy.copy((mcm.get_cmap(cmap))) _cmap.set_under('w', 0) qr_start, qr_end, qr_num = qr.min(),qr.max(), Nzline qz_start, qz_end, qz_num = qz.min(),qz.max(), Nrline qr_edge, qr_center = get_qedge(qr_start , qr_end, ( qr_end- qr_start)/(qr_num+100), qr_num ) qz_edge, qz_center = get_qedge( qz_start, qz_end, (qz_end - qz_start)/(qz_num+100 ) , qz_num ) label_array_qz = get_qmap_label( qz, qz_edge) label_array_qr = get_qmap_label( qr, qr_edge) labels_qz, indices_qz = roi.extract_label_indices( label_array_qz ) labels_qr, indices_qr = roi.extract_label_indices( label_array_qr ) num_qz = len(np.unique( labels_qz )) num_qr = len(np.unique( labels_qr )) fig, ax = plt.subplots() if data is None: data=qr+qz im = ax.imshow(data, cmap='viridis',origin='lower') else: im = ax.imshow(data, cmap='viridis',origin='lower', norm= LogNorm(vmin=0.001, vmax=1e1)) imr=ax.imshow(label_array_qr, origin='lower' ,cmap='viridis', vmin=0.5,vmax= None )#,interpolation='nearest',) imz=ax.imshow(label_array_qz, origin='lower' ,cmap='viridis', vmin=0.5,vmax= None )#,interpolation='nearest',) caxr = fig.add_axes([0.81, 0.1, 0.03, .8]) #x,y, width, heigth cba = fig.colorbar(im, cax=caxr ) ax.set_xlabel(r'$q_r$', fontsize=18) ax.set_ylabel(r'$q_z$',fontsize=18) zticks,zticks_label = get_qz_tick_label(qz,label_array_qz) #rticks,rticks_label = get_qr_tick_label(label_array_qr,inc_x0) rticks,rticks_label = zip(*sorted( zip( *get_qr_tick_label( qr, label_array_qr, inc_x0) )) ) ax.set_yticks( zticks[::1] ) yticks = zticks_label[::1] ax.set_yticklabels(yticks, fontsize=9) stride = int(len(rticks)/7) ax.set_xticks( rticks[::stride] ) xticks = rticks_label[::stride] ax.set_xticklabels(xticks, fontsize=9) ax.set_title( 'Q-zr_Map', y=1.03,fontsize=18) plt.show()
def autocor_one_time( num_buf, rois, imgs, num_lev=None, start_img=None, end_img=None, bad_images = None, threshold=None): ''' Dec 16, 2015, Y.G.@CHX a multi-tau code for one-time correlation function, add new funciton to deal with bad images, which masked intensities are still large than threshold Parameters: num_buf: int, number of buffer rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs imgs: pims sequences, image stack Options: num_lev: int, number of level, if None: = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 start_img: int, None, =0 end_img: int, None, = len(imgs) bad_images: list, None,bad_images list threshold: float, None, intensity max threshold, above which is considered as bad images Return: g2, 2D-array, shape as (tau, q) tau, 1D-array One example: g2, tau = autocor_one_time( num_buf, ring_mask, imgsr, num_lev=None, bad_images=None, threshold= 65500 ) ''' start_time = time.time() #print (dly) if start_img is None: start_img=0 if end_img is None: try: end_img= len(imgs) except: end_img= imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) ring_mask = rois if num_lev is None:num_lev = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 nolev = num_lev nobuf =num_buf print ( 'The lev number is %s'%num_lev) dly, dict_dly = delays( num_lev, num_buf, time=1 ) #print (dly.max()) lev_leng = np.array( [ len( dict_dly[i] ) for i in list(dict_dly.keys()) ]) qind, pixelist = roi.extract_label_indices( ring_mask ) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs+1))[1:] nopixels = nopr.sum() start_time = time.time() buf = np.ma.zeros([num_lev,num_buf,nopixels]) buf.mask = True cts=np.zeros(num_lev) cur=np.ones(num_lev) * num_buf countl = np.array( np.zeros( num_lev ),dtype='int') g2 = np.zeros( [ noframes, noframes, noqs] ) G=np.zeros( [(nolev+1)*int(nobuf/2),noqs]) IAP=np.zeros( [(nolev+1)*int(nobuf/2),noqs]) IAF=np.zeros( [(nolev+1)*int(nobuf/2),noqs]) num= np.array( np.zeros( num_lev ),dtype='int') Num= { key: [0]* len( dict_dly[key] ) for key in list(dict_dly.keys()) } print ('Doing g2 caculation of %s frames---'%(noframes )) ttx=0 #if bad_images is None:bad_images=[] for n in range( start_img, end_img ): ##do the work here img = imgs[n] #for n, img in enumerate( imgs): img_ = (np.ravel(img))[pixelist] #print ( img_.max() ) if threshold is not None: if img_.max() >= threshold: print ('bad image: %s here!'%n) img_ = np.ma.zeros( len(img_) ) img_.mask = True if bad_images is not None: if n in bad_images: print ('bad image: %s here!'%n) img_ = np.ma.zeros( len(img_) ) img_.mask = True cur[0]=1+cur[0]%num_buf # increment buffer buf[0, cur[0]-1 ]= img_ img=[] #//save space img_=[] countl[0] = 1+ countl[0] process_one_time(lev=0, bufno=cur[0]-1, G=G,IAP=IAP,IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly, Num=Num, lev_leng=lev_leng ) #time_ind[0].append( current_img_time ) processing=1 lev=1 while processing: if cts[lev]: prev= 1+ (cur[lev-1]-1-1+num_buf)%num_buf cur[lev]= 1+ cur[lev]%num_buf countl[lev] = 1+ countl[lev] bufa = buf[lev-1,prev-1] bufb= buf[lev-1,cur[lev-1]-1] if (bufa.data==0).all(): buf[lev,cur[lev]-1] = bufa elif (bufb.data==0).all(): buf[lev,cur[lev]-1] = bufb else: buf[lev,cur[lev]-1] = ( bufa + bufb ) /2. cts[lev]=0 t1_idx= (countl[lev]-1) *2 process_one_time(lev=lev, bufno=cur[lev]-1, G=G,IAP=IAP,IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly,Num =Num, lev_leng=lev_leng ) lev+=1 #//Since this level finished, test if there is a next level for processing if lev<num_lev:processing = 1 else:processing = 0 else: cts[lev]=1 #// set flag to process next time processing=0 #// can stop until more images are accumulated if n %( int(noframes/10) ) ==0: sys.stdout.write("#") sys.stdout.flush() #print G.shape if (len(np.where(IAP==0)[0])!=0) and ( 0 not in nopr): gmax = np.where(IAP==0)[0][0] else: gmax=IAP.shape[0] #g2=G/(IAP*IAF) #print G g2=(G[:gmax]/(IAP[:gmax]*IAF[:gmax])) elapsed_time = time.time() - start_time #print (Num) print ('Total time: %.2f min' %(elapsed_time/60.)) return g2,dly[:gmax] #, elapsed_time/60.
def autocor_two_time( num_buf, rois, imgs, num_lev=None, start_img=None, end_img=None ): ''' Dec 16, 2015, Y.G.@CHX a multi-tau code for two-time correlation function Parameters: num_buf: int, number of buffer rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs imgs: pims sequences, image stack Options: num_lev: int, number of level, if None: = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 start_img: int, None, =0 end_img: int, None, = len(imgs) #to be done to deal with bad frames #bad_images: list, None,bad_images list #threshold: float, None, intensity max threshold, above which is considered as bad images Return: g12, 3D-array, shape as ( len(imgs), len(imgs), q) One example: g12 = autocor_two_time( num_buf, ring_mask, imgsr, num_lev=None ) ''' #print (dly) if start_img is None:start_img=0 if end_img is None: try: end_img= len(imgs) except: end_img= imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) ring_mask = rois if num_lev is None:num_lev = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 print ( 'The lev number is %s'%num_lev) dly, dict_dly = delays( num_lev, num_buf, time=1 ) #print (dly.max()) qind, pixelist = roi.extract_label_indices( ring_mask ) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs+1))[1:] nopixels = nopr.sum() start_time = time.time() buf=np.zeros([num_lev,num_buf,nopixels]) #// matrix of buffers, for store img cts=np.zeros(num_lev) cur=np.ones(num_lev) * num_buf countl = np.array( np.zeros( num_lev ),dtype='int') g12 = np.zeros( [ noframes, noframes, noqs] ) num= np.array( np.zeros( num_lev ),dtype='int') time_ind ={key: [] for key in range(num_lev)} ttx=0 for n in range( start_img, end_img ): ##do the work here cur[0]=1+cur[0]%num_buf # increment buffer img = imgs[n] #print ( 'The insert image is %s' %(n) ) buf[0, cur[0]-1 ]= (np.ravel(img))[pixelist] img=[] #//save space countl[0] = 1+ countl[0] current_img_time = n - start_img +1 process_two_time(lev=0, bufno=cur[0]-1,n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) time_ind[0].append( current_img_time ) processing=1 lev=1 while processing: if cts[lev]: prev= 1+ (cur[lev-1]-1-1+num_buf)%num_buf cur[lev]= 1+ cur[lev]%num_buf countl[lev] = 1+ countl[lev] buf[lev,cur[lev]-1] = ( buf[lev-1,prev-1] + buf[lev-1,cur[lev-1]-1] ) /2. cts[lev]=0 t1_idx= (countl[lev]-1) *2 current_img_time = ((time_ind[lev-1])[t1_idx ] + (time_ind[lev-1])[t1_idx +1 ] )/2. time_ind[lev].append( current_img_time ) process_two_time(lev=lev, bufno=cur[lev]-1,n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) lev+=1 #//Since this level finished, test if there is a next level for processing if lev<num_lev:processing = 1 else:processing = 0 else: cts[lev]=1 #// set flag to process next time processing=0 #// can stop until more images are accumulated if n %(noframes/10) ==0: sys.stdout.write("#") sys.stdout.flush() for q in range(noqs): x0 = g12[:,:,q] g12[:,:,q] = np.tril(x0) + np.tril(x0).T - np.diag( np.diag(x0) ) elapsed_time = time.time() - start_time print ('Total time: %.2f min' %(elapsed_time/60.)) return g12, elapsed_time/60.
def multi_tau_auto_corr(num_levels, num_bufs, labels, images): ##comments, please add start_image, end_image, the default as None from skxray.core import roi from skxray.core import utils as core """ This function computes one-time correlations. It uses a scheme to achieve long-time correlations inexpensively by downsampling the data, iteratively combining successive frames. The longest lag time computed is num_levels * num_bufs. Parameters ---------- num_levels : int how many generations of downsampling to perform, i.e., the depth of the binomial tree of averaged frames num_bufs : int, must be even maximum lag step to compute in each generation of downsampling labels : array labeled array of the same shape as the image stack; each ROI is represented by a distinct label (i.e., integer) images : iterable of 2D arrays dimensions are: (rr, cc) Returns ------- g2 : array matrix of normalized intensity-intensity autocorrelation shape (num_levels, number of labels(ROI)) lag_steps : array delay or lag steps for the multiple tau analysis shape num_levels Notes ----- The normalized intensity-intensity time-autocorrelation function is defined as :math :: g_2(q, t') = \frac{<I(q, t)I(q, t + t')> }{<I(q, t)>^2} ; t' > 0 Here, I(q, t) refers to the scattering strength at the momentum transfer vector q in reciprocal space at time t, and the brackets <...> refer to averages over time t. The quantity t' denotes the delay time This implementation is based on code in the language Yorick by Mark Sutton, based on published work. [1]_ References ---------- .. [1] D. Lumma, L. B. Lurio, S. G. J. Mochrie and M. Sutton, "Area detector based photon correlation in the regime of short data batches: Data reduction for dynamic x-ray scattering," Rev. Sci. Instrum., vol 70, p 3274-3289, 2000. """ # In order to calculate correlations for `num_bufs`, images must be # kept for up to the maximum lag step. These are stored in the array # buffer. This algorithm only keeps number of buffers and delays but # several levels of delays number of levels are kept in buf. Each # level has twice the delay times of the next lower one. To save # needless copying, of cyclic storage of images in buf is used. if num_bufs % 2 != 0: raise ValueError("number of channels(number of buffers) in " "multiple-taus (must be even)") if hasattr(images, "frame_shape"): # Give a user-friendly error if we can detect the shape from pims. if labels.shape != images.frame_shape: raise ValueError("Shape of the image stack should be equal to" " shape of the labels array") # get the pixels in each label label_mask, pixel_list = roi.extract_label_indices(labels) num_rois = np.max(label_mask) # number of pixels per ROI num_pixels = np.bincount(label_mask, minlength=(num_rois + 1)) num_pixels = num_pixels[1:] if np.any(num_pixels == 0): raise ValueError( "Number of pixels of the required roi's" " cannot be zero, " "num_pixels = {0}".format(num_pixels) ) # G holds the un normalized auto-correlation result. We # accumulate computations into G as the algorithm proceeds. G = np.zeros(((num_levels + 1) * num_bufs / 2, num_rois), dtype=np.float64) # matrix of past intensity normalizations past_intensity_norm = np.zeros(((num_levels + 1) * num_bufs / 2, num_rois), dtype=np.float64) # matrix of future intensity normalizations future_intensity_norm = np.zeros(((num_levels + 1) * num_bufs / 2, num_rois), dtype=np.float64) # Ring buffer, a buffer with periodic boundary conditions. # Images must be keep for up to maximum delay in buf. buf = np.zeros((num_levels, num_bufs, np.sum(num_pixels)), dtype=np.float64) # to track processing each level track_level = np.zeros(num_levels) # to increment buffer cur = np.ones(num_levels, dtype=np.int64) # to track how many images processed in each level img_per_level = np.zeros(num_levels, dtype=np.int64) start_time = time.time() # used to log the computation time (optionally) for n, img in enumerate(images): cur[0] = (1 + cur[0]) % num_bufs # increment buffer # Put the image into the ring buffer. buf[0, cur[0] - 1] = (np.ravel(img))[pixel_list] # Compute the correlations between the first level # (undownsampled) frames. This modifies G, # past_intensity_norm, future_intensity_norm, # and img_per_level in place! _process( buf, G, past_intensity_norm, future_intensity_norm, label_mask, num_bufs, num_pixels, img_per_level, level=0, buf_no=cur[0] - 1, ) # check whether the number of levels is one, otherwise # continue processing the next level processing = num_levels > 1 # Compute the correlations for all higher levels. level = 1 while processing: if not track_level[level]: track_level[level] = 1 processing = False else: prev = 1 + (cur[level - 1] - 2) % num_bufs cur[level] = 1 + cur[level] % num_bufs buf[level, cur[level] - 1] = (buf[level - 1, prev - 1] + buf[level - 1, cur[level - 1] - 1]) / 2 # make the track_level zero once that level is processed track_level[level] = 0 # call the _process function for each multi-tau level # for multi-tau levels greater than one # Again, this is modifying things in place. See comment # on previous call above. _process( buf, G, past_intensity_norm, future_intensity_norm, label_mask, num_bufs, num_pixels, img_per_level, level=level, buf_no=cur[level] - 1, ) level += 1 # Checking whether there is next level for processing processing = level < num_levels # ending time for the process end_time = time.time() logger.info("Processing time for {0} images took {1} seconds." "".format(n, (end_time - start_time))) # the normalization factor if len(np.where(past_intensity_norm == 0)[0]) != 0: g_max = np.where(past_intensity_norm == 0)[0][0] else: g_max = past_intensity_norm.shape[0] # g2 is normalized G g2 = G[:g_max] / (past_intensity_norm[:g_max] * future_intensity_norm[:g_max]) # Convert from num_levels, num_bufs to lag frames. tot_channels, lag_steps = core.multi_tau_lags(num_levels, num_bufs) lag_steps = lag_steps[:g_max] return g2, lag_steps
def show_qzr_map(qr, qz, inc_x0, data=None, Nzline=10, Nrline=10): """ Dec 16, 2015, Y.G.@CHX plot a qzr map of a gisaxs image (data) Parameters: qr: 2-D array, qr of a gisaxs image (data) qz: 2-D array, qz of a gisaxs image (data) inc_x0: the incident beam center x Options: data: 2-D array, a gisaxs image, if None, =qr+qz Nzline: int, z-line number Nrline: int, r-line number Return: zticks: list, z-tick positions in unit of pixel zticks_label: list, z-tick positions in unit of real space rticks: list, r-tick positions in unit of pixel rticks_label: list, r-tick positions in unit of real space Examples: ticks = show_qzr_map( qr, qz, inc_x0, data = None, Nzline=10, Nrline= 10 ) ticks = show_qzr_map( qr,qz, inc_x0, data = avg_imgmr, Nzline=10, Nrline=10 ) """ import matplotlib.pyplot as plt import copy import matplotlib.cm as mcm cmap = "viridis" _cmap = copy.copy((mcm.get_cmap(cmap))) _cmap.set_under("w", 0) qr_start, qr_end, qr_num = qr.min(), qr.max(), Nzline qz_start, qz_end, qz_num = qz.min(), qz.max(), Nrline qr_edge, qr_center = get_qedge(qr_start, qr_end, (qr_end - qr_start) / (qr_num + 100), qr_num) qz_edge, qz_center = get_qedge(qz_start, qz_end, (qz_end - qz_start) / (qz_num + 100), qz_num) label_array_qz = get_qmap_label(qz, qz_edge) label_array_qr = get_qmap_label(qr, qr_edge) labels_qz, indices_qz = roi.extract_label_indices(label_array_qz) labels_qr, indices_qr = roi.extract_label_indices(label_array_qr) num_qz = len(np.unique(labels_qz)) num_qr = len(np.unique(labels_qr)) fig, ax = plt.subplots() if data is None: data = qr + qz im = ax.imshow(data, cmap="viridis", origin="lower") else: im = ax.imshow(data, cmap="viridis", origin="lower", norm=LogNorm(vmin=0.001, vmax=1e1)) imr = ax.imshow(label_array_qr, origin="lower", cmap="viridis", vmin=0.5, vmax=None) # ,interpolation='nearest',) imz = ax.imshow(label_array_qz, origin="lower", cmap="viridis", vmin=0.5, vmax=None) # ,interpolation='nearest',) caxr = fig.add_axes([0.81, 0.1, 0.03, 0.8]) # x,y, width, heigth cba = fig.colorbar(im, cax=caxr) ax.set_xlabel(r"$q_r$", fontsize=18) ax.set_ylabel(r"$q_z$", fontsize=18) zticks, zticks_label = get_qz_tick_label(qz, label_array_qz) # rticks,rticks_label = get_qr_tick_label(label_array_qr,inc_x0) rticks, rticks_label = zip(*sorted(zip(*get_qr_tick_label(qr, label_array_qr, inc_x0)))) stride = int(len(zticks) / 7) ax.set_yticks(zticks[::stride]) yticks = zticks_label[::stride] ax.set_yticklabels(yticks, fontsize=9) stride = int(len(rticks) / 7) ax.set_xticks(rticks[::stride]) xticks = rticks_label[::stride] ax.set_xticklabels(xticks, fontsize=9) ax.set_title("Q-zr_Map", y=1.03, fontsize=18) plt.show() return zticks, zticks_label, rticks, rticks_label
def autocor_one_time( num_buf, ring_mask, imgs, num_lev=None, start_img=None, end_img=None, bad_images = None, threshold=None): start_time = time.time() #print (dly) if start_img is None: start_img=0 if end_img is None: try: end_img= len(imgs) except: end_img= imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) if num_lev is None:num_lev = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 nolev = num_lev nobuf =num_buf print ( 'The lev number is %s'%num_lev) dly, dict_dly = delays( num_lev, num_buf, time=1 ) #print (dly.max()) lev_leng = np.array( [ len( dict_dly[i] ) for i in list(dict_dly.keys()) ]) qind, pixelist = roi.extract_label_indices( ring_mask ) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs+1))[1:] nopixels = nopr.sum() start_time = time.time() buf = np.ma.zeros([num_lev,num_buf,nopixels]) buf.mask = True cts=np.zeros(num_lev) cur=np.ones(num_lev) * num_buf countl = np.array( np.zeros( num_lev ),dtype='int') g2 = np.zeros( [ noframes, noframes, noqs] ) G=np.zeros( [(nolev+1)*int(nobuf/2),noqs]) IAP=np.zeros( [(nolev+1)*int(nobuf/2),noqs]) IAF=np.zeros( [(nolev+1)*int(nobuf/2),noqs]) num= np.array( np.zeros( num_lev ),dtype='int') Num= { key: [0]* len( dict_dly[key] ) for key in list(dict_dly.keys()) } print ('Doing g2 caculation of %s frames---'%(noframes )) ttx=0 #if bad_images is None:bad_images=[] for n in range( start_img, end_img ): ##do the work here img = imgs[n] img_ = (np.ravel(img))[pixelist] #print ( img_.max() ) if threshold is not None: if img_.max() >= threshold: print ('bad image: %s here!'%n) img_ = np.ma.zeros( len(img_) ) img_.mask = True if bad_images is not None: if n in bad_images: print ('bad image: %s here!'%n) img_ = np.ma.zeros( len(img_) ) img_.mask = True cur[0]=1+cur[0]%num_buf # increment buffer buf[0, cur[0]-1 ]= img_ img=[] #//save space img_=[] countl[0] = 1+ countl[0] process_one_time(lev=0, bufno=cur[0]-1, G=G,IAP=IAP,IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly, Num=Num, lev_leng=lev_leng ) #time_ind[0].append( current_img_time ) processing=1 lev=1 while processing: if cts[lev]: prev= 1+ (cur[lev-1]-1-1+num_buf)%num_buf cur[lev]= 1+ cur[lev]%num_buf countl[lev] = 1+ countl[lev] bufa = buf[lev-1,prev-1] bufb= buf[lev-1,cur[lev-1]-1] if (bufa.data==0).all(): buf[lev,cur[lev]-1] = bufa elif (bufb.data==0).all(): buf[lev,cur[lev]-1] = bufb else: buf[lev,cur[lev]-1] = ( bufa + bufb ) /2. cts[lev]=0 t1_idx= (countl[lev]-1) *2 process_one_time(lev=lev, bufno=cur[lev]-1, G=G,IAP=IAP,IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly,Num =Num, lev_leng=lev_leng ) lev+=1 #//Since this level finished, test if there is a next level for processing if lev<num_lev:processing = 1 else:processing = 0 else: cts[lev]=1 #// set flag to process next time processing=0 #// can stop until more images are accumulated if n %(noframes/10) ==0: sys.stdout.write("#") sys.stdout.flush() #print G.shape if (len(np.where(IAP==0)[0])!=0) and ( 0 not in nopr): gmax = np.where(IAP==0)[0][0] else: gmax=IAP.shape[0] #g2=G/(IAP*IAF) #print G g2=(G[:gmax]/(IAP[:gmax]*IAF[:gmax])) elapsed_time = time.time() - start_time #print (Num) print ('Total time: %.2f min' %(elapsed_time/60.)) return g2,dly[:gmax] #, elapsed_time/60.
def multi_tau_auto_corr(num_levels, num_bufs, labels, images): ##comments, please add start_image, end_image, the default as None from skxray.core import roi from skxray.core import utils as core """ This function computes one-time correlations. It uses a scheme to achieve long-time correlations inexpensively by downsampling the data, iteratively combining successive frames. The longest lag time computed is num_levels * num_bufs. Parameters ---------- num_levels : int how many generations of downsampling to perform, i.e., the depth of the binomial tree of averaged frames num_bufs : int, must be even maximum lag step to compute in each generation of downsampling labels : array labeled array of the same shape as the image stack; each ROI is represented by a distinct label (i.e., integer) images : iterable of 2D arrays dimensions are: (rr, cc) Returns ------- g2 : array matrix of normalized intensity-intensity autocorrelation shape (num_levels, number of labels(ROI)) lag_steps : array delay or lag steps for the multiple tau analysis shape num_levels Notes ----- The normalized intensity-intensity time-autocorrelation function is defined as :math :: g_2(q, t') = \frac{<I(q, t)I(q, t + t')> }{<I(q, t)>^2} ; t' > 0 Here, I(q, t) refers to the scattering strength at the momentum transfer vector q in reciprocal space at time t, and the brackets <...> refer to averages over time t. The quantity t' denotes the delay time This implementation is based on code in the language Yorick by Mark Sutton, based on published work. [1]_ References ---------- .. [1] D. Lumma, L. B. Lurio, S. G. J. Mochrie and M. Sutton, "Area detector based photon correlation in the regime of short data batches: Data reduction for dynamic x-ray scattering," Rev. Sci. Instrum., vol 70, p 3274-3289, 2000. """ # In order to calculate correlations for `num_bufs`, images must be # kept for up to the maximum lag step. These are stored in the array # buffer. This algorithm only keeps number of buffers and delays but # several levels of delays number of levels are kept in buf. Each # level has twice the delay times of the next lower one. To save # needless copying, of cyclic storage of images in buf is used. if num_bufs % 2 != 0: raise ValueError("number of channels(number of buffers) in " "multiple-taus (must be even)") if hasattr(images, 'frame_shape'): # Give a user-friendly error if we can detect the shape from pims. if labels.shape != images.frame_shape: raise ValueError("Shape of the image stack should be equal to" " shape of the labels array") # get the pixels in each label label_mask, pixel_list = roi.extract_label_indices(labels) num_rois = np.max(label_mask) # number of pixels per ROI num_pixels = np.bincount(label_mask, minlength=(num_rois + 1)) num_pixels = num_pixels[1:] if np.any(num_pixels == 0): raise ValueError("Number of pixels of the required roi's" " cannot be zero, " "num_pixels = {0}".format(num_pixels)) # G holds the un normalized auto-correlation result. We # accumulate computations into G as the algorithm proceeds. G = np.zeros(((num_levels + 1) * num_bufs / 2, num_rois), dtype=np.float64) # matrix of past intensity normalizations past_intensity_norm = np.zeros(((num_levels + 1) * num_bufs / 2, num_rois), dtype=np.float64) # matrix of future intensity normalizations future_intensity_norm = np.zeros( ((num_levels + 1) * num_bufs / 2, num_rois), dtype=np.float64) # Ring buffer, a buffer with periodic boundary conditions. # Images must be keep for up to maximum delay in buf. buf = np.zeros((num_levels, num_bufs, np.sum(num_pixels)), dtype=np.float64) # to track processing each level track_level = np.zeros(num_levels) # to increment buffer cur = np.ones(num_levels, dtype=np.int64) # to track how many images processed in each level img_per_level = np.zeros(num_levels, dtype=np.int64) start_time = time.time() # used to log the computation time (optionally) for n, img in enumerate(images): cur[0] = (1 + cur[0]) % num_bufs # increment buffer # Put the image into the ring buffer. buf[0, cur[0] - 1] = (np.ravel(img))[pixel_list] # Compute the correlations between the first level # (undownsampled) frames. This modifies G, # past_intensity_norm, future_intensity_norm, # and img_per_level in place! _process(buf, G, past_intensity_norm, future_intensity_norm, label_mask, num_bufs, num_pixels, img_per_level, level=0, buf_no=cur[0] - 1) # check whether the number of levels is one, otherwise # continue processing the next level processing = num_levels > 1 # Compute the correlations for all higher levels. level = 1 while processing: if not track_level[level]: track_level[level] = 1 processing = False else: prev = 1 + (cur[level - 1] - 2) % num_bufs cur[level] = 1 + cur[level] % num_bufs buf[level, cur[level] - 1] = (buf[level - 1, prev - 1] + buf[level - 1, cur[level - 1] - 1]) / 2 # make the track_level zero once that level is processed track_level[level] = 0 # call the _process function for each multi-tau level # for multi-tau levels greater than one # Again, this is modifying things in place. See comment # on previous call above. _process( buf, G, past_intensity_norm, future_intensity_norm, label_mask, num_bufs, num_pixels, img_per_level, level=level, buf_no=cur[level] - 1, ) level += 1 # Checking whether there is next level for processing processing = level < num_levels # ending time for the process end_time = time.time() logger.info("Processing time for {0} images took {1} seconds." "".format(n, (end_time - start_time))) # the normalization factor if len(np.where(past_intensity_norm == 0)[0]) != 0: g_max = np.where(past_intensity_norm == 0)[0][0] else: g_max = past_intensity_norm.shape[0] # g2 is normalized G g2 = (G[:g_max] / (past_intensity_norm[:g_max] * future_intensity_norm[:g_max])) # Convert from num_levels, num_bufs to lag frames. tot_channels, lag_steps = core.multi_tau_lags(num_levels, num_bufs) lag_steps = lag_steps[:g_max] return g2, lag_steps
def xsvs(image_sets, label_array, number_of_img, timebin_num=2, time_bin=None, max_cts=None, bad_images=None, threshold=None): """ This function will provide the probability density of detecting photons for different integration times. The experimental probability density P(K) of detecting photons K is obtained by histogramming the speckle counts over an ensemble of equivalent pixels and over a number of speckle patterns recorded with the same integration time T under the same condition. Parameters ---------- image_sets : array sets of images label_array : array labeled array; 0 is background. Each ROI is represented by a distinct label (i.e., integer). number_of_img : int number of images (how far to go with integration times when finding the time_bin, using skxray.utils.geometric function) timebin_num : int, optional integration time; default is 2 max_cts : int, optional the brightest pixel in any ROI in any image in the image set. defaults to using skxray.core.roi.roi_max_counts to determine the brightest pixel in any of the ROIs bad_images: array, optional the bad images number list, the XSVS will not analyze the binning image groups which involve any bad images threshold: float, optional If one image involves a pixel with intensity above threshold, such image will be considered as a bad image. Returns ------- prob_k_all : array probability density of detecting photons prob_k_std_dev : array standard deviation of probability density of detecting photons Notes ----- These implementation is based on following references References: text [1]_, text [2]_ .. [1] L. Li, P. Kwasniewski, D. Oris, L Wiegart, L. Cristofolini, C. Carona and A. Fluerasu , "Photon statistics and speckle visibility spectroscopy with partially coherent x-rays" J. Synchrotron Rad., vol 21, p 1288-1295, 2014. .. [2] R. Bandyopadhyay, A. S. Gittings, S. S. Suh, P.K. Dixon and D.J. Durian "Speckle-visibilty Spectroscopy: A tool to study time-varying dynamics" Rev. Sci. Instrum. vol 76, p 093110, 2005. There is an example in https://github.com/scikit-xray/scikit-xray-examples It will demonstrate the use of these functions in this module for experimental data. """ if max_cts is None: max_cts = roi.roi_max_counts(image_sets, label_array) # find the label's and pixel indices for ROI's labels, indices = roi.extract_label_indices(label_array) nopixels = len(indices) # number of ROI's u_labels = list(np.unique(labels)) num_roi = len(u_labels) # create integration times if time_bin is None: time_bin = geometric_series(timebin_num, number_of_img) # number of times in the time bin num_times = len(time_bin) # number of pixels per ROI num_pixels = np.bincount(labels, minlength=(num_roi + 1))[1:] # probability density of detecting photons prob_k_all = np.zeros([num_times, num_roi], dtype=np.object) # square of probability density of detecting photons prob_k_pow_all = np.zeros_like(prob_k_all) # standard deviation of probability density of detecting photons prob_k_std_dev = np.zeros_like(prob_k_all) # get the bin edges for each time bin for each ROI bin_edges = np.zeros(prob_k_all.shape[0], dtype=prob_k_all.dtype) for i in range(num_times): bin_edges[i] = np.arange(max_cts * 2**i) start_time = time.time() # used to log the computation time (optionally) for i, images in enumerate(image_sets): # Ring buffer, a buffer with periodic boundary conditions. # Images must be keep for up to maximum delay in buf. #buf = np.zeros([num_times, timebin_num], dtype=np.object) # matrix of buffers buf = np.ma.zeros([num_times, timebin_num, nopixels]) buf.mask = True # to track processing each time level track_level = np.zeros(num_times) track_bad_level = np.zeros(num_times) # to increment buffer cur = np.full(num_times, timebin_num) # to track how many images processed in each level img_per_level = np.zeros(num_times, dtype=np.int64) prob_k = np.zeros_like(prob_k_all) prob_k_pow = np.zeros_like(prob_k_all) try: noframes = len(images) except: noframes = images.length #Num= { key: [0]* len( dict_dly[key] ) for key in list(dict_dly.keys()) } for n, img in enumerate(images): cur[0] = 1 + cur[0] % timebin_num # read each frame # Put the image into the ring buffer. img_ = (np.ravel(img))[indices] if threshold is not None: if img_.max() >= threshold: print('bad image: %s here!' % n) img_ = np.ma.zeros(len(img_)) img_.mask = True if bad_images is not None: if n in bad_images: print('bad image: %s here!' % n) img_ = np.ma.zeros(len(img_)) img_.mask = True buf[0, cur[0] - 1] = img_ _process(num_roi, 0, cur[0] - 1, buf, img_per_level, labels, max_cts, bin_edges[0], prob_k, prob_k_pow, track_bad_level) #print (0, img_per_level) # check whether the number of levels is one, otherwise # continue processing the next level level = 1 processing = 1 #print ('track_level: %s'%track_level) #while level < num_times: #if not track_level[level]: #track_level[level] = 1 while processing: if track_level[level]: prev = 1 + (cur[level - 1] - 2) % timebin_num cur[level] = 1 + cur[level] % timebin_num bufa = buf[level - 1, prev - 1] bufb = buf[level - 1, cur[level - 1] - 1] if (bufa.data == 0).all(): buf[level, cur[level] - 1] = bufa elif (bufb.data == 0).all(): buf[level, cur[level] - 1] = bufb else: buf[level, cur[level] - 1] = bufa + bufb #print (level, cur[level]-1) track_level[level] = 0 _process(num_roi, level, cur[level] - 1, buf, img_per_level, labels, max_cts, bin_edges[level], prob_k, prob_k_pow, track_bad_level) level += 1 if level < num_times: processing = 1 else: processing = 0 else: track_level[level] = 1 processing = 0 #print ('track_level: %s'%track_level) if noframes >= 10 and n % (int(noframes / 10)) == 0: sys.stdout.write("#") sys.stdout.flush() prob_k_all += (prob_k - prob_k_all) / (i + 1) prob_k_pow_all += (prob_k_pow - prob_k_pow_all) / (i + 1) prob_k_std_dev = np.power((prob_k_pow_all - np.power(prob_k_all, 2)), .5) for i in range(num_times): if isinstance(prob_k_all[i, 0], float): for j in range(len(u_labels)): prob_k_all[i, j] = np.array([0] * (len(bin_edges[i]) - 1)) prob_k_std_dev[i, j] = np.array([0] * (len(bin_edges[i]) - 1)) logger.info("Processing time for XSVS took %s seconds." "", (time.time() - start_time)) elapsed_time = time.time() - start_time #print (Num) print('Total time: %.2f min' % (elapsed_time / 60.)) #print (img_per_level - track_bad_level) #print (buf) return prob_k_all, prob_k_std_dev
def auto_two_Array_g1_norm(data, rois, data_pixel=None): ''' Dec 16, 2015, Y.G.@CHX a numpy operation method to get two-time correlation function with a normalization the purpose for this fucntion is to get a exactly same result as one-time correlation function Parameters: data: images sequence, shape as [img[0], img[1], imgs_length] rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs Options: data_pixel: if not None, 2-D array, shape as (len(images), len(qind)), use function Get_Pixel_Array( ).get_data( ) to get Return: g12b_norm: a 3-D array, shape as ( imgs_length, imgs_length, q), a convention two-time correlation functio same as obtained by auto_two_Array( data, roi, data_pixel=None ) g12b: a 3-D array, shape as ( imgs_length, imgs_length, q), a non-normlized two-time correlation function norms: a 2-D array, shape as ( imgs_length, q), a normalization for further get one-time from two time One example: g12b_norm, g12b_not_norm, norms = auto_two_Array_g1_norm( imgsr, ring_mask, data_pixel = data_pixel ) ''' start_time = time.time() qind, pixelist = roi.extract_label_indices(rois) noqs = len(np.unique(qind)) nopr = np.bincount(qind, minlength=(noqs + 1))[1:] if data_pixel is None: data_pixel = Get_Pixel_Array(data, pixelist).get_data() #print (data_pixel.shape) try: noframes = len(data) except: noframes = data.length g12b_norm = np.zeros([noframes, noframes, noqs]) g12b = np.zeros([noframes, noframes, noqs]) norms = np.zeros([noframes, noqs]) Unitq = (noqs / 10) proi = 0 for qi in range(1, noqs + 1): pixelist_qi = np.where(qind == qi)[0] #print (pixelist_qi.shape, data_pixel[qi].shape) data_pixel_qi = data_pixel[:, pixelist_qi] sum1 = (np.average(data_pixel_qi, axis=1)).reshape(1, noframes) sum2 = sum1.T #norms_g12 = sum1 * sum2 * nopr[qi -1] norms[:, qi - 1] = sum1 g12b[:, :, qi - 1] = np.dot(data_pixel_qi, data_pixel_qi.T) g12b_norm[:, :, qi - 1] = g12b[:, :, qi - 1] / sum1 / sum2 / nopr[qi - 1] #print ( proi, int( qi //( Unitq) ) ) if int(qi // (Unitq)) == proi: sys.stdout.write("#") sys.stdout.flush() proi += 1 elapsed_time = time.time() - start_time print('Total time: %.2f min' % (elapsed_time / 60.)) return g12b_norm, g12b, norms
def auto_two_Array(data, rois, data_pixel=None): ''' Dec 16, 2015, Y.G.@CHX a numpy operation method to get two-time correlation function Parameters: data: images sequence, shape as [img[0], img[1], imgs_length] rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs Options: data_pixel: if not None, 2-D array, shape as (len(images), len(qind)), use function Get_Pixel_Array( ).get_data( ) to get Return: g12: a 3-D array, shape as ( imgs_length, imgs_length, q) One example: g12 = auto_two_Array( imgsr, ring_mask, data_pixel = data_pixel ) ''' start_time = time.time() qind, pixelist = roi.extract_label_indices(rois) noqs = len(np.unique(qind)) nopr = np.bincount(qind, minlength=(noqs + 1))[1:] if data_pixel is None: data_pixel = Get_Pixel_Array(data, pixelist).get_data() #print (data_pixel.shape) try: noframes = len(data) except: noframes = data.length g12b = np.zeros([noframes, noframes, noqs]) Unitq = (noqs / 10) proi = 0 for qi in range(1, noqs + 1): pixelist_qi = np.where(qind == qi)[0] #print (pixelist_qi.shape, data_pixel[qi].shape) data_pixel_qi = data_pixel[:, pixelist_qi] sum1 = (np.average(data_pixel_qi, axis=1)).reshape(1, noframes) sum2 = sum1.T g12b[:, :, qi - 1] = np.dot( data_pixel_qi, data_pixel_qi.T) / sum1 / sum2 / nopr[qi - 1] #print ( proi, int( qi //( Unitq) ) ) if int(qi // (Unitq)) == proi: sys.stdout.write("#") sys.stdout.flush() proi += 1 elapsed_time = time.time() - start_time print('Total time: %.2f min' % (elapsed_time / 60.)) return g12b
def autocor_one_time(num_buf, rois, imgs, num_lev=None, start_img=None, end_img=None, bad_images=None, threshold=None): ''' Dec 16, 2015, Y.G.@CHX a multi-tau code for one-time correlation function, add new funciton to deal with bad images, which masked intensities are still large than threshold Parameters: num_buf: int, number of buffer rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs imgs: pims sequences, image stack Options: num_lev: int, number of level, if None: = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 start_img: int, None, =0 end_img: int, None, = len(imgs) bad_images: list, None,bad_images list threshold: float, None, intensity max threshold, above which is considered as bad images Return: g2, 2D-array, shape as (tau, q) tau, 1D-array One example: g2, tau = autocor_one_time( num_buf, ring_mask, imgsr, num_lev=None, bad_images=None, threshold= 65500 ) ''' start_time = time.time() #print (dly) if start_img is None: start_img = 0 if end_img is None: try: end_img = len(imgs) except: end_img = imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) ring_mask = rois if num_lev is None: num_lev = int(np.log(noframes / (num_buf - 1)) / np.log(2) + 1) + 1 nolev = num_lev nobuf = num_buf print('The lev number is %s' % num_lev) dly, dict_dly = delays(num_lev, num_buf, time=1) #print (dly.max()) lev_leng = np.array([len(dict_dly[i]) for i in list(dict_dly.keys())]) qind, pixelist = roi.extract_label_indices(ring_mask) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs + 1))[1:] nopixels = nopr.sum() start_time = time.time() buf = np.ma.zeros([num_lev, num_buf, nopixels]) buf.mask = True cts = np.zeros(num_lev) cur = np.ones(num_lev) * num_buf countl = np.array(np.zeros(num_lev), dtype='int') g2 = np.zeros([noframes, noframes, noqs]) G = np.zeros([(nolev + 1) * int(nobuf / 2), noqs]) IAP = np.zeros([(nolev + 1) * int(nobuf / 2), noqs]) IAF = np.zeros([(nolev + 1) * int(nobuf / 2), noqs]) num = np.array(np.zeros(num_lev), dtype='int') Num = {key: [0] * len(dict_dly[key]) for key in list(dict_dly.keys())} print('Doing g2 caculation of %s frames---' % (noframes)) ttx = 0 #if bad_images is None:bad_images=[] for n in range(start_img, end_img): ##do the work here img = imgs[n] #for n, img in enumerate( imgs): img_ = (np.ravel(img))[pixelist] #print ( img_.max() ) if threshold is not None: if img_.max() >= threshold: print('bad image: %s here!' % n) img_ = np.ma.zeros(len(img_)) img_.mask = True if bad_images is not None: if n in bad_images: print('bad image: %s here!' % n) img_ = np.ma.zeros(len(img_)) img_.mask = True cur[0] = 1 + cur[0] % num_buf # increment buffer buf[0, cur[0] - 1] = img_ img = [] #//save space img_ = [] countl[0] = 1 + countl[0] process_one_time(lev=0, bufno=cur[0] - 1, G=G, IAP=IAP, IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly, Num=Num, lev_leng=lev_leng) #time_ind[0].append( current_img_time ) processing = 1 lev = 1 while processing: if cts[lev]: prev = 1 + (cur[lev - 1] - 1 - 1 + num_buf) % num_buf cur[lev] = 1 + cur[lev] % num_buf countl[lev] = 1 + countl[lev] bufa = buf[lev - 1, prev - 1] bufb = buf[lev - 1, cur[lev - 1] - 1] if (bufa.data == 0).all(): buf[lev, cur[lev] - 1] = bufa elif (bufb.data == 0).all(): buf[lev, cur[lev] - 1] = bufb else: buf[lev, cur[lev] - 1] = (bufa + bufb) / 2. cts[lev] = 0 t1_idx = (countl[lev] - 1) * 2 process_one_time(lev=lev, bufno=cur[lev] - 1, G=G, IAP=IAP, IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly, Num=Num, lev_leng=lev_leng) lev += 1 #//Since this level finished, test if there is a next level for processing if lev < num_lev: processing = 1 else: processing = 0 else: cts[lev] = 1 #// set flag to process next time processing = 0 #// can stop until more images are accumulated if n % (int(noframes / 10)) == 0: sys.stdout.write("#") sys.stdout.flush() #print G.shape if (len(np.where(IAP == 0)[0]) != 0) and (0 not in nopr): gmax = np.where(IAP == 0)[0][0] else: gmax = IAP.shape[0] #g2=G/(IAP*IAF) #print G g2 = (G[:gmax] / (IAP[:gmax] * IAF[:gmax])) elapsed_time = time.time() - start_time #print (Num) print('Total time: %.2f min' % (elapsed_time / 60.)) return g2, dly[:gmax] #, elapsed_time/60.
def autocor_two_time(num_buf, rois, imgs, num_lev=None, start_img=None, end_img=None): ''' Dec 16, 2015, Y.G.@CHX a multi-tau code for two-time correlation function Parameters: num_buf: int, number of buffer rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs imgs: pims sequences, image stack Options: num_lev: int, number of level, if None: = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 start_img: int, None, =0 end_img: int, None, = len(imgs) #to be done to deal with bad frames #bad_images: list, None,bad_images list #threshold: float, None, intensity max threshold, above which is considered as bad images Return: g12, 3D-array, shape as ( len(imgs), len(imgs), q) One example: g12 = autocor_two_time( num_buf, ring_mask, imgsr, num_lev=None ) ''' #print (dly) if start_img is None: start_img = 0 if end_img is None: try: end_img = len(imgs) except: end_img = imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) ring_mask = rois if num_lev is None: num_lev = int(np.log(noframes / (num_buf - 1)) / np.log(2) + 1) + 1 print('The lev number is %s' % num_lev) dly, dict_dly = delays(num_lev, num_buf, time=1) #print (dly.max()) qind, pixelist = roi.extract_label_indices(ring_mask) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs + 1))[1:] nopixels = nopr.sum() start_time = time.time() buf = np.zeros([num_lev, num_buf, nopixels]) #// matrix of buffers, for store img cts = np.zeros(num_lev) cur = np.ones(num_lev) * num_buf countl = np.array(np.zeros(num_lev), dtype='int') g12 = np.zeros([noframes, noframes, noqs]) num = np.array(np.zeros(num_lev), dtype='int') time_ind = {key: [] for key in range(num_lev)} ttx = 0 for n in range(start_img, end_img): ##do the work here cur[0] = 1 + cur[0] % num_buf # increment buffer img = imgs[n] #print ( 'The insert image is %s' %(n) ) buf[0, cur[0] - 1] = (np.ravel(img))[pixelist] img = [] #//save space countl[0] = 1 + countl[0] current_img_time = n - start_img + 1 process_two_time(lev=0, bufno=cur[0] - 1, n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) time_ind[0].append(current_img_time) processing = 1 lev = 1 while processing: if cts[lev]: prev = 1 + (cur[lev - 1] - 1 - 1 + num_buf) % num_buf cur[lev] = 1 + cur[lev] % num_buf countl[lev] = 1 + countl[lev] buf[lev, cur[lev] - 1] = (buf[lev - 1, prev - 1] + buf[lev - 1, cur[lev - 1] - 1]) / 2. cts[lev] = 0 t1_idx = (countl[lev] - 1) * 2 current_img_time = ((time_ind[lev - 1])[t1_idx] + (time_ind[lev - 1])[t1_idx + 1]) / 2. time_ind[lev].append(current_img_time) process_two_time(lev=lev, bufno=cur[lev] - 1, n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) lev += 1 #//Since this level finished, test if there is a next level for processing if lev < num_lev: processing = 1 else: processing = 0 else: cts[lev] = 1 #// set flag to process next time processing = 0 #// can stop until more images are accumulated if n % (noframes / 10) == 0: sys.stdout.write("#") sys.stdout.flush() for q in range(noqs): x0 = g12[:, :, q] g12[:, :, q] = np.tril(x0) + np.tril(x0).T - np.diag(np.diag(x0)) elapsed_time = time.time() - start_time print('Total time: %.2f min' % (elapsed_time / 60.)) return g12, elapsed_time / 60.
def xsvs(image_sets, label_array, number_of_img, timebin_num=2, max_cts=None, bad_images = None, threshold=None): """ This function will provide the probability density of detecting photons for different integration times. The experimental probability density P(K) of detecting photons K is obtained by histogramming the speckle counts over an ensemble of equivalent pixels and over a number of speckle patterns recorded with the same integration time T under the same condition. Parameters ---------- image_sets : array sets of images label_array : array labeled array; 0 is background. Each ROI is represented by a distinct label (i.e., integer). number_of_img : int number of images (how far to go with integration times when finding the time_bin, using skxray.utils.geometric function) timebin_num : int, optional integration time; default is 2 max_cts : int, optional the brightest pixel in any ROI in any image in the image set. defaults to using skxray.core.roi.roi_max_counts to determine the brightest pixel in any of the ROIs bad_images: array, optional the bad images number list, the XSVS will not analyze the binning image groups which involve any bad images threshold: float, optional If one image involves a pixel with intensity above threshold, such image will be considered as a bad image. Returns ------- prob_k_all : array probability density of detecting photons prob_k_std_dev : array standard deviation of probability density of detecting photons Notes ----- These implementation is based on following references References: text [1]_, text [2]_ .. [1] L. Li, P. Kwasniewski, D. Oris, L Wiegart, L. Cristofolini, C. Carona and A. Fluerasu , "Photon statistics and speckle visibility spectroscopy with partially coherent x-rays" J. Synchrotron Rad., vol 21, p 1288-1295, 2014. .. [2] R. Bandyopadhyay, A. S. Gittings, S. S. Suh, P.K. Dixon and D.J. Durian "Speckle-visibilty Spectroscopy: A tool to study time-varying dynamics" Rev. Sci. Instrum. vol 76, p 093110, 2005. There is an example in https://github.com/scikit-xray/scikit-xray-examples It will demonstrate the use of these functions in this module for experimental data. """ if max_cts is None: max_cts = roi.roi_max_counts(image_sets, label_array) # find the label's and pixel indices for ROI's labels, indices = roi.extract_label_indices(label_array) # number of ROI's u_labels = list(np.unique(labels)) num_roi = len(u_labels) # create integration times time_bin = geometric_series(timebin_num, number_of_img) # number of times in the time bin num_times = len(time_bin) # number of pixels per ROI num_pixels = np.bincount(labels, minlength=(num_roi+1))[1:] # probability density of detecting photons prob_k_all = np.zeros([num_times, num_roi], dtype=np.object) # square of probability density of detecting photons prob_k_pow_all = np.zeros_like(prob_k_all) # standard deviation of probability density of detecting photons prob_k_std_dev = np.zeros_like(prob_k_all) # get the bin edges for each time bin for each ROI bin_edges = np.zeros(prob_k_all.shape[0], dtype=prob_k_all.dtype) for i in range(num_times): bin_edges[i] = np.arange(max_cts*2**i) start_time = time.time() # used to log the computation time (optionally) for i, images in enumerate(image_sets): # Ring buffer, a buffer with periodic boundary conditions. # Images must be keep for up to maximum delay in buf. buf = np.zeros([num_times, timebin_num], dtype=np.object) # matrix of buffers # to track processing each time level track_level = np.zeros( num_times ) # to increment buffer cur = np.full(num_times, timebin_num) # to track how many images processed in each level img_per_level = np.zeros(num_times, dtype=np.int64) prob_k = np.zeros_like(prob_k_all) prob_k_pow = np.zeros_like(prob_k_all) try: noframes= len(images) except: noframes= images.length #Num= { key: [0]* len( dict_dly[key] ) for key in list(dict_dly.keys()) } for n, img in enumerate(images): cur[0] = 1 + cur[0]% timebin_num # read each frame # Put the image into the ring buffer. buf[0, cur[0] - 1] = (np.ravel(img))[indices] #print (n, cur[0]-1) #print (buf.shape) _process(num_roi, 0, cur[0] - 1, buf, img_per_level, labels, max_cts, bin_edges[0], prob_k, prob_k_pow) #print (0, img_per_level) # check whether the number of levels is one, otherwise # continue processing the next level level = 1 processing=1 #print ('track_level: %s'%track_level) #while level < num_times: #if not track_level[level]: #track_level[level] = 1 while processing: if track_level[level]: prev = 1 + (cur[level - 1] - 2) % timebin_num cur[level] = 1 + cur[level] % timebin_num buf[level, cur[level]-1] = (buf[level-1, prev-1] + buf[level-1, cur[level - 1] - 1]) #print (level, cur[level]-1) track_level[level] = 0 _process(num_roi, level, cur[level]-1, buf, img_per_level, labels, max_cts, bin_edges[level], prob_k, prob_k_pow) level += 1 if level < num_times:processing = 1 else:processing = 0 else: track_level[level] = 1 processing = 0 #print ('track_level: %s'%track_level) if n %( int(noframes/10) ) ==0: sys.stdout.write("#") sys.stdout.flush() prob_k_all += (prob_k - prob_k_all)/(i + 1) prob_k_pow_all += (prob_k_pow - prob_k_pow_all)/(i + 1) prob_k_std_dev = np.power((prob_k_pow_all - np.power(prob_k_all, 2)), .5) logger.info("Processing time for XSVS took %s seconds." "", (time.time() - start_time)) elapsed_time = time.time() - start_time #print (Num) print ('Total time: %.2f min' %(elapsed_time/60.)) print (img_per_level) #print (buf) return prob_k_all, prob_k_std_dev
def autocor_two_time( num_buf, ring_mask, imgs, num_lev=None, start_img=None, end_img=None ): #print (dly) if start_img is None:start_img=0 if end_img is None: try: end_img= len(imgs) except: end_img= imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) if num_lev is None:num_lev = int(np.log( noframes/(num_buf-1))/np.log(2) +1) +1 print ( 'The lev number is %s'%num_lev) dly, dict_dly = delays( num_lev, num_buf, time=1 ) #print (dly.max()) qind, pixelist = roi.extract_label_indices( ring_mask ) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs+1))[1:] nopixels = nopr.sum() start_time = time.time() buf=np.zeros([num_lev,num_buf,nopixels]) #// matrix of buffers, for store img cts=np.zeros(num_lev) cur=np.ones(num_lev) * num_buf countl = np.array( np.zeros( num_lev ),dtype='int') g12 = np.zeros( [ noframes, noframes, noqs] ) num= np.array( np.zeros( num_lev ),dtype='int') time_ind ={key: [] for key in range(num_lev)} ttx=0 for n in range( start_img, end_img ): ##do the work here cur[0]=1+cur[0]%num_buf # increment buffer img = imgs[n] #print ( 'The insert image is %s' %(n) ) buf[0, cur[0]-1 ]= (np.ravel(img))[pixelist] img=[] #//save space countl[0] = 1+ countl[0] current_img_time = n - start_img +1 process_two_time(lev=0, bufno=cur[0]-1,n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) time_ind[0].append( current_img_time ) processing=1 lev=1 while processing: if cts[lev]: prev= 1+ (cur[lev-1]-1-1+num_buf)%num_buf cur[lev]= 1+ cur[lev]%num_buf countl[lev] = 1+ countl[lev] buf[lev,cur[lev]-1] = ( buf[lev-1,prev-1] + buf[lev-1,cur[lev-1]-1] ) /2. cts[lev]=0 t1_idx= (countl[lev]-1) *2 current_img_time = ((time_ind[lev-1])[t1_idx ] + (time_ind[lev-1])[t1_idx +1 ] )/2. time_ind[lev].append( current_img_time ) process_two_time(lev=lev, bufno=cur[lev]-1,n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) lev+=1 #//Since this level finished, test if there is a next level for processing if lev<num_lev:processing = 1 else:processing = 0 else: cts[lev]=1 #// set flag to process next time processing=0 #// can stop until more images are accumulated if n %(noframes/10) ==0: sys.stdout.write("#") sys.stdout.flush() for q in range(noqs): x0 = g12[:,:,q] g12[:,:,q] = np.tril(x0) + np.tril(x0).T - np.diag( np.diag(x0) ) elapsed_time = time.time() - start_time print ('Total time: %.2f min' %(elapsed_time/60.)) return g12, elapsed_time/60.
def auto_two_Array( data, rois, data_pixel=None ): ''' Dec 16, 2015, Y.G.@CHX a numpy operation method to get two-time correlation function Parameters: data: images sequence, shape as [img[0], img[1], imgs_length] rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs Options: data_pixel: if not None, 2-D array, shape as (len(images), len(qind)), use function Get_Pixel_Array( ).get_data( ) to get Return: g12: a 3-D array, shape as ( imgs_length, imgs_length, q) One example: g12 = auto_two_Array( imgsr, ring_mask, data_pixel = data_pixel ) ''' start_time = time.time() qind, pixelist = roi.extract_label_indices( rois ) noqs = len( np.unique(qind) ) nopr = np.bincount(qind, minlength=(noqs+1))[1:] if data_pixel is None: data_pixel = Get_Pixel_Array( data, pixelist).get_data() #print (data_pixel.shape) try: noframes = len(data) except: noframes = data.length g12b = np.zeros( [noframes, noframes, noqs] ) Unitq = (noqs/10) proi=0 for qi in range(1, noqs + 1 ): pixelist_qi = np.where( qind == qi)[0] #print (pixelist_qi.shape, data_pixel[qi].shape) data_pixel_qi = data_pixel[:,pixelist_qi] sum1 = (np.average( data_pixel_qi, axis=1)).reshape( 1, noframes ) sum2 = sum1.T g12b[:,:,qi -1 ] = np.dot( data_pixel_qi, data_pixel_qi.T) /sum1 / sum2 / nopr[qi -1] #print ( proi, int( qi //( Unitq) ) ) if int( qi //( Unitq) ) == proi: sys.stdout.write("#") sys.stdout.flush() proi += 1 elapsed_time = time.time() - start_time print ('Total time: %.2f min' %(elapsed_time/60.)) return g12b
def auto_two_Array_g1_norm( data, rois, data_pixel=None ): ''' Dec 16, 2015, Y.G.@CHX a numpy operation method to get two-time correlation function with a normalization the purpose for this fucntion is to get a exactly same result as one-time correlation function Parameters: data: images sequence, shape as [img[0], img[1], imgs_length] rois: 2-D array, the interested roi, has the same shape as image, can be rings for saxs, boxes for gisaxs Options: data_pixel: if not None, 2-D array, shape as (len(images), len(qind)), use function Get_Pixel_Array( ).get_data( ) to get Return: g12b_norm: a 3-D array, shape as ( imgs_length, imgs_length, q), a convention two-time correlation functio same as obtained by auto_two_Array( data, roi, data_pixel=None ) g12b: a 3-D array, shape as ( imgs_length, imgs_length, q), a non-normlized two-time correlation function norms: a 2-D array, shape as ( imgs_length, q), a normalization for further get one-time from two time One example: g12b_norm, g12b_not_norm, norms = auto_two_Array_g1_norm( imgsr, ring_mask, data_pixel = data_pixel ) ''' start_time = time.time() qind, pixelist = roi.extract_label_indices( rois ) noqs = len( np.unique(qind) ) nopr = np.bincount(qind, minlength=(noqs+1))[1:] if data_pixel is None: data_pixel = Get_Pixel_Array( data, pixelist).get_data() #print (data_pixel.shape) try: noframes = len(data) except: noframes = data.length g12b_norm = np.zeros( [noframes, noframes, noqs] ) g12b = np.zeros( [noframes, noframes, noqs] ) norms = np.zeros( [noframes, noqs] ) Unitq = (noqs/10) proi=0 for qi in range(1, noqs + 1 ): pixelist_qi = np.where( qind == qi)[0] #print (pixelist_qi.shape, data_pixel[qi].shape) data_pixel_qi = data_pixel[:,pixelist_qi] sum1 = (np.average( data_pixel_qi, axis=1)).reshape( 1, noframes ) sum2 = sum1.T #norms_g12 = sum1 * sum2 * nopr[qi -1] norms[:,qi -1 ] = sum1 g12b[:,:,qi -1 ] = np.dot( data_pixel_qi, data_pixel_qi.T) g12b_norm[:,:,qi -1 ] = g12b[:,:,qi -1 ]/ sum1 / sum2 / nopr[qi -1] #print ( proi, int( qi //( Unitq) ) ) if int( qi //( Unitq) ) == proi: sys.stdout.write("#") sys.stdout.flush() proi += 1 elapsed_time = time.time() - start_time print ('Total time: %.2f min' %(elapsed_time/60.)) return g12b_norm, g12b, norms
def autocor_one_time(num_buf, ring_mask, imgs, num_lev=None, start_img=None, end_img=None, bad_images=None, threshold=None): start_time = time.time() #print (dly) if start_img is None: start_img = 0 if end_img is None: try: end_img = len(imgs) except: end_img = imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) if num_lev is None: num_lev = int(np.log(noframes / (num_buf - 1)) / np.log(2) + 1) + 1 nolev = num_lev nobuf = num_buf print('The lev number is %s' % num_lev) dly, dict_dly = delays(num_lev, num_buf, time=1) #print (dly.max()) lev_leng = np.array([len(dict_dly[i]) for i in list(dict_dly.keys())]) qind, pixelist = roi.extract_label_indices(ring_mask) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs + 1))[1:] nopixels = nopr.sum() start_time = time.time() buf = np.ma.zeros([num_lev, num_buf, nopixels]) buf.mask = True cts = np.zeros(num_lev) cur = np.ones(num_lev) * num_buf countl = np.array(np.zeros(num_lev), dtype='int') g2 = np.zeros([noframes, noframes, noqs]) G = np.zeros([(nolev + 1) * int(nobuf / 2), noqs]) IAP = np.zeros([(nolev + 1) * int(nobuf / 2), noqs]) IAF = np.zeros([(nolev + 1) * int(nobuf / 2), noqs]) num = np.array(np.zeros(num_lev), dtype='int') Num = {key: [0] * len(dict_dly[key]) for key in list(dict_dly.keys())} print('Doing g2 caculation of %s frames---' % (noframes)) ttx = 0 #if bad_images is None:bad_images=[] for n in range(start_img, end_img): ##do the work here img = imgs[n] img_ = (np.ravel(img))[pixelist] #print ( img_.max() ) if threshold is not None: if img_.max() >= threshold: print('bad image: %s here!' % n) img_ = np.ma.zeros(len(img_)) img_.mask = True if bad_images is not None: if n in bad_images: print('bad image: %s here!' % n) img_ = np.ma.zeros(len(img_)) img_.mask = True cur[0] = 1 + cur[0] % num_buf # increment buffer buf[0, cur[0] - 1] = img_ img = [] #//save space img_ = [] countl[0] = 1 + countl[0] process_one_time(lev=0, bufno=cur[0] - 1, G=G, IAP=IAP, IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly, Num=Num, lev_leng=lev_leng) #time_ind[0].append( current_img_time ) processing = 1 lev = 1 while processing: if cts[lev]: prev = 1 + (cur[lev - 1] - 1 - 1 + num_buf) % num_buf cur[lev] = 1 + cur[lev] % num_buf countl[lev] = 1 + countl[lev] bufa = buf[lev - 1, prev - 1] bufb = buf[lev - 1, cur[lev - 1] - 1] if (bufa.data == 0).all(): buf[lev, cur[lev] - 1] = bufa elif (bufb.data == 0).all(): buf[lev, cur[lev] - 1] = bufb else: buf[lev, cur[lev] - 1] = (bufa + bufb) / 2. cts[lev] = 0 t1_idx = (countl[lev] - 1) * 2 process_one_time(lev=lev, bufno=cur[lev] - 1, G=G, IAP=IAP, IAF=IAF, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly, Num=Num, lev_leng=lev_leng) lev += 1 #//Since this level finished, test if there is a next level for processing if lev < num_lev: processing = 1 else: processing = 0 else: cts[lev] = 1 #// set flag to process next time processing = 0 #// can stop until more images are accumulated if n % (noframes / 10) == 0: sys.stdout.write("#") sys.stdout.flush() #print G.shape if (len(np.where(IAP == 0)[0]) != 0) and (0 not in nopr): gmax = np.where(IAP == 0)[0][0] else: gmax = IAP.shape[0] #g2=G/(IAP*IAF) #print G g2 = (G[:gmax] / (IAP[:gmax] * IAF[:gmax])) elapsed_time = time.time() - start_time #print (Num) print('Total time: %.2f min' % (elapsed_time / 60.)) return g2, dly[:gmax] #, elapsed_time/60.
roi_width = 9 # in pixels roi_spacing = (5.0, 4.0) x_center = 7. # in pixels y_center = (129.) # in pixels num_rings = 3 # get the edges of the rings edges = roi.ring_edges(roi_start, width=roi_width, spacing=roi_spacing, num_rings=num_rings) # get the label array from the ring shaped 3 region of interests(ROI's) labeled_roi_array = roi.rings( edges, (y_center, x_center), img_stack.shape[1:]) # extarct the ROI's lables and pixel indices corresponding to those labels roi_indices, pixel_list = roi.extract_label_indices(labeled_roi_array) # define the ROIs roi_start = 65 # in pixels roi_width = 9 # in pixels roi_spacing = (5.0, 4.0) x_center = 7. # in pixels y_center = (129.) # in pixels num_rings = 3 # get the edges of the rings edges = roi.ring_edges(roi_start, width=roi_width, spacing=roi_spacing, num_rings=num_rings) # get the label array from the ring shaped 3 region of interests(ROI's)
def autocor_two_time(num_buf, ring_mask, imgs, num_lev=None, start_img=None, end_img=None): #print (dly) if start_img is None: start_img = 0 if end_img is None: try: end_img = len(imgs) except: end_img = imgs.length #print (start_img, end_img) noframes = end_img - start_img #+ 1 #print (noframes) if num_lev is None: num_lev = int(np.log(noframes / (num_buf - 1)) / np.log(2) + 1) + 1 print('The lev number is %s' % num_lev) dly, dict_dly = delays(num_lev, num_buf, time=1) #print (dly.max()) qind, pixelist = roi.extract_label_indices(ring_mask) noqs = np.max(qind) nopr = np.bincount(qind, minlength=(noqs + 1))[1:] nopixels = nopr.sum() start_time = time.time() buf = np.zeros([num_lev, num_buf, nopixels]) #// matrix of buffers, for store img cts = np.zeros(num_lev) cur = np.ones(num_lev) * num_buf countl = np.array(np.zeros(num_lev), dtype='int') g12 = np.zeros([noframes, noframes, noqs]) num = np.array(np.zeros(num_lev), dtype='int') time_ind = {key: [] for key in range(num_lev)} ttx = 0 for n in range(start_img, end_img): ##do the work here cur[0] = 1 + cur[0] % num_buf # increment buffer img = imgs[n] #print ( 'The insert image is %s' %(n) ) buf[0, cur[0] - 1] = (np.ravel(img))[pixelist] img = [] #//save space countl[0] = 1 + countl[0] current_img_time = n - start_img + 1 process_two_time(lev=0, bufno=cur[0] - 1, n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) time_ind[0].append(current_img_time) processing = 1 lev = 1 while processing: if cts[lev]: prev = 1 + (cur[lev - 1] - 1 - 1 + num_buf) % num_buf cur[lev] = 1 + cur[lev] % num_buf countl[lev] = 1 + countl[lev] buf[lev, cur[lev] - 1] = (buf[lev - 1, prev - 1] + buf[lev - 1, cur[lev - 1] - 1]) / 2. cts[lev] = 0 t1_idx = (countl[lev] - 1) * 2 current_img_time = ((time_ind[lev - 1])[t1_idx] + (time_ind[lev - 1])[t1_idx + 1]) / 2. time_ind[lev].append(current_img_time) process_two_time(lev=lev, bufno=cur[lev] - 1, n=current_img_time, g12=g12, buf=buf, num=num, num_buf=num_buf, noqs=noqs, qind=qind, nopr=nopr, dly=dly) lev += 1 #//Since this level finished, test if there is a next level for processing if lev < num_lev: processing = 1 else: processing = 0 else: cts[lev] = 1 #// set flag to process next time processing = 0 #// can stop until more images are accumulated if n % (noframes / 10) == 0: sys.stdout.write("#") sys.stdout.flush() for q in range(noqs): x0 = g12[:, :, q] g12[:, :, q] = np.tril(x0) + np.tril(x0).T - np.diag(np.diag(x0)) elapsed_time = time.time() - start_time print('Total time: %.2f min' % (elapsed_time / 60.)) return g12, elapsed_time / 60.
def show_qzr_map(qr, qz, inc_x0, data=None, Nzline=10, Nrline=10): ''' Dec 16, 2015, Y.G.@CHX plot a qzr map of a gisaxs image (data) Parameters: qr: 2-D array, qr of a gisaxs image (data) qz: 2-D array, qz of a gisaxs image (data) inc_x0: the incident beam center x Options: data: 2-D array, a gisaxs image, if None, =qr+qz Nzline: int, z-line number Nrline: int, r-line number Return: zticks: list, z-tick positions in unit of pixel zticks_label: list, z-tick positions in unit of real space rticks: list, r-tick positions in unit of pixel rticks_label: list, r-tick positions in unit of real space Examples: ticks = show_qzr_map( qr, qz, inc_x0, data = None, Nzline=10, Nrline= 10 ) ticks = show_qzr_map( qr,qz, inc_x0, data = avg_imgmr, Nzline=10, Nrline=10 ) ''' import matplotlib.pyplot as plt import copy import matplotlib.cm as mcm cmap = 'viridis' _cmap = copy.copy((mcm.get_cmap(cmap))) _cmap.set_under('w', 0) qr_start, qr_end, qr_num = qr.min(), qr.max(), Nzline qz_start, qz_end, qz_num = qz.min(), qz.max(), Nrline qr_edge, qr_center = get_qedge(qr_start, qr_end, (qr_end - qr_start) / (qr_num + 100), qr_num) qz_edge, qz_center = get_qedge(qz_start, qz_end, (qz_end - qz_start) / (qz_num + 100), qz_num) label_array_qz = get_qmap_label(qz, qz_edge) label_array_qr = get_qmap_label(qr, qr_edge) labels_qz, indices_qz = roi.extract_label_indices(label_array_qz) labels_qr, indices_qr = roi.extract_label_indices(label_array_qr) num_qz = len(np.unique(labels_qz)) num_qr = len(np.unique(labels_qr)) fig, ax = plt.subplots() if data is None: data = qr + qz im = ax.imshow(data, cmap='viridis', origin='lower') else: im = ax.imshow(data, cmap='viridis', origin='lower', norm=LogNorm(vmin=0.001, vmax=1e1)) imr = ax.imshow(label_array_qr, origin='lower', cmap='viridis', vmin=0.5, vmax=None) #,interpolation='nearest',) imz = ax.imshow(label_array_qz, origin='lower', cmap='viridis', vmin=0.5, vmax=None) #,interpolation='nearest',) caxr = fig.add_axes([0.81, 0.1, 0.03, .8]) #x,y, width, heigth cba = fig.colorbar(im, cax=caxr) ax.set_xlabel(r'$q_r$', fontsize=18) ax.set_ylabel(r'$q_z$', fontsize=18) zticks, zticks_label = get_qz_tick_label(qz, label_array_qz) #rticks,rticks_label = get_qr_tick_label(label_array_qr,inc_x0) rticks, rticks_label = zip( *sorted(zip(*get_qr_tick_label(qr, label_array_qr, inc_x0)))) stride = int(len(zticks) / 7) ax.set_yticks(zticks[::stride]) yticks = zticks_label[::stride] ax.set_yticklabels(yticks, fontsize=9) stride = int(len(rticks) / 7) ax.set_xticks(rticks[::stride]) xticks = rticks_label[::stride] ax.set_xticklabels(xticks, fontsize=9) ax.set_title('Q-zr_Map', y=1.03, fontsize=18) plt.show() return zticks, zticks_label, rticks, rticks_label
roi_spacing = (5.0, 4.0) x_center = 7. # in pixels y_center = (129.) # in pixels num_rings = 3 # get the edges of the rings edges = roi.ring_edges(roi_start, width=roi_width, spacing=roi_spacing, num_rings=num_rings) # get the label array from the ring shaped 3 region of interests(ROI's) labeled_roi_array = roi.rings(edges, (y_center, x_center), img_stack.shape[1:]) # extarct the ROI's lables and pixel indices corresponding to those labels roi_indices, pixel_list = roi.extract_label_indices(labeled_roi_array) # define the ROIs roi_start = 65 # in pixels roi_width = 9 # in pixels roi_spacing = (5.0, 4.0) x_center = 7. # in pixels y_center = (129.) # in pixels num_rings = 3 # get the edges of the rings edges = roi.ring_edges(roi_start, width=roi_width, spacing=roi_spacing, num_rings=num_rings)