You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 19 Next »

Peakfinder

A set of peak-finding algorithms developed for analysis of data from LCLS pixel array detectors.

Interface

from ... import imagealgos

peaks = imagealgos.peaks_adapt_thr(data, mask, nsigm, rank, base_r, base_dr, do_base_sub=False, npix_min=None, npix_max=None, thr_atot=None, son_min=None)
peaks = imagealgos.peaks_two_thr(data, mask, thr_low, thr_high, rank, base_r, base_dr, do_base_sub=False, npix_min=None, npix_max=None, thr_atot=None, son_min=None)

Input

arguments:

data :

1) numpy.array, ndim=2  - 2-d data array for processing

2)  [numpy.array, ndim=2] - list of 2-d data arrays for processing

3) numpy.array , ndim>2 - a set of 2-d data arrays for processing; last two indexes are used as 2-d row and column, higher indexes compacted to the segment index


keyword arguments for peak finding:

mask : numpy.array (shape,dtype=np.uint16) | None - expected the same shape/structure as data - pixel mask with 0/1 for bad/good pixel

rank : int -  radial size of the region (2*rank+1 rows and columns) around pixel for peak finding

thr_low : float -  low threshold on pixel intensity for 'peaks_two_thr' finder

thr_high : float - high threshold on pixel intensity for 'peaks_two_thr' finder

base_r : float - internal radius of the ring for evaluation of base level mean and rms (noise)

base_dr : float - width of the ring for evaluation of base level mean and rms (noise)

nsigm : float - threshold in number of noise rms for peaks_adapt_thr


keyword arguments for peak selection:   
 

npix_min : int - minimum number of pixels in the peak  

npix_max : int - maximum number of pixels in the peak 

thr_atot : float - threshold on total peak intensity  

son_min : float - threshold on signal over noise (S/N) value

Output

peaks :

    • dict of arrays/lists - most natural to work with a single values for many peaks

peaks keywords:

    • seg : int - 2-d segment index beginning from 0, e.g. in CSPAD this index should be in the range from 0 to 31
    • row : int - row (beginning from 0) of the pixel with maximal intensity
    • col : int - column (beginning from 0) of the pixel with maximal intensity
    • npix : int - number of pixels accounted in the peak
    • amp_max : float - maximal intensity among peak pixels
    • amp_total : float - total intensity of pixels accounted in the peak
    • row_cgmean : float - row coordinate mean value evaluated in the "center of gravity" algorithm for pixels accounted in the peak using their intensities as weights
    • col_cgmean : float - column coordinate mean value evaluated in the "center of gravity" algorithm
    • raw_cgrms : float - row coordinate rms spread value evaluated in the "center of gravity" algorithm
    • col_cgrms : float - column coordinate rms spread value evaluated in the "center of gravity" algorithm
    • base : float - per pixel base level mean estimated for pixels in the ring region (parameters base_r, base_dr)  around peak center
    • noise : float - per pixel base level rms estimated for pixels in the ring region (parameters base_r, base_dr) around peak center
    • son : float - signal over noise ratio estimated as amp_total / (noise * sqrt(npix))
    • peak : list - of peak objects
      peak attributes:
      • pixinds : list - list of peak index tuple (row, col) for pixels accounted in the peak
      peak methods:
      • row_min() : int- minimal row of the pixel group accounted in the peak
      • row_max() : int- maximal row of the pixel group accounted in the peak
      • col_min() : int- minimal column of the pixel group accounted in the peak
      • col_max() : int- maximal column of the pixel group accounted in the peak
      • other methods of data processing for pixinds

Peak-finding algorithms

Method peakfinder is a wrapper around a few algorithms. First argument mode switches between different peak-finding algorithms. Each algorithm works in a few stages. First stage is a search for peak candidates or "seed" peaks and this is a most distinctive part between algorithms:

  • peaks_two_thr - or peak-finder is a two-threshold algorithm searching for groups of connected pixels with intensity above thr_low around group central pixel with intensity exceeding thr_high in the region restricted by the radial parameter rank. In the loop over all pixels each pixel with intensity grater or equal thr_high is considered as a peak candidate. For each candidate recursive algorithm is launched and searches for a group of connected pixels with intensity grater or equal thr_low in the square region with dimensions 2*rank+1 pixel in rows and columns. Pixels of the group are marked as busy on 2-d map and are not used for other groups. Central pixel of the peak candidate should have maximal intensity in the group of connected pixels, otherwise recursion is terminated and all group pixels released for further search. Two neighbor pixels with intensity above thr_low having common boarder are assumed connected. Two pixels having a single common vertex are assumed disconnected. Base level mean, bkgd, and, rms, noise values are evaluated for pixels in the ring with internal radius base_r and width base_dr around central pixel. Pixels with intensity above thr_low are excluded from evaluation of the base level parameters.
  • peaks_adapt_thr - searches peak candidates as group of connected pixels with intensity above dynamically estimated threshold around local intensity maximums of specified rank.  Maps of local maximums and minimums of specified rank are generated for data array. Parameter rank defines a square region with dimensions 2*rank+1 pixels in rows and columns around center pixel. Each local maximum is considered as a peak candidate. Its base level mean, bkgd, and rms , noise, values are evaluated using surrounding pixels in the ring with internal radius base_r and width base_dr. Pixels marked as local maximums and minimums (for symmetry) of specified rank in rows and columns are excluded in evaluation of the base level parameters. NOTE: due to excluded extremes the base level rms is under-estimated in this algorithm, so, set parameter nsigm wisely. Then, for each peak candidate local threshold parameter thr=bkgd+nsigm*noise (no exclusion for nsigm=0) is used. Recursive algorithm searches for the group of connected pixels with intensity above local threshold thr in the rank-restricted region.

Other stages of all algorithms are about the same.

  • returned values of  amp_max and amp_total are base level corrected by subtracting bkgd and bkgd*npix, respectively
  • signal over noise son is evaluated as amp_total / (noise * sqrt(npix)),
  • output list of peaks is generated from the list of seed peaks complying with selection parameters npix_min, npix_max, amax_thr, atot_thr, son_min .

Comments

  • Chuck: use specific methods in stead of single wrapper
  • Chris:
    • look at scipy optimize, skimage ransac
    • think about returning dictionary vs. object with attributes
    • consider make row_min a method
    • turn off background subtraction in intuitive way?  base_r=None or base_dr=None
    • vote to do v4 only for now
    • all kwarg
    • worry about seg
    • vote to only support 2D array, at least at beginning
    • add option to skip background correction
  • 2016-11-09 grp mtg (Chris, David, Wilko):
    • use meaningful parameters
    • separate arguments and keywards with default parameters
    • check input validity (i.e. pyvalid) that keyargs are not misspelled.
    • peaks - dict(arrays)

References


  • No labels