Metadata-Version: 2.1
Name: bccd
Version: 2.0.0
Summary: BNMR/BNQR Beamspot Image Viewer and Analysis
Home-page: https://github.com/dfujim/bccd
Author: Derek Fujimoto
Author-email: fujimoto@phas.ubc.ca
License: UNKNOWN
Description: # Draw and process BNMR CCD image files
        
        Object for reading and processing fits files taken by the BNMR or BNQR CCD camera.
        
        ## `bccd.fits`
        
        Constructor: 
        
        ```python
        fits(filename,rescale_pixels=True)
        ```
        
        Functions: 
            
        ```python
        
        # look for shapes in image
        detect_lines(sigma=1,min_length=50,min_gap=3,theta=None,nlines=np.inf,draw=True)
        detect_hlines(sigma=1,min_length=50,min_gap=3,nlines=np.inf,draw=True,**kwargs)
        detect_circles(rad_range,nlines=1,sigma=1,draw=True)
        
        # drawing and visualization
        draw(black=0,alpha=1,cmap='Greys',imap=True)
        draw_2Dfit(fn,*pars,levels=10,cmap='jet')
        draw_contour(nlevels=5,alpha=1,cmap='Greys',imap=True)
        draw_edges(sigma=1,alpha=1,cmap='Greys',imap=True) 
        draw_sobel(alpha=1,cmap='Greys',imap=False)
        
        # fitting
        fit2D(function,**fitargs)
        fit_gaussian2D(draw=True,**fitargs)
        
        # processing
        get_center(draw=True)
        get_cm(draw=True)
        get_gaussian2D_overlap(ylo,yhi,xlo,xhi)
        
        # worker functions
        read(filename,rescale_pixels=True)
        set_black(black)
        set_mask(mask)
        ```
        
        Data fields:
        
        ```
        black:          float, pixel value corresponding to black (zero)
        data:           2D numpy array, pixel values
        data_original:  numpy array, pixel values
        header:         dict, header information
        
        mask:           (x,y,r) specifying circle to mask on
        
        result_center:      (par,names) fitting results
        result_cm:          (par,names) center of mass results
        result_fit2D:       (par,cov) fitting results
        result_gaussian2D:  (par,cov,names) fitting results
        result_gaussian2D_overlap: float, overlap
        ```
        
        Some useful colourmap names:
        
        ```
            Greys
            Purples
            Yellows
            Blues
            Oranges
            Reds
            Greens
        ```
        
        Parameter descriptions
        
        ```
        alpha:          float, image transparency. Range: [0,1].
        black:          float, value to set to black, all pixels of lower value raised to this level. Use to
                        clean up noise. 
        
        cmap:           str, color map to color the image. Ex: "Reds", "Greens", etc.
        draw:           bool, if true, draw output
        filename:       str, path to .fits file
        fitargs:        **dict, arguments passed to curve_fit
        fn:             function handle, function to draw
        imap:           bool, if True, invert color map colours
        levels:         int, number of contour levels to draw
        kwargs:         **dict, unused
        mask:           tuple, exclude all pixels outside of circle from draw or calculation. (x0,y0,r)
        min_length:     float, minimum length of lines to find, in pixels
        min_gap:        float, maximum acceptable distance between line pixels which do not signify breaking
                        the line
        nlines:         int, number of shapes to find
        pars:           *tuple, parameters passed to fn. 
        rad_range:      tuple, radius range to seach in (r_lo, r_hi)
        rescale_pixels: bool, pixels are intrinsically asymmetric. Rescale image such that the pixels are 
                        square, interpolating pixel values with 3rd order spline. 
        shape:          tuple, shape of the image (number of pixels x,y)
        sigma:          float, standard deviation of rolling Gaussian filter, smoothing image features.
        theta:          float, list of acceptable angles for the lines to point
        
        xlo:              function handle, lower integration bound [inner]
        xlhi:             function handle, upper integration bound [inner]
        ylo:              float, lower integration bound [outer]
        yhi:              float, upper integration bound [outer]
        ```
        
        
        
        ## `bccd.functions`
        
        ```python
        gaussian2D(x,y,x0,y0,sigmax,sigmay,amp,theta=0)
        ```
        
        Parameter descriptions
        
        ```
        amp:              float, unused in favour of normalized amplitude (present for ease of use)
        sx,sy:            float, standard deviation
        theta:            float, angle of rotation                  
        x0,y0:            float, gaussian mean location
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
Classifier: Operating System :: POSIX :: Linux
Description-Content-Type: text/markdown
