# `pyFAI` Package

`pyFAI.__init__.``tests`()

# `azimuthalIntegrator` Module

class `pyFAI.azimuthalIntegrator.``AzimuthalIntegrator`(dist=1, poni1=0, poni2=0, rot1=0, rot2=0, rot3=0, pixel1=None, pixel2=None, splineFile=None, detector=None, wavelength=None)

  Bases: `pyFAI.geometry.Geometry`

  This class is an azimuthal integrator based on P. Boesecke’s geometry and histogram algorithm by Manolo S. del Rio and V.A Sole

  All geometry calculation are done in the Geometry class

  main methods are:

      >>> tth, I = ai.integrate1d(data, npt, unit="2th_deg")
      >>> q, I, sigma = ai.integrate1d(data, npt, unit="q_nm^-1", error_model="poisson")
      >>> regrouped = ai.integrate2d(data, npt_rad, npt_azim, unit="q_nm^-1")[0]

  `DEFAULT_METHOD` = 'splitbbox'
  `array_from_unit`(shape, typ='center', unit=2th_deg)

    Generate an array of position in different dimentions (R, Q, 2Theta)

    Parameters:

    - shape (ndarray.shape) – shape of the expected array
    - typ (str) – “center”, “corner” or “delta”
    - unit (pyFAI.units.Enum) – can be Q, TTH, R for now

    Returns: | R, Q or 2Theta array depending on unit
    Return type: | ndarray

  `create_mask`(data, mask=None, dummy=None, delta_dummy=None, mode='normal')

    Combines various masks into another one.

    Parameters:

    - data (ndarray) – input array of data
    - mask (ndarray) – input mask (if none, self.mask is used)
    - dummy (float) – value of dead pixels
    - delta_dumy – precision of dummy pixels
    - mode (str) – can be “normal” or “numpy” (inverted) or “where” applied to the mask

    Returns: | the new mask
    Return type: | ndarray of bool

    This method combine two masks (dynamic mask from data & dummy and mask) to generate a new one with the ‘or’ binary operation. One can adjust the level, with the dummy and the delta_dummy parameter, when you consider the data values needs to be masked out.

    This method can work in two different mode:

    > - “normal”: False for valid pixels, True for bad pixels
    > - “numpy”: True for valid pixels, false for others

    This method tries to accomodate various types of masks (like valid=0 & masked=-1, ...) and guesses if an input mask needs to be inverted.

  `dark_correction`(data, dark=None)

    Correct for Dark-current effects. If dark is not defined, correct for a dark set by “set_darkfiles”

    Parameters:

    - data – input ndarray with the image
    - dark – ndarray with dark noise or None

    Returns: | 2tuple: corrected_data, dark_actually used (or None)

  `darkcurrent`
  `empty`
  `flat_correction`(data, flat=None)

    Correct for flat field. If flat is not defined, correct for a flat set by “set_flatfiles”

    Parameters:

    - data – input ndarray with the image
    - dark – ndarray with dark noise or None

    Returns: | 2tuple: corrected_data, flat_actually used (or None)

  `flatfield`
  `get_darkcurrent`()
  `get_empty`()
  `get_flatfield`()
  `integrate1d`(data, npt, filename=None, correctSolidAngle=True, variance=None, error_model=None, radial_range=None, azimuth_range=None, mask=None, dummy=None, delta_dummy=None, polarization_factor=None, dark=None, flat=None, method='lut', unit=q_nm^-1, safe=True, normalization_factor=None, block_size=32, profile=False, all=False)

    Calculate the azimuthal integrated Saxs curve in q(nm^-1) by default

    Multi algorithm implementation (tries to be bullet proof), suitable for SAXS, WAXS, ... and much more

    Parameters:

    - data (ndarray) – 2D array from the Detector/CCD camera
    - npt (int) – number of points in the output pattern
    - filename (str) – output filename in 2/3 column ascii format
    - correctSolidAngle (bool) – correct for solid angle of each pixel if True
    - variance (ndarray) – array containing the variance of the data. If not available, no error propagation is done
    - error_model (str) – When the variance is unknown, an error model can be given: “poisson” (variance = I), “azimuthal” (variance = (I-<I>)^2)
    - radial_range ((float, float), optional) – The lower and upper range of the radial unit. If not provided, range is simply (data.min(), data.max()). Values outside the range are ignored.
    - azimuth_range ((float, float), optional) – The lower and upper range of the azimuthal angle in degree. If not provided, range is simply (data.min(), data.max()). Values outside the range are ignored.
    - mask (ndarray) – array (same size as image) with 1 for masked pixels, and 0 for valid pixels
    - dummy (float) – value for dead/masked pixels
    - delta_dummy (float) – precision for dummy value
    - polarization_factor (float) – polarization factor between -1 (vertical) and +1 (horizontal). 0 for circular polarization or random, None for no correction
    - dark (ndarray) – dark noise image
    - flat (ndarray) – flat field image
    - method (str) – can be “numpy”, “cython”, “BBox” or “splitpixel”, “lut”, “csr”, “nosplit_csr”, “full_csr”, “lut_ocl” and “csr_ocl” if you want to go on GPU. To Specify the device: “csr_ocl_1,2”
    - unit (pyFAI.units.Enum) – Output units, can be “q_nm^-1”, “q_A^-1”, “2th_deg”, “2th_rad”, “r_mm” for now
    - safe (bool) – Do some extra checks to ensure LUT/CSR is still valid. False is faster.
    - normalization_factor (float) – Value of a normalization monitor
    - block_size – size of the block for OpenCL integration (unused?)
    - profile – set to True to enable profiling in OpenCL
    - all – if true return a dictionary with many more parameters

    Returns: | q/2th/r bins center positions and regrouped intensity (and error array if variance or variance model provided), uneless all==True.
    Return type: | 2 or 3-tuple of ndarrays

  `integrate2d`(data, npt_rad, npt_azim=360, filename=None, correctSolidAngle=True, variance=None, error_model=None, radial_range=None, azimuth_range=None, mask=None, dummy=None, delta_dummy=None, polarization_factor=None, dark=None, flat=None, method='bbox', unit=q_nm^-1, safe=True, normalization_factor=None, all=False)

    Calculate the azimuthal regrouped 2d image in q(nm^-1)/chi(deg) by default

    Multi algorithm implementation (tries to be bullet proof)

    Parameters:

    - data (ndarray) – 2D array from the Detector/CCD camera
    - npt_rad (int) – number of points in the radial direction
    - npt_azim (int) – number of points in the azimuthal direction
    - filename (str) – output image (as edf format)
    - correctSolidAngle (bool) – correct for solid angle of each pixel if True
    - variance (ndarray) – array containing the variance of the data. If not available, no error propagation is done
    - error_model (str) – When the variance is unknown, an error model can be given: “poisson” (variance = I), “azimuthal” (variance = (I-<I>)^2)
    - radial_range ((float, float), optional) – The lower and upper range of the radial unit. If not provided, range is simply (data.min(), data.max()). Values outside the range are ignored.
    - azimuth_range ((float, float), optional) – The lower and upper range of the azimuthal angle in degree. If not provided, range is simply (data.min(), data.max()). Values outside the range are ignored.
    - mask (ndarray) – array (same size as image) with 1 for masked pixels, and 0 for valid pixels
    - dummy (float) – value for dead/masked pixels
    - delta_dummy (float) – precision for dummy value
    - polarization_factor (float) – polarization factor between -1 (vertical) and +1 (horizontal). 0 for circular polarization or random, None for no correction
    - dark (ndarray) – dark noise image
    - flat (ndarray) – flat field image
    - method (str) – can be “numpy”, “cython”, “BBox” or “splitpixel”, “lut”, “csr; “lut_ocl” and “csr_ocl” if you want to go on GPU. To Specify the device: “csr_ocl_1,2”
    - unit (pyFAI.units.Enum) – Output units, can be “q_nm^-1”, “q_A^-1”, “2th_deg”, “2th_rad”, “r_mm” for now
    - safe (bool) – Do some extra checks to ensure LUT is still valid. False is faster.
    - normalization_factor (float) – Value of a normalization monitor
    - all – if true, return many more intermediate results as a dict.

    Returns: | azimuthaly regrouped intensity, q/2theta/r pos. and chi pos.
    Return type: | 3-tuple of ndarrays (2d, 1d, 1d)

  `makeHeaders`(hdr='#', dark=None, flat=None, polarization_factor=None, normalization_factor=None)

    Parameters:

    - hdr (str) – string used as comment in the header
    - dark – save the darks filenames (default: no)
    - flat – save the flat filenames (default: no)
    - polarization_factor (float) – the polarization factor

    Returns: | the header
    Return type: | str

  `reset`()

    Reset azimuthal integrator in addition to other arrays.

  `save1D`(filename, dim1, I, error=None, dim1_unit=2th_deg, dark=None, flat=None, polarization_factor=None, normalization_factor=None)

    Parameters:

    - filename (str) – the filename used to save the 1D integration
    - dim1 (numpy.ndarray) – the x coordinates of the integrated curve
    - I (numpy.mdarray) – The integrated intensity
    - error (numpy.ndarray or None) – the error bar for each intensity
    - dim1_unit (pyFAI.units.Unit) – the unit of the dim1 array
    - dark – save the darks filenames (default: no)
    - flat – save the flat filenames (default: no)
    - polarization_factor (float) – the polarization factor
    - normalization_factor (float) – the monitor value

    This method save the result of a 1D integration.

  `save2D`(filename, I, dim1, dim2, error=None, dim1_unit=2th_deg, dark=None, flat=None, polarization_factor=None, normalization_factor=None)

    Parameters:

    - filename (str) – the filename used to save the 2D histogram
    - dim1 (numpy.ndarray) – the 1st coordinates of the histogram
    - dim1 – the 2nd coordinates of the histogram
    - I (numpy.mdarray) – The integrated intensity
    - error (numpy.ndarray or None) – the error bar for each intensity
    - dim1_unit (pyFAI.units.Unit) – the unit of the dim1 array
    - dark – save the darks filenames (default: no)
    - flat – save the flat filenames (default: no)
    - polarization_factor (float) – the polarization factor
    - normalization_factor (float) – the monitor value

    This method save the result of a 2D integration.

  `saxs`(*arg, **kw)

    decorator that deprecates the use of a function

  `separate`(data, npt_rad=1024, npt_azim=512, unit='2th_deg', percentile=50, mask=None, restore_mask=True)

    Separate bragg signal from powder/amorphous signal using azimuthal integration, median filering and projected back before subtraction.

    Parameters:

    - data – input image as numpy array
    - npt_rad – number of radial points
    - npt_azim – number of azimuthal points
    - unit – unit to be used for integration
    - percentile – which percentile use for cutting out
    - mask – masked out pixels array
    - restore_mask – masked pixels have the same value as input data provided

    Returns: | bragg, amorphous

  `set_darkcurrent`(dark)
  `set_darkfiles`(files=None, method='mean')

    Parameters:

    - files (str or list(str) or None) – file(s) used to compute the dark.
    - method (str) – method used to compute the dark, “mean” or “median”

    Set the dark current from one or mutliple files, avaraged according to the method provided

  `set_empty`(value)
  `set_flatfield`(flat)
  `set_flatfiles`(files, method='mean')

    Parameters:

    - files (str or list(str) or None) – file(s) used to compute the dark.
    - method (str) – method used to compute the dark, “mean” or “median”

    Set the flat field from one or mutliple files, averaged according to the method provided

  `setup_CSR`(shape, npt, mask=None, pos0_range=None, pos1_range=None, mask_checksum=None, unit=2th_deg, split='bbox')

    Prepare a look-up-table

    Parameters:

    - shape ((int, int)) – shape of the dataset
    - npt (int or (int, int)) – number of points in the the output pattern
    - mask (ndarray) – array with masked pixel (1=masked)
    - pos0_range ((float, float)) – range in radial dimension
    - pos1_range ((float, float)) – range in azimuthal dimension
    - mask_checksum (int (or anything else ...)) – checksum of the mask buffer
    - unit (pyFAI.units.Enum) – use to propagate the LUT object for further checkings
    - split – Splitting scheme: valid options are “no”, “bbox”, “full”

    This method is called when a look-up table needs to be set-up. The shape parameter, correspond to the shape of the original datatset. It is possible to customize the number of point of the output histogram with the npt parameter which can be either an integer for an 1D integration or a 2-tuple of integer in case of a 2D integration. The LUT will have a different shape: (npt, lut_max_size), the later parameter being calculated during the instanciation of the splitBBoxLUT class.

    It is possible to prepare the LUT with a predefine mask. This operation can speedup the computation of the later integrations. Instead of applying the patch on the dataset, it is taken into account during the histogram computation. If provided the mask_checksum prevent the re-calculation of the mask. When the mask changes, its checksum is used to reset (or not) the LUT (which is a very time consuming operation !)

    It is also possible to restrain the range of the 1D or 2D pattern with the pos1_range and pos2_range.

    The unit parameter is just propagated to the LUT integrator for further checkings: The aim is to prevent an integration to be performed in 2th-space when the LUT was setup in q space.

  `setup_LUT`(shape, npt, mask=None, pos0_range=None, pos1_range=None, mask_checksum=None, unit=2th_deg)

    Prepare a look-up-table

    Parameters:

    - shape ((int, int)) – shape of the dataset
    - npt (int or (int, int)) – number of points in the the output pattern
    - mask (ndarray) – array with masked pixel (1=masked)
    - pos0_range ((float, float)) – range in radial dimension
    - pos1_range ((float, float)) – range in azimuthal dimension
    - mask_checksum (int (or anything else ...)) – checksum of the mask buffer
    - unit (pyFAI.units.Enum) – use to propagate the LUT object for further checkings

    This method is called when a look-up table needs to be set-up. The shape parameter, correspond to the shape of the original datatset. It is possible to customize the number of point of the output histogram with the npt parameter which can be either an integer for an 1D integration or a 2-tuple of integer in case of a 2D integration. The LUT will have a different shape: (npt, lut_max_size), the later parameter being calculated during the instanciation of the splitBBoxLUT class.

    It is possible to prepare the LUT with a predefine mask. This operation can speedup the computation of the later integrations. Instead of applying the patch on the dataset, it is taken into account during the histogram computation. If provided the mask_checksum prevent the re-calculation of the mask. When the mask changes, its checksum is used to reset (or not) the LUT (which is a very time consuming operation !)

    It is also possible to restrain the range of the 1D or 2D pattern with the pos1_range and pos2_range.

    The unit parameter is just propagated to the LUT integrator for further checkings: The aim is to prevent an integration to be performed in 2th-space when the LUT was setup in q space.

  `xrpd`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd2`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd2_histogram`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd2_numpy`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd2_splitBBox`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd2_splitPixel`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_CSR_OCL`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_LUT`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_LUT_OCL`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_OpenCL`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_cython`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_numpy`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_splitBBox`(*arg, **kw)

    decorator that deprecates the use of a function

  `xrpd_splitPixel`(*arg, **kw)

    decorator that deprecates the use of a function

# `integrate_widget` Module

# `geometry` Module

class `pyFAI.geometry.``Geometry`(dist=1, poni1=0, poni2=0, rot1=0, rot2=0, rot3=0, pixel1=None, pixel2=None, splineFile=None, detector=None, wavelength=None)

  Bases: `object`

  This class is an azimuthal integrator based on P. Boesecke’s geometry and histogram algorithm by Manolo S. del Rio and V.A Sole

  Detector is assumed to be corrected from “raster orientation” effect. It is not addressed here but rather in the Detector object or at read time. Considering there is no tilt:

  - Detector fast dimension (dim2) is supposed to be horizontal (dimension X of the image)
  - Detector slow dimension (dim1) is supposed to be vertical, upwards (dimension Y of the image)
  - The third dimension is chose such as the referential is orthonormal, so dim3 is along incoming X-ray beam

  Axis 1 is along first dimension of detector (when not tilted), this is the slow dimension of the image array in C or Y x1={1,0,0}

  Axis 2 is along second dimension of detector (when not tilted), this is the fast dimension of the image in C or X x2={0,1,0}

  Axis 3 is along the incident X-Ray beam x3={0,0,1}

  We define the 3 rotation around axis 1, 2 and 3:

  rotM1 = RotationMatrix[rot1,x1] = {{1,0,0},{0,cos[rot1],-sin[rot1]},{0,sin[rot1],cos[rot1]}} rotM2 = RotationMatrix[rot2,x2] = {{cos[rot2],0,sin[rot2]},{0,1,0},{-sin[rot2],0,cos[rot2]}} rotM3 = RotationMatrix[rot3,x3] = {{cos[rot3],-sin[rot3],0},{sin[rot3],cos[rot3],0},{0,0,1}}

  Rotations of the detector are applied first Rot around axis 1, then axis 2 and finally around axis 3:

  R = rotM3.rotM2.rotM1

  R = {{cos[rot2] cos[rot3],cos[rot3] sin[rot1] sin[rot2]-cos[rot1] sin[rot3],cos[rot1] cos[rot3] sin[rot2]+sin[rot1] sin[rot3]},
    {cos[rot2] sin[rot3],cos[rot1] cos[rot3]+sin[rot1] sin[rot2] sin[rot3],-cos[rot3] sin[rot1]+cos[rot1] sin[rot2] sin[rot3]}, {-sin[rot2],cos[rot2] sin[rot1],cos[rot1] cos[rot2]}}

  In Python notation:

  R.x1 = [cos(rot2)*cos(rot3),cos(rot2)*sin(rot3),-sin(rot2)]

  R.x2 = [cos(rot3)*sin(rot1)*sin(rot2) - cos(rot1)*sin(rot3),cos(rot1)*cos(rot3) + sin(rot1)*sin(rot2)*sin(rot3), cos(rot2)*sin(rot1)]

  R.x3 = [cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3),-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3), cos(rot1)*cos(rot2)]

  - Coordinates of the Point of Normal Incidence:

    PONI = R.{0,0,L}

    PONI = [L*(cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3)),

      L*(-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3)),L*cos(rot1)*cos(rot2)]

  - Any pixel on detector plan at coordinate (d1, d2) in meters. Detector is at z=L

    P={d1,d2,L}

    R.P = [t1, t2, t3] t1 = R.P.x1 = d1*cos(rot2)*cos(rot3) + d2*(cos(rot3)*sin(rot1)*sin(rot2) - cos(rot1)*sin(rot3)) + L*(cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3)) t2 = R.P.x2 = d1*cos(rot2)*sin(rot3) + d2*(cos(rot1)*cos(rot3) + sin(rot1)*sin(rot2)*sin(rot3)) + L*(-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3)) t3 = R.P.x3 = d2*cos(rot2)*sin(rot1) - d1*sin(rot2) + L*cos(rot1)*cos(rot2)

  - Distance sample (origin) to detector point (d1,d2)

    |R.P| = sqrt(pow(Abs(L*cos(rot1)*cos(rot2) + d2*cos(rot2)*sin(rot1) - d1*sin(rot2)),2) +

      pow(Abs(d1*cos(rot2)*cos(rot3) + d2*(cos(rot3)*sin(rot1)*sin(rot2) - cos(rot1)*sin(rot3)) + L*(cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3))),2) + pow(Abs(d1*cos(rot2)*sin(rot3) + L*(-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3)) + d2*(cos(rot1)*cos(rot3) + sin(rot1)*sin(rot2)*sin(rot3))),2))

  - cos(2theta) is defined as (R.P component along x3) over the distance from origin to data point |R.P|

  tth = ArcCos [-(R.P).x3/|R.P|]

  tth = Arccos((-(L*cos(rot1)*cos(rot2)) - d2*cos(rot2)*sin(rot1) + d1*sin(rot2))/
    sqrt(pow(Abs(L*cos(rot1)*cos(rot2) + d2*cos(rot2)*sin(rot1) - d1*sin(rot2)),2) +

      > pow(Abs(d1*cos(rot2)*cos(rot3) + d2*(cos(rot3)*sin(rot1)*sin(rot2) - cos(rot1)*sin(rot3)) +

      L*(cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3))),2) +
        pow(Abs(d1*cos(rot2)*sin(rot3) + L*(-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3)) +

      d2*(cos(rot1)*cos(rot3) + sin(rot1)*sin(rot2)*sin(rot3))),2)))

  - tan(2theta) is defined as sqrt(t1**2 + t2**2) / t3

  tth = ArcTan2 [sqrt(t1**2 + t2**2) , t3 ]

  Getting 2theta from it’s tangeant seems both more precise (around beam stop very far from sample) and faster by about 25% Currently there is a swich in the method to follow one path or the other.

  - Tangeant of angle chi is defined as (R.P component along x1) over (R.P component along x2). Arctan2 should be used in actual calculation

  > chi = ArcTan[((R.P).x1) / ((R.P).x2)]

  > chi = ArcTan2(d1*cos(rot2)*cos(rot3) + d2*(cos(rot3)*sin(rot1)*sin(rot2) - cos(rot1)*sin(rot3)) +

  >   > L*(cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3)),

  >   d1*cos(rot2)*sin(rot3) + L*(-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3)) +
  >     d2*(cos(rot1)*cos(rot3) + sin(rot1)*sin(rot2)*sin(rot3)))

  `calc_pos_zyx`(d0=None, d1=None, d2=None, param=None)

    Allows you to calculate the position of a set of points in space in the sample re

    Parameters:

    - d0 – altitude on the point compared to the detector (i.e. z)
    - d1 – position on the detector along the slow dimention (i.e. y)
    - d2 – position on the detector along the fastest dimention (i.e. x)

    :return zyx array, so 3D array with dim0=along the beam,
      dim1=along slowest dimension dim2=along fastest dimension unless rotations are too large
  `calc_transmission`(t0, shape=None)

    Defines the absorption correction for a phosphor screen or a scintillator from t0, the normal transmission of the screen.

    Icor = Iobs(1-t0)/(1-exp(ln(t0)/cos(incidence)))
      1-exp(ln(t0)/cos(incidence)
    let t = —————————–
      1 - t0

    See reference on: J. Appl. Cryst. (2002). 35, 356–359 G. Wu et al. CCD phosphor

    Parameters:

    - t0 – value of the normal transmission (from 0 to 1)
    - shape – shape of the array

    Returns: | actual

  `calcfrom1d`(tth, I, shape=None, mask=None, dim1_unit=2th_deg, correctSolidAngle=True)

    Computes a 2D image from a 1D integrated profile

    Parameters:

    - tth – 1D array with 2theta in degrees
    - I – scattering intensity

    Returns: | 2D image reconstructed

  `chi`(d1, d2, path='cython')

    Calculate the chi (azimuthal angle) for the centre of a pixel at coordinate d1,d2 which in the lab ref has coordinate:

    X1 = p1*cos(rot2)*cos(rot3) + p2*(cos(rot3)*sin(rot1)*sin(rot2) - cos(rot1)*sin(rot3)) - L*(cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3)) X2 = p1*cos(rot2)*sin(rot3) - L*(-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3)) + p2*(cos(rot1)*cos(rot3) + sin(rot1)*sin(rot2)*sin(rot3)) X3 = -(L*cos(rot1)*cos(rot2)) + p2*cos(rot2)*sin(rot1) - p1*sin(rot2) hence tan(Chi) = X2 / X1

    Parameters:

    - d1 (float or array of them) – pixel coordinate along the 1st dimention (C convention)
    - d2 (float or array of them) – pixel coordinate along the 2nd dimention (C convention)
    - path – can be “tan” (i.e via numpy) or “cython”

    Returns: | chi, the azimuthal angle in rad

  `chiArray`(shape)

    Generate an array of the given shape with chi(i,j) (azimuthal angle) for all elements.

    Parameters: | shape (ndarray.shape) – the shape of the chi array
    Returns: | the chi array
    Return type: | ndarray

  `chi_corner`(d1, d2)

    Calculate the chi (azimuthal angle) for the corner of a pixel at coordinate d1,d2 which in the lab ref has coordinate:

    X1 = p1*cos(rot2)*cos(rot3) + p2*(cos(rot3)*sin(rot1)*sin(rot2) - cos(rot1)*sin(rot3)) - L*(cos(rot1)*cos(rot3)*sin(rot2) + sin(rot1)*sin(rot3)) X2 = p1*cos(rot2)*sin(rot3) - L*(-(cos(rot3)*sin(rot1)) + cos(rot1)*sin(rot2)*sin(rot3)) + p2*(cos(rot1)*cos(rot3) + sin(rot1)*sin(rot2)*sin(rot3)) X3 = -(L*cos(rot1)*cos(rot2)) + p2*cos(rot2)*sin(rot1) - p1*sin(rot2) hence tan(Chi) = X2 / X1

    Parameters:

    - d1 (float or array of them) – pixel coordinate along the 1st dimention (C convention)
    - d2 (float or array of them) – pixel coordinate along the 2nd dimention (C convention)

    Returns: | chi, the azimuthal angle in rad

  `chia`

    chi array in cache

  `cornerArray`(shape)

    Generate a 3D array of the given shape with (i,j) (radial angle 2th, azimuthal angle chi ) for all elements.

    Parameters: | shape (ndarray.shape) – expected shape
    Returns: | 3d array with shape=(*shape,2) the two elements are (radial angle 2th, azimuthal angle chi)

  `cornerQArray`(shape)

    Generate a 3D array of the given shape with (i,j) (azimuthal angle) for all elements.

  `cornerRArray`(shape)

    Generate a 3D array of the given shape with (i,j) (azimuthal angle) for all elements.

  `correct_SA_spline`
  `cosIncidance`(d1, d2, path='cython')

    Calculate the incidence angle (alpha) for current pixels (P). The poni being the point of normal incidence, it’s incidence angle is ${alpha} = 0$ hence $cos({alpha}) = 1$

    Parameters:

    - d1 – 1d or 2d set of points in pixel coord
    - d2 – 1d or 2d set of points in pixel coord

    Returns: | cosine of the incidence angle

  `del_chia`()
  `del_dssa`()
  `del_qa`()
  `del_ttha`()
  `delta2Theta`(shape)

    Generate a 3D array of the given shape with (i,j) with the max distance between the center and any corner in 2 theta

    Parameters: | shape – The shape of the detector array: 2-tuple of integer
    Returns: | 2D-array containing the max delta angle between a pixel center and any corner in 2theta-angle (rad)

  `deltaChi`(shape)

    Generate a 3D array of the given shape with (i,j) with the max distance between the center and any corner in chi-angle (rad)

    Parameters: | shape – The shape of the detector array: 2-tuple of integer
    Returns: | 2D-array containing the max delta angle between a pixel center and any corner in chi-angle (rad)

  `deltaQ`(shape)

    Generate a 2D array of the given shape with (i,j) with the max distance between the center and any corner in q_vector unit (nm^-1)

    Parameters: | shape – The shape of the detector array: 2-tuple of integer
    Returns: | array 2D containing the max delta Q between a pixel center and any corner in q_vector unit (nm^-1)

  `deltaR`(shape)

    Generate a 2D array of the given shape with (i,j) with the max distance between the center and any corner in radius unit (mm)

    Parameters: | shape – The shape of the detector array: 2-tuple of integer
    Returns: | array 2D containing the max delta Q between a pixel center and any corner in q_vector unit (nm^-1)

  `diffSolidAngle`(d1, d2)

    Calculate the solid angle of the current pixels (P) versus the PONI (C)

    > Omega(P) A cos(a) SC^2 3 SC^3

    dOmega = ——— = ——— x ——— = cos (a) = ——
      Omega(C) SP^2 A cos(0) SP^3

    cos(a) = SC/SP

    Parameters:

    - d1 – 1d or 2d set of points
    - d2 – 1d or 2d set of points (same size&shape as d1)

    Returns: | solid angle correction array

  `dist`
  `dssa`

    solid angle array in cache

  `getFit2D`()

    Export geometry setup with the geometry of Fit2D

    Returns: | dict with parameters compatible with fit2D geometry

  `getPyFAI`()

    Export geometry setup with the geometry of PyFAI

    Returns: | dict with the parameter-set of the PyFAI geometry

  `getSPD`()

    get the SPD like parameter set: For geometry description see Peter Boesecke J.Appl.Cryst.(2007).40, s423–s427

    Basically the main difference with pyFAI is the order of the axis which are flipped

    Returns:

    dictionnary with those parameters: SampleDistance: distance from sample to detector at the PONI (orthogonal projection) Center_1, pixel position of the PONI along fastest axis Center_2: pixel position of the PONI along slowest axis Rot_1: rotation around the fastest axis (x) Rot_2: rotation around the slowest axis (y) Rot_3: rotation around the axis ORTHOGONAL to the detector plan PSize_1: pixel size in meter along the fastest dimention PSize_2: pixel size in meter along the slowst dimention splineFile: name of the file containing the spline BSize_1: pixel binning factor along the fastest dimention BSize_2: pixel binning factor along the slowst dimention WaveLength: wavelength used in meter

  `get_chia`()
  `get_correct_solid_angle_for_spline`()
  `get_dist`()
  `get_dssa`()
  `get_mask`()
  `get_maskfile`()
  `get_pixel1`()
  `get_pixel2`()
  `get_poni1`()
  `get_poni2`()
  `get_qa`()
  `get_rot1`()
  `get_rot2`()
  `get_rot3`()
  `get_spline`()
  `get_splineFile`()
  `get_ttha`()
  `get_wavelength`()
  `load`(filename)

    Load the refined parameters from a file.

    Parameters: | filename (string) – name of the file to load

  `mask`
  `maskfile`
  `oversampleArray`(myarray)
  `pixel1`
  `pixel2`
  `polarization`(shape=None, factor=None, axis_offset=0)

    Calculate the polarization correction accoding to the polarization factor:

    - If the polarization factor is None, the correction is not applied (returns 1)
    - If the polarization factor is 0 (circular polarization), the correction correspond to (1+(cos2θ)^2)/2
    - If the polarization factor is 1 (linear horizontal polarization), there is no correction in the vertical plane and a node at 2th=90, chi=0
    - If the polarization factor is -1 (linear vertical polarization), there is no correction in the horizontal plane and a node at 2th=90, chi=90
    - If the polarization is elliptical, the polarization factor varies between -1 and +1.

    The axis_offset parameter allows correction for the misalignement of the polarization plane (or ellipse main axis) and the the detector’s X axis.

    Parameters:

    - factor – (Ih-Iv)/(Ih+Iv): varies between 0 (no polarization) and 1 (where division by 0 could occure at 2th=90, chi=0)
    - axis_offset – Angle between the polarization main axis and detector X direction (in radians !!!)

    Returns: | 2D array with polarization correction array (intensity/polarisation)

  `poni1`
  `poni2`
  `qArray`(shape)

    Generate an array of the given shape with q(i,j) for all elements.

  `qCornerFunct`(d1, d2)

    Calculate the q_vector for any pixel corner (in nm^-1)

  `qFunction`(d1, d2, param=None, path='cython')

    Calculates the q value for the center of a given pixel (or set of pixels) in nm-1

    q = 4pi/lambda sin( 2theta / 2 )

    Parameters:

    - d1 (scalar or array of scalar) – position(s) in pixel in first dimension (c order)
    - d2 (scalar or array of scalar) – position(s) in pixel in second dimension (c order)

    Returns: | q in in nm^(-1)
    Return type: | float or array of floats.

  `qa`

    Q array in cache

  `rArray`(shape)

    Generate an array of the given shape with r(i,j) for all elements; r in m.

    Parameters: | shape – expected shape
    Returns: | 2d array of the given shape with radius in m from beam center on detector.

  `rCornerFunct`(d1, d2)

    Calculate the radius array for any pixel corner (in m)

  `rFunction`(d1, d2, param=None, path='numpy')

    Calculates the radius value for the center of a given pixel (or set of pixels) in m

    r = direct_distance * tan( 2theta )

    Parameters:

    - d1 (scalar or array of scalar) – position(s) in pixel in first dimension (c order)
    - d2 (scalar or array of scalar) – position(s) in pixel in second dimension (c order)

    Returns: | r in in m
    Return type: | float or array of floats.

  `read`(filename)

    Load the refined parameters from a file.

    Parameters: | filename (string) – name of the file to load

  `reset`()

    reset most arrays that are cached: used when a parameter changes.

  `rot1`
  `rot2`
  `rot3`
  `save`(filename)

    Save the geometry parameters.

    Parameters: | filename (string) – name of the file where to save the parameters

  `setChiDiscAtPi`()

    Set the position of the discontinuity of the chi axis between -pi and +pi. This is the default behavour

  `setChiDiscAtZero`()

    Set the position of the discontinuity of the chi axis between 0 and 2pi. By default it is between pi and -pi

  `setFit2D`(directDist, centerX, centerY, tilt=0.0, tiltPlanRotation=0.0, pixelX=None, pixelY=None, splineFile=None)

    Set the Fit2D-like parameter set: For geometry description see HPR 1996 (14) pp-240

    Warning: Fit2D flips automatically images depending on their file-format. By reverse engineering we noticed this behavour for Tiff and Mar345 images (at least). To obtaine correct result you will have to flip images using numpy.flipud.

    Parameters:

    - direct – direct distance from sample to detector along the incident beam (in millimeter as in fit2d)
    - tilt – tilt in degrees
    - tiltPlanRotation – Rotation (in degrees) of the tilt plan arround the Z-detector axis * 0deg -> Y does not move, +X goes to Z<0 * 90deg -> X does not move, +Y goes to Z<0 * 180deg -> Y does not move, +X goes to Z>0 * 270deg -> X does not move, +Y goes to Z>0
    - pixelX,pixelY – as in fit2d they ar given in micron, not in meter
    - centerY (centerX,) – pixel position of the beam center
    - splineFile – name of the file containing the spline

  `setOversampling`(iOversampling)

    set the oversampling factor

  `setPyFAI`(**kwargs)

    set the geometry from a pyFAI-like dict

  `setSPD`(SampleDistance, Center_1, Center_2, Rot_1=0, Rot_2=0, Rot_3=0, PSize_1=None, PSize_2=None, splineFile=None, BSize_1=1, BSize_2=1, WaveLength=None)

    Set the SPD like parameter set: For geometry description see Peter Boesecke J.Appl.Cryst.(2007).40, s423–s427

    Basically the main difference with pyFAI is the order of the axis which are flipped

    Parameters: | SampleDistance – distance from sample to detector at the PONI (orthogonal projection)

    :param Center_1, pixel position of the PONI along fastest axis :param Center_2: pixel position of the PONI along slowest axis :param Rot_1: rotation around the fastest axis (x) :param Rot_2: rotation around the slowest axis (y) :param Rot_3: rotation around the axis ORTHOGONAL to the detector plan :param PSize_1: pixel size in meter along the fastest dimention :param PSize_2: pixel size in meter along the slowst dimention :param splineFile: name of the file containing the spline :param BSize_1: pixel binning factor along the fastest dimention :param BSize_2: pixel binning factor along the slowst dimention :param WaveLength: wavelength used

  `set_chia`(_)
  `set_correct_solid_angle_for_spline`(value)
  `set_dist`(value)
  `set_dssa`(_)
  `set_mask`(mask)
  `set_maskfile`(maskfile)
  `set_pixel1`(pixel1)
  `set_pixel2`(pixel2)
  `set_poni1`(value)
  `set_poni2`(value)
  `set_qa`(_)
  `set_rot1`(value)
  `set_rot2`(value)
  `set_rot3`(value)
  `set_spline`(spline)
  `set_splineFile`(splineFile)
  `set_ttha`(_)
  `set_wavelength`(value)
  classmethod `sload`(filename)

    A static method combining the constructor and the loader from a file

    Parameters: | filename (string) – name of the file to load
    Returns: | instance of Gerometry of AzimuthalIntegrator set-up with the parameter from the file.

  `solidAngleArray`(shape, order=3, absolute=False)

    Generate an array for the solid angle correction given the shape of the detector.

    solid_angle = cos(incidence)^3

    Parameters:

    - shape – shape of the array expected
    - order – should be 3, power of the formula just obove
    - absolute – the absolute solid angle is calculated as:

    SA = pix1*pix2/dist^2 * cos(incidence)^3

  `spline`
  `splineFile`
  `tth`(d1, d2, param=None, path='cython')

    Calculates the 2theta value for the center of a given pixel (or set of pixels)

    Parameters:

    - d1 (scalar or array of scalar) – position(s) in pixel in first dimension (c order)
    - d2 (scalar or array of scalar) – position(s) in pixel in second dimension (c order)
    - path – can be “cos”, “tan” or “cython”

    Returns: | 2theta in radians
    Return type: | floar or array of floats.

  `tth_corner`(d1, d2)

    Calculates the 2theta value for the corner of a given pixel (or set of pixels)

    Parameters:

    - d1 (scalar or array of scalar) – position(s) in pixel in first dimension (c order)
    - d2 (scalar or array of scalar) – position(s) in pixel in second dimension (c order)

    Returns: | 2theta in radians
    Return type: | floar or array of floats.

  `ttha`

    2theta array in cache

  `twoThetaArray`(shape)

    Generate an array of the given shape with two-theta(i,j) for all elements.

  `wavelength`
  `write`(filename)

    Save the geometry parameters.

    Parameters: | filename (string) – name of the file where to save the parameters

# `geometryRefinement` Module

# `detectors` Module

Module containing the description of all detectors with a factory to instantiate them

class `pyFAI.detectors.``Aarhus`(pixel1=2.5e-05, pixel2=2.5e-05, radius=0.3)

  Bases: `pyFAI.detectors.Detector`

  Cylindrical detector made of a bent imaging-plate. Developped at the Danish university of Aarhus r = 1.2m or 0.3m

  The image has to be laid-out horizontally

  Nota: the detector is bending towards the sample, hence reducing the sample-detector distance. This is why z<0 (or p3<0)

  TODO: update cython code for 3d detectors use expand2d instead of outer product with ones

  `IS_FLAT` = False
  `MAX_SHAPE` = (1000, 16000)
  `calc_cartesian_positions`(d1=None, d2=None, center=True, use_cython=True)

    Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition

    Parameters:

    - d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
    - d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
    - center – retrieve the coordinate of the center of the pixel
    - use_cython – set to False to test Python implementeation

    Returns: | position in meter of the center of each pixels.
    Return type: | ndarray

    d1 and d2 must have the same shape, returned array will have the same shape.

  `get_pixel_corners`(use_cython=True)

    Calculate the position of the corner of the pixels

    This should be overwritten by class representing non-contiguous detector (Xpad, ...)

    Returns: | 4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

class `pyFAI.detectors.``Basler`(pixel=3.75e-06)

  Bases: `pyFAI.detectors.Detector`

  Basler camera are simple CCD camara over GigaE

  `MAX_SHAPE` = (966, 1296)
  `aliases` = ['aca1300']
  `force_pixel` = True

class `pyFAI.detectors.``Detector`(pixel1=None, pixel2=None, splineFile=None)

  Bases: `object`

  Generic class representing a 2D detector

  `IS_FLAT` = True
  `aliases` = []
  `binning`
  `calc_cartesian_positions`(d1=None, d2=None, center=True, use_cython=True)

    Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition

    Parameters:

    - d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
    - d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
    - center – retrieve the coordinate of the center of the pixel
    - use_cython – set to False to test Python implementation

    Returns: | position in meter of the center of each pixels.
    Return type: | 3xndarray, the later being None if IS_FLAT

    d1 and d2 must have the same shape, returned array will have the same shape.

    pos_z is None for flat detectors

  `calc_mask`()

    Detectors with gaps should overwrite this method with something actually calculating the mask!

  classmethod `factory`(name, config=None)

    A kind of factory...

    Parameters:

    - name (str) – name of a detector
    - config (dict or JSON representation of it.) – configuration of the detector

    Returns: | an instance of the right detector, set-up if possible
    Return type: | pyFAI.detectors.Detector

  `force_pixel` = False
  `getFit2D`()

    Helper method to serialize the description of a detector using the Fit2d units

    Returns: | representation of the detector easy to serialize
    Return type: | dict

  `getPyFAI`()

    Helper method to serialize the description of a detector using the pyFAI way with everything in S.I units.

    Returns: | representation of the detector easy to serialize
    Return type: | dict

  `get_binning`()
  `get_mask`()
  `get_maskfile`()
  `get_name`()

    Get a meaningful name for detector

  `get_pixel1`()
  `get_pixel2`()
  `get_pixel_corners`()

    Calculate the position of the corner of the pixels

    This should be overwritten by class representing non-contiguous detector (Xpad, ...)

    Precision float32 is ok: precision of 1µm for a detector size of 1m

    Returns: | 4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

  `get_splineFile`()
  `guess_binning`(data)

    Guess the binning/mode depending on the image shape :param data: 2-tuple with the shape of the image or the image with a .shape attribute.

  `mask`
  `maskfile`
  `name`

    Get a meaningful name for detector

  `pixel1`
  `pixel2`
  `registry` = {'imxpads70': <class 'pyFAI.detectors.ImXPadS70'>, 'rayonix_mx225': <class 'pyFAI.detectors.RayonixMx225'>, 'eiger1m': <class 'pyFAI.detectors.Eiger1M'>, 'imxpads10': <class 'pyFAI.detectors.ImXPadS10'>, 'mar_345': <class 'pyFAI.detectors.Mar345'>, 'titan': <class 'pyFAI.detectors.Titan'>, 'rayonixlx225': <class 'pyFAI.detectors.RayonixLx255'>, 'pilatus2m': <class 'pyFAI.detectors.Pilatus2M'>, 'agilent_titan': <class 'pyFAI.detectors.Titan'>, 'rayonixmx225hs': <class 'pyFAI.detectors.RayonixMx225hs'>, 'fairchildcondor486:90': <class 'pyFAI.detectors.Fairchild'>, 'rayonix_mx425hs': <class 'pyFAI.detectors.RayonixMx425hs'>, 'rayonix_sx85hs': <class 'pyFAI.detectors.RayonixSx85hs'>, 'rayonixmx170': <class 'pyFAI.detectors.RayonixMx170'>, 'mar165': <class 'pyFAI.detectors.RayonixSx165'>, 'perkinelmer': <class 'pyFAI.detectors.Perkin'>, 'titan2kx2k': <class 'pyFAI.detectors.Titan'>, 'rayonix': <class 'pyFAI.detectors.Rayonix'>, 'xpads540flat': <class 'pyFAI.detectors.Xpad_flat'>, 'mar133': <class 'pyFAI.detectors.Rayonix133'>, 'rayonixmx300hs': <class 'pyFAI.detectors.RayonixMx300hs'>, 'rayonix133': <class 'pyFAI.detectors.Rayonix133'>, 'condor': <class 'pyFAI.detectors.Fairchild'>, 'fairchild_condor_486:90': <class 'pyFAI.detectors.Fairchild'>, 'eiger16m': <class 'pyFAI.detectors.Eiger16M'>, 'rayonix_mx170': <class 'pyFAI.detectors.RayonixMx170'>, 'rayonixsx165': <class 'pyFAI.detectors.RayonixSx165'>, 'xpad_flat': <class 'pyFAI.detectors.Xpad_flat'>, 'agilenttitan': <class 'pyFAI.detectors.Titan'>, 'oxd_titan': <class 'pyFAI.detectors.Titan'>, 'perkin_elmer': <class 'pyFAI.detectors.Perkin'>, 'rayonixlx255': <class 'pyFAI.detectors.RayonixLx255'>, 'dexela_2923': <class 'pyFAI.detectors.Dexela2923'>, 'pilatus6m': <class 'pyFAI.detectors.Pilatus6M'>, 'titan_2k_x_2k': <class 'pyFAI.detectors.Titan'>, 'aca1300': <class 'pyFAI.detectors.Basler'>, 'oxdtitan': <class 'pyFAI.detectors.Titan'>, 'pilatus1m': <class 'pyFAI.detectors.Pilatus1M'>, 'xpad_s540_flat': <class 'pyFAI.detectors.Xpad_flat'>, 'mar3450': <class 'pyFAI.detectors.Mar345'>, 'rayonixlx170': <class 'pyFAI.detectors.RayonixLx170'>, 'basler': <class 'pyFAI.detectors.Basler'>, 'eiger4m': <class 'pyFAI.detectors.Eiger4M'>, 'rayonix_lx170': <class 'pyFAI.detectors.RayonixLx170'>, 'imxpad_s10': <class 'pyFAI.detectors.ImXPadS10'>, 'aarhus': <class 'pyFAI.detectors.Aarhus'>, 'rayonix_sx200': <class 'pyFAI.detectors.RayonixSx200'>, 'rayonixsx85hs': <class 'pyFAI.detectors.RayonixSx85hs'>, 'rayonixmx225': <class 'pyFAI.detectors.RayonixMx225'>, 'pilatus300k': <class 'pyFAI.detectors.Pilatus300k'>, 'rayonix_lx225': <class 'pyFAI.detectors.RayonixLx255'>, 'perkin_detector': <class 'pyFAI.detectors.Perkin'>, 'pilatus200k': <class 'pyFAI.detectors.Pilatus200k'>, 'imxpads140': <class 'pyFAI.detectors.ImXPadS140'>, 'detector': <class 'pyFAI.detectors.Detector'>, 'rayonixmx300': <class 'pyFAI.detectors.RayonixMx300'>, 'rayonix_sx165': <class 'pyFAI.detectors.RayonixSx165'>, 'imxpad_s140': <class 'pyFAI.detectors.ImXPadS140'>, 'pilatus300kw': <class 'pyFAI.detectors.Pilatus300kw'>, 'imxpad_s70': <class 'pyFAI.detectors.ImXPadS70'>, 'fairchild': <class 'pyFAI.detectors.Fairchild'>, 'rayonixsx200': <class 'pyFAI.detectors.RayonixSx200'>, 'rayonix_mx225hs': <class 'pyFAI.detectors.RayonixMx225hs'>, 'rayonix_sx30hs': <class 'pyFAI.detectors.RayonixSx30hs'>, 'rayonix_mx340hs': <class 'pyFAI.detectors.RayonixMx340hs'>, 'eiger9m': <class 'pyFAI.detectors.Eiger9M'>, 'perkin': <class 'pyFAI.detectors.Perkin'>, 'rayonixsx30hs': <class 'pyFAI.detectors.RayonixSx30hs'>, 'rayonixmx340hs': <class 'pyFAI.detectors.RayonixMx340hs'>, 'mar345': <class 'pyFAI.detectors.Mar345'>, 'perkindetector': <class 'pyFAI.detectors.Perkin'>, 'rayonixmx425hs': <class 'pyFAI.detectors.RayonixMx425hs'>, 'rayonixmx325': <class 'pyFAI.detectors.RayonixMx325'>, 'rayonix_mx300': <class 'pyFAI.detectors.RayonixMx300'>, 'pilatus100k': <class 'pyFAI.detectors.Pilatus100k'>, 'rayonix_mx325': <class 'pyFAI.detectors.RayonixMx325'>, 'rayonix_mx300hs': <class 'pyFAI.detectors.RayonixMx300hs'>, 'dexela2923': <class 'pyFAI.detectors.Dexela2923'>}
  `save`(filename)

    Saves the detector description into a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html Main differences:

    > - differentiate pixel center from pixel corner offsets
    > - store all offsets are ndarray according to slow/fast dimention (not x, y)

    Parameters: | filename – name of the file on the disc

  `setFit2D`(**kwarg)

    Twin method of getFit2D: setup a detector instance according to a description

    Parameters: | kwarg – dictionary containing pixel1, pixel2 and splineFile

  `setPyFAI`(**kwarg)

    Twin method of getPyFAI: setup a detector instance according to a description

    Parameters: | kwarg – dictionary containing detector, pixel1, pixel2 and splineFile

  `set_binning`(bin_size=(1, 1))

    Set the “binning” of the detector,

    Parameters: | bin_size ((int, int)) – binning as integer or tuple of integers.

  `set_config`(config)

    Sets the configuration of the detector. This implies: - Orientation: integers - Binning - ROI

    The configuration is either a python dictionary or a JSON string or a file containing this JSON configuration

    keys in that dictionary are : “orientation”: integers from 0 to 7 “binning”: integer or 2-tuple of integers. If only one integer is provided, “offset”: coordinate (in pixels) of the start of the detector

  `set_dx`(dx=None)

    set the pixel-wise displacement along X (dim2):

  `set_dy`(dy=None)

    set the pixel-wise displacement along Y (dim1):

  `set_mask`(mask)
  `set_maskfile`(maskfile)
  `set_pixel1`(value)
  `set_pixel2`(value)
  `set_splineFile`(splineFile)
  `splineFile`
  `uniform_pixel` = True

class `pyFAI.detectors.``DetectorMeta`(name, bases, dct)

  Bases: `type`

  Metaclass used to register all detector classes inheriting from Detector

class `pyFAI.detectors.``Dexela2923`(pixel1=7.5e-05, pixel2=7.5e-05)

  Bases: `pyFAI.detectors.Detector`

  Dexela CMOS family detector

  `MAX_SHAPE` = (3888, 3072)
  `aliases` = ['Dexela 2923']
  `force_pixel` = True

class `pyFAI.detectors.``Eiger`(pixel1=7.5e-05, pixel2=7.5e-05)

  Bases: `pyFAI.detectors.Detector`

  Eiger detector: generic description containing mask algorithm

  `MODULE_GAP` = (37, 10)
  `MODULE_SIZE` = (514, 1030)
  `calc_cartesian_positions`(d1=None, d2=None)

    Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

    Parameters:

    - d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
    - d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

    Returns: | position in meter of the center of each pixels.
    Return type: | ndarray

    d1 and d2 must have the same shape, returned array will have the same shape.

  `calc_mask`()

    Returns a generic mask for Pilatus detectors...

  `force_pixel` = True

class `pyFAI.detectors.``Eiger16M`(pixel1=7.5e-05, pixel2=7.5e-05)

  Bases: `pyFAI.detectors.Eiger`

  Eiger 16M detector

  `MAX_SHAPE` = (4371, 4150)

class `pyFAI.detectors.``Eiger1M`(pixel1=7.5e-05, pixel2=7.5e-05)

  Bases: `pyFAI.detectors.Eiger`

  Eiger 1M detector

  `MAX_SHAPE` = (1065, 1030)

class `pyFAI.detectors.``Eiger4M`(pixel1=7.5e-05, pixel2=7.5e-05)

  Bases: `pyFAI.detectors.Eiger`

  Eiger 4M detector

  `MAX_SHAPE` = (2167, 2070)

class `pyFAI.detectors.``Eiger9M`(pixel1=7.5e-05, pixel2=7.5e-05)

  Bases: `pyFAI.detectors.Eiger`

  Eiger 9M detector

  `MAX_SHAPE` = (3269, 3110)

class `pyFAI.detectors.``FReLoN`(splineFile=None)

  Bases: `pyFAI.detectors.Detector`

  FReLoN detector: The spline is mandatory to correct for geometric distortion of the taper

  TODO: create automatically a mask that removes pixels out of the “valid reagion”

  `calc_mask`()

    Returns a generic mask for Frelon detectors... All pixels which (center) turns to be out of the valid region are by default discarded

class `pyFAI.detectors.``Fairchild`(pixel1=1.5e-05, pixel2=1.5e-05)

  Bases: `pyFAI.detectors.Detector`

  Fairchild Condor 486:90 detector

  `MAX_SHAPE` = (4096, 4096)
  `aliases` = ['Fairchild', 'Condor', 'Fairchild Condor 486:90']
  `force_pixel` = True
  `uniform_pixel` = True

class `pyFAI.detectors.``ImXPadS10`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors.Detector`

  ImXPad detector: ImXPad s10 detector with 1x1modules

  `BORDER_SIZE_RELATIVE` = 2.5
  `MAX_SHAPE` = (120, 80)
  `MODULE_SIZE` = (120, 80)
  `PIXEL_SIZE` = (0.00013, 0.00013)
  `aliases` = ['Imxpad S10']
  `calc_cartesian_positions`(d1=None, d2=None)

    Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

    Parameters:

    - d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
    - d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

    Returns: | position in meter of the center of each pixels.
    Return type: | ndarray

    d1 and d2 must have the same shape, returned array will have the same shape.

  `calc_mask`()

    Calculate the mask

  `calc_pixels_edges`()

    Calculate the position of the pixel edges

  `force_pixel` = True
  `from_control_points`(points, border_relative_size=1.0)

    This methods allows the calculation of the pixel corners from a set of control points taked on each chip, 2 on each of them.

    Parameters:

    - points – list (len 2x the number of chips) with xyz coordinates in mm
    - border_relative_size – 2.5 for Si sensor, 1 for CdTe sensor

  `get_pixel_corners`()

    Calculate the position of the corner of the pixels

    This should be overwritten by class representing non-contiguous detector (Xpad, ...)

    Precision float32 is ok: precision of 1µm for a detector size of 1m

    Returns: | 4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

  `uniform_pixel` = False

class `pyFAI.detectors.``ImXPadS140`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors.ImXPadS10`

  ImXPad detector: ImXPad s140 detector with 2x7modules

  `BORDER_PIXEL_SIZE_RELATIVE` = 2.5
  `MAX_SHAPE` = (240, 560)
  `MODULE_SIZE` = (120, 80)
  `PIXEL_SIZE` = (0.00013, 0.00013)
  `aliases` = ['Imxpad S140']
  `force_pixel` = True

class `pyFAI.detectors.``ImXPadS70`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors.ImXPadS10`

  ImXPad detector: ImXPad s70 detector with 1x7modules

  `BORDER_SIZE_RELATIVE` = 2.5
  `MAX_SHAPE` = (120, 560)
  `MODULE_SIZE` = (120, 80)
  `PIXEL_EDGES` = None
  `PIXEL_SIZE` = (0.00013, 0.00013)
  `aliases` = ['Imxpad S70']
  `force_pixel` = True

class `pyFAI.detectors.``Mar345`(pixel1=0.0001, pixel2=0.0001)

  Bases: `pyFAI.detectors.Detector`

  Mar345 Imaging plate detector

  In this detector, pixels are always square The valid image size are 2300, 2000, 1600, 1200, 3450, 3000, 2400, 1800

  `MAX_SHAPE` = (3450, 3450)
  `VALID_SIZE` = {2000: 0.00015, 1600: 0.00015, 3000: 0.0001, 2400: 0.0001, 3450: 0.0001, 1200: 0.00015, 2300: 0.00015, 1800: 0.0001}
  `aliases` = ['MAR 345', 'Mar3450']
  `calc_mask`()
  `force_pixel` = True
  `guess_binning`(data)

    Guess the binning/mode depending on the image shape :param data: 2-tuple with the shape of the image or the image with a .shape attribute.

class `pyFAI.detectors.``NexusDetector`(filename=None)

  Bases: `pyFAI.detectors.Detector`

  Class representing a 2D detector loaded from a NeXus file

  `getFit2D`()

    Helper method to serialize the description of a detector using the Fit2d units

    Returns: | representation of the detector easy to serialize
    Return type: | dict

  `getPyFAI`()

    Helper method to serialize the description of a detector using the pyFAI way with everything in S.I units.

    Returns: | representation of the detector easy to serialize
    Return type: | dict

  `load`(filename)

    Loads the detector description from a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html

    Parameters: | filename – name of the file on the disk

  classmethod `sload`(filename)

    Instantiate the detector description from a NeXus file, adapted from: http://download.nexusformat.org/sphinx/classes/base_classes/NXdetector.html

    Parameters: | filename – name of the file on the disk
    Returns: | Detector instance

class `pyFAI.detectors.``Perkin`(pixel1=0.0002, pixel2=0.0002)

  Bases: `pyFAI.detectors.Detector`

  Perkin detector

  `DEFAULT_PIXEL1` = 0.0002
  `DEFAULT_PIXEL2` = 0.0002
  `MAX_SHAPE` = (4096, 4096)
  `aliases` = ['Perkin detector', 'Perkin Elmer']
  `force_pixel` = True

class `pyFAI.detectors.``Pilatus`(pixel1=0.000172, pixel2=0.000172, x_offset_file=None, y_offset_file=None)

  Bases: `pyFAI.detectors.Detector`

  Pilatus detector: generic description containing mask algorithm

  Sub-classed by Pilatus1M, Pilatus2M and Pilatus6M

  `MODULE_GAP` = (17, 7)
  `MODULE_SIZE` = (195, 487)
  `calc_cartesian_positions`(d1=None, d2=None)

    Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!!

    Parameters:

    - d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
    - d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)

    Returns: | position in meter of the center of each pixels.
    Return type: | ndarray

    d1 and d2 must have the same shape, returned array will have the same shape.

  `calc_mask`()

    Returns a generic mask for Pilatus detectors...

  `force_pixel` = True
  `get_splineFile`()
  `set_splineFile`(splineFile=None)

    In this case splinefile is a couple filenames

  `splineFile`

class `pyFAI.detectors.``Pilatus100k`(pixel1=0.000172, pixel2=0.000172)

  Bases: `pyFAI.detectors.Pilatus`

  Pilatus 100k detector

  `MAX_SHAPE` = (195, 487)

class `pyFAI.detectors.``Pilatus1M`(pixel1=0.000172, pixel2=0.000172)

  Bases: `pyFAI.detectors.Pilatus`

  Pilatus 1M detector

  `MAX_SHAPE` = (1043, 981)

class `pyFAI.detectors.``Pilatus200k`(pixel1=0.000172, pixel2=0.000172)

  Bases: `pyFAI.detectors.Pilatus`

  Pilatus 200k detector

  `MAX_SHAPE` = (407, 487)

class `pyFAI.detectors.``Pilatus2M`(pixel1=0.000172, pixel2=0.000172)

  Bases: `pyFAI.detectors.Pilatus`

  Pilatus 2M detector

  `MAX_SHAPE` = (1679, 1475)

class `pyFAI.detectors.``Pilatus300k`(pixel1=0.000172, pixel2=0.000172)

  Bases: `pyFAI.detectors.Pilatus`

  Pilatus 300k detector

  `MAX_SHAPE` = (619, 487)

class `pyFAI.detectors.``Pilatus300kw`(pixel1=0.000172, pixel2=0.000172)

  Bases: `pyFAI.detectors.Pilatus`

  Pilatus 300k-wide detector

  `MAX_SHAPE` = (195, 1475)

class `pyFAI.detectors.``Pilatus6M`(pixel1=0.000172, pixel2=0.000172)

  Bases: `pyFAI.detectors.Pilatus`

  Pilatus 6M detector

  `MAX_SHAPE` = (2527, 2463)

class `pyFAI.detectors.``Rayonix`(pixel1=3.2e-05, pixel2=3.2e-05)

  Bases: `pyFAI.detectors.Detector`

  `BINNED_PIXEL_SIZE` = {1: 3.2e-05}
  `MAX_SHAPE` = (4096, 4096)
  `binning`
  `force_pixel` = True
  `get_binning`()
  `guess_binning`(data)

    Guess the binning/mode depending on the image shape :param data: 2-tuple with the shape of the image or the image with a .shape attribute.

  `set_binning`(bin_size=(1, 1))

    Set the “binning” of the detector,

    Parameters: | bin_size (int or (int, int)) – set the binning of the detector

class `pyFAI.detectors.``Rayonix133`(pixel1=6.4e-05, pixel2=6.4e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix 133 2D CCD detector detector also known as mar133

  Personnal communication from M. Blum

  What should be the default binning factor for those cameras ?

  Circular detector

  `BINNED_PIXEL_SIZE` = {8: 0.000256, 1: 3.2e-05, 2: 6.4e-05, 4: 0.000128}
  `MAX_SHAPE` = (4096, 4096)
  `aliases` = ['MAR133']
  `calc_mask`()

    Circular mask

  `force_pixel` = True

class `pyFAI.detectors.``RayonixLx170`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix lx170 2d CCD Detector (2x1 CCDs).

  Nota: this is the same for lx170hs

  `BINNED_PIXEL_SIZE` = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}
  `MAX_SHAPE` = (1920, 3840)
  `aliases` = ['Rayonix lx170']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixLx255`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix lx255 2d Detector (3x1 CCDs)

  Nota: this detector is also called lx255hs

  `BINNED_PIXEL_SIZE` = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}
  `MAX_SHAPE` = (1920, 5760)
  `aliases` = ['Rayonix lx225']

class `pyFAI.detectors.``RayonixMx170`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx170 2d CCD Detector (2x2 CCDs).

  Nota: this is the same for mx170hs

  `BINNED_PIXEL_SIZE` = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}
  `MAX_SHAPE` = (3840, 3840)
  `aliases` = ['Rayonix mx170']

class `pyFAI.detectors.``RayonixMx225`(pixel1=7.3242e-05, pixel2=7.3242e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx225 2D CCD detector detector

  Nota: this is the same definition for mx225he Personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {8: 0.000292969, 1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484}
  `MAX_SHAPE` = (6144, 6144)
  `aliases` = ['Rayonix mx225']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx225hs`(pixel1=7.8125e-05, pixel2=7.8125e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx225hs 2D CCD detector detector

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {1: 3.90625e-05, 2: 7.8125e-05, 3: 0.0001171875, 4: 0.00015625, 5: 0.0001953125, 6: 0.000234375, 8: 0.0003125, 10: 0.000390625}
  `MAX_SHAPE` = (5760, 5760)
  `aliases` = ['Rayonix mx225hs']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx300`(pixel1=7.3242e-05, pixel2=7.3242e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx300 2D detector (4x4 CCDs)

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {8: 0.000292969, 1: 3.6621e-05, 2: 7.3242e-05, 3: 0.000109971, 4: 0.000146484}
  `MAX_SHAPE` = (8192, 8192)
  `aliases` = ['Rayonix mx300']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx300hs`(pixel1=7.8125e-05, pixel2=7.8125e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx300hs 2D detector (4x4 CCDs)

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {1: 3.90625e-05, 2: 7.8125e-05, 3: 0.0001171875, 4: 0.00015625, 5: 0.0001953125, 6: 0.000234375, 8: 0.0003125, 10: 0.000390625}
  `MAX_SHAPE` = (7680, 7680)
  `aliases` = ['Rayonix mx300hs']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx325`(pixel1=7.9346e-05, pixel2=7.9346e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx325 and mx325he 2D detector (4x4 CCD chips)

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {8: 0.000317383, 1: 3.9673e-05, 2: 7.9346e-05, 3: 0.000119135, 4: 0.000158691}
  `MAX_SHAPE` = (8192, 8192)
  `aliases` = ['Rayonix mx325']

class `pyFAI.detectors.``RayonixMx340hs`(pixel1=8.85417e-05, pixel2=8.85417e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx340hs 2D detector (4x4 CCDs)

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}
  `MAX_SHAPE` = (7680, 7680)
  `aliases` = ['Rayonix mx340hs']
  `force_pixel` = True

class `pyFAI.detectors.``RayonixMx425hs`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix mx425hs 2D CCD camera (5x5 CCD chip)

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}
  `MAX_SHAPE` = (9600, 9600)
  `aliases` = ['Rayonix mx425hs']

class `pyFAI.detectors.``RayonixSx165`(pixel1=3.95e-05, pixel2=3.95e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix sx165 2d Detector also known as MAR165.

  Circular detector

  `BINNED_PIXEL_SIZE` = {8: 0.000316, 1: 3.95e-05, 2: 7.9e-05, 3: 0.000118616, 4: 0.000158}
  `MAX_SHAPE` = (4096, 4096)
  `aliases` = ['MAR165', 'Rayonix Sx165']
  `calc_mask`()

    Circular mask

  `force_pixel` = True

class `pyFAI.detectors.``RayonixSx200`(pixel1=4.8e-05, pixel2=4.8e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix sx200 2d CCD Detector.

  Pixel size are personnal communication from M. Blum.

  `BINNED_PIXEL_SIZE` = {8: 0.000384, 1: 4.8e-05, 2: 9.6e-05, 3: 0.000144, 4: 0.000192}
  `MAX_SHAPE` = (4096, 4096)
  `aliases` = ['Rayonix sx200']

class `pyFAI.detectors.``RayonixSx30hs`(pixel1=1.5625e-05, pixel2=1.5625e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix sx30hs 2D CCD camera (1 CCD chip)

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {1: 1.5625e-05, 2: 3.125e-05, 3: 4.6875e-05, 4: 6.25e-05, 5: 7.8125e-05, 6: 9.375e-05, 8: 0.000125, 10: 0.00015625}
  `MAX_SHAPE` = (1920, 1920)
  `aliases` = ['Rayonix Sx30hs']

class `pyFAI.detectors.``RayonixSx85hs`(pixel1=4.42708e-05, pixel2=4.42708e-05)

  Bases: `pyFAI.detectors.Rayonix`

  Rayonix sx85hs 2D CCD camera (1 CCD chip)

  Pixel size from a personnal communication from M. Blum

  `BINNED_PIXEL_SIZE` = {1: 4.42708e-05, 2: 8.85417e-05, 3: 0.0001328125, 4: 0.0001770833, 5: 0.0002213542, 6: 0.000265625, 8: 0.0003541667, 10: 0.0004427083}
  `MAX_SHAPE` = (1920, 1920)
  `aliases` = ['Rayonix Sx85hs']

class `pyFAI.detectors.``Titan`(pixel1=6e-05, pixel2=6e-05)

  Bases: `pyFAI.detectors.Detector`

  Titan CCD detector from Agilent. Mask not handled

  `MAX_SHAPE` = (2048, 2048)
  `aliases` = ['Titan 2k x 2k', 'OXD Titan', 'Agilent Titan']
  `force_pixel` = True
  `uniform_pixel` = True

class `pyFAI.detectors.``Xpad_flat`(pixel1=0.00013, pixel2=0.00013)

  Bases: `pyFAI.detectors.ImXPadS10`

  Xpad detector: generic description for ImXPad detector with 8x7modules

  `BORDER_PIXEL_SIZE_RELATIVE` = 2.5
  `MAX_SHAPE` = (960, 560)
  `MODULE_GAP` = (0.00357, 0)
  `MODULE_SIZE` = (120, 80)
  `PIXEL_SIZE` = (0.00013, 0.00013)
  `aliases` = ['Xpad S540 flat']
  `calc_cartesian_positions`(d1=None, d2=None, center=True, use_cython=True)

    Calculate the position of each pixel center in cartesian coordinate and in meter of a couple of coordinates. The half pixel offset is taken into account here !!! Adapted to Nexus detector definition

    Parameters:

    - d1 (ndarray (1D or 2D)) – the Y pixel positions (slow dimension)
    - d2 (ndarray (1D or 2D)) – the X pixel positions (fast dimension)
    - center – retrieve the coordinate of the center of the pixel

    @parm use_cython: set to False to test Numpy implementation :return: position in meter of the center of each pixels. :rtype: ndarray

    d1 and d2 must have the same shape, returned array will have the same shape.

  `calc_mask`()

    Returns a generic mask for Xpad detectors... discards the first line and raw form all modules: those are 2.5x bigger and often mis - behaving

  `force_pixel` = True
  `get_pixel_corners`()

    Calculate the position of the corner of the pixels

    Returns: | 4D array containing: pixel index (slow dimension) pixel index (fast dimension) corner index (A, B, C or D), triangles or hexagons can be handled the same way vertex position (z,y,x)

  `uniform_pixel` = False

# `spline` Module

This is piece of software aims at manipulating spline files describing for geometric corrections of the 2D detectors using cubic-spline.

Mainly used at ESRF with FReLoN CCD camera.

class `pyFAI.spline.``Spline`(filename=None)

  Bases: `object`

  This class is a python representation of the spline file

  Those file represent cubic splines for 2D detector distortions and makes heavy use of fitpack (dierckx in netlib) — A Python-C wrapper to FITPACK (by P. Dierckx). FITPACK is a collection of FORTRAN programs for curve and surface fitting with splines and tensor product splines. See _http://www.cs.kuleuven.ac.be/cwis/research/nalag/research/topics/fitpack.html or _http://www.netlib.org/dierckx/index.html

  `array2spline`(smoothing=1000, timing=False)

    Calculates the spline coefficients from the displacements matrix using fitpack.

    Parameters:

    - smoothing (float) – the greater the smoothing, the fewer the number of knots remaining
    - timing (bool) – print the profiling of the calculation

  `bin`(binning=None)

    Performs the binning of a spline (same camera with different binning)

    Parameters: | binning – binning factor as integer or 2-tuple of integers
    Type: | int or (int, int)

  `comparison`(ref, verbose=False)

    Compares the current spline distortion with a reference

    Parameters:

    - ref (Spline instance) – another spline file
    - verbose (bool) – print or not pylab plots

    Returns: | True or False depending if the splines are the same or not
    Return type: | bool

  `correct`(pos)
  `fliplr`()

    Flip the spline :return: new spline object

  `fliplrud`()

    Flip the spline left-right and up-down :return: new spline object

  `flipud`()

    Flip the spline up-down :return: new spline object

  `getPixelSize`()

    Return the size of the pixel from as a 2-tuple of floats expressed in meters.

    Returns: | the size of the pixel from a 2D detector
    Return type: | 2-tuple of floats expressed in meter.

  `read`(filename)

    read an ascii spline file from file

    Parameters: | filename (str) – file containing the cubic spline distortion file

  `setPixelSize`(pixelSize)

    Sets the size of the pixel from a 2-tuple of floats expressed in meters.

    Param: | pixel size in meter

  `spline2array`(timing=False)

    Calculates the displacement matrix using fitpack bisplev(x, y, tck, dx = 0, dy = 0)

    Parameters: | timing (bool) – profile the calculation or not
    Returns: | Nothing !
    Return type: | float or ndarray

    Evaluate a bivariate B-spline and its derivatives. Return a rank-2 array of spline function values (or spline derivative values) at points given by the cross-product of the rank-1 arrays x and y. In special cases, return an array or just a float if either x or y or both are floats.

  `splineFuncX`(x, y, list_of_points=False)

    Calculates the displacement matrix using fitpack for the X direction on the given grid.

    Parameters:

    - x (ndarray) – points of the grid in the x direction
    - y (ndarray) – points of the grid in the y direction
    - list_of_points – if true, consider the zip(x,y) instead of the of the square array

    Returns: | displacement matrix for the X direction
    Return type: | ndarray

  `splineFuncY`(x, y, list_of_points=False)

    calculates the displacement matrix using fitpack for the Y direction

    Parameters:

    - x (ndarray) – points in the x direction
    - y (ndarray) – points in the y direction
    - list_of_points – if true, consider the zip(x,y) instead of the of the square array

    Returns: | displacement matrix for the Y direction
    Return type: | ndarray

  `tilt`(center=(0.0, 0.0), tiltAngle=0.0, tiltPlanRot=0.0, distanceSampleDetector=1.0, timing=False)

    The tilt method apply a virtual tilt on the detector, the point of tilt is given by the center

    Parameters:

    - center (2-tuple of floats) – position of the point of tilt, this point will not be moved.
    - tiltAngle (float in the range [-90:+90] degrees) – the value of the tilt in degrees
    - tiltPlanRot (Float in the range [-180:180]) – the rotation of the tilt plan with the Ox axis (0 deg for y axis invariant, 90 deg for x axis invariant)
    - distanceSampleDetector (float) – the distance from sample to detector in meter (along the beam, so distance from sample to center)

    Returns: | tilted Spline instance
    Return type: | Spline

  `write`(filename)

    save the cubic spline in an ascii file usable with Fit2D or SPD

    Parameters: | filename (str) – name of the file containing the cubic spline distortion file

  `writeEDF`(basename)

    save the distortion matrices into a couple of files called basename-x.edf and basename-y.edf

    Parameters: | basename (str) – base of the name used to save the data

  `zeros`(xmin=0.0, ymin=0.0, xmax=2048.0, ymax=2048.0, pixSize=None)

    Defines a spline file with no ( zero ) displacement.

    Parameters:

    - xmin (float) – minimum coordinate in x, usually zero
    - xmax (float) – maximum coordinate in x (+1) usually 2048
    - ymin (float) – minimum coordinate in y, usually zero
    - ymax (float) – maximum coordinate y (+1) usually 2048
    - pixSize (float) – size of the pixel

  `zeros_like`(other)

    Defines a spline file with no ( zero ) displacement with the same shape as the other one given.

    Parameters: | other (Spline instance) – another Spline instance

`pyFAI.spline.``main`()

  Some tests ....

# `opencl` Module

class `pyFAI.opencl.``Device`(name='None', dtype=None, version=None, driver_version=None, extensions='', memory=None, available=None, cores=None, frequency=None, flop_core=None, idx=0, workgroup=1)

  Bases: `object`

  Simple class that contains the structure of an OpenCL device

  `pretty_print`()

    Complete device description

    Returns: | string

class `pyFAI.opencl.``OpenCL`

  Bases: `object`

  Simple class that wraps the structure ocl_tools_extended.h

  This is a static class. ocl should be the only instance and shared among all python modules.

  `context_cache` = {}
  `create_context`(devicetype='ALL', useFp64=False, platformid=None, deviceid=None, cached=True)

    Choose a device and initiate a context.

    Devicetypes can be GPU,gpu,CPU,cpu,DEF,ACC,ALL. Suggested are GPU,CPU. For each setting to work there must be such an OpenCL device and properly installed. E.g.: If Nvidia driver is installed, GPU will succeed but CPU will fail. The AMD SDK kit is required for CPU via OpenCL. :param devicetype: string in [“cpu”,”gpu”, “all”, “acc”] :param useFp64: boolean specifying if double precision will be used :param platformid: integer :param devid: integer :return: OpenCL context on the selected device

  `get_platform`(key)

    Return a platform according

    Parameters: | key (int or str) – identifier for a platform, either an Id (int) or it’s name

  `nb_devices` = 0
  `platforms` = []
  `select_device`(dtype='ALL', memory=None, extensions=[], best=True, **kwargs)

    Select a device based on few parameters (at the end, keep the one with most memory)

    Parameters:

    - type – “gpu” or “cpu” or “all” ....
    - memory – minimum amount of memory (int)
    - extensions – list of extensions to be present
    - best – shall we look for the

class `pyFAI.opencl.``Platform`(name='None', vendor='None', version=None, extensions=None, idx=0)

  Bases: `object`

  Simple class that contains the structure of an OpenCL platform

  `add_device`(device)

    Add new device to the platform

    Parameters: | device – Device instance

  `get_device`(key)

    Return a device according to key

    Parameters: | key (int or str) – identifier for a device, either it’s id (int) or it’s name

`pyFAI.opencl.``allocate_cl_buffers`(buffers, device, context)

  Parameters: | buffers – the buffers info use to create the pyopencl.Buffer
  Returns: | a dict containing the instanciated pyopencl.Buffer
  Return type: | dict(str, pyopencl.Buffer)

  This method instanciate the pyopencl.Buffer from the buffers description.

`pyFAI.opencl.``release_cl_buffers`(cl_buffers)

  Parameters: | cl_buffer (dict(str, pyopencl.Buffer)) – the buffer you want to release

  This method release the memory of the buffers store in the dict

# `ocl_azim` Module

# `ocl_azim_lut` Module

# `ocl_azim_csr` Module

# `ocl_azim_csr_dis` Module

# `worker` Module

This module contains the Worker class:

A tool able to perform azimuthal integration with: additional saving capabilities like - save as 2/3D structure in a HDF5 File - read from HDF5 files

Aims at being integrated into a plugin like LImA or as model for the GUI

The configuration of this class is mainly done via a dictionary transmitted as a JSON string: Here are the valid keys:

> “dist”, “poni1”, “poni2”, “rot1” “rot3” “rot2” “pixel1” “pixel2”

> “splineFile” “wavelength”

> “poni” #path of the file

> “chi_discontinuity_at_0” “do_mask” “do_dark” “do_azimuthal_range” “do_flat” “do_2D” “azimuth_range_min” “azimuth_range_max”

> “polarization_factor” “nbpt_rad” “do_solid_angle” “do_radial_range” “do_poisson” “delta_dummy” “nbpt_azim” “flat_field” “radial_range_min” “dark_current” “do_polarization” “mask_file” “detector” “unit” “radial_range_max” “val_dummy” “do_dummy” “method”

}

class `pyFAI.worker.``DistortionWorker`(detector=None, dark=None, flat=None, solidangle=None, polarization=None, mask=None, dummy=None, delta_dummy=None, device=None)

  Bases: `object`

  Simple worker doing dark, flat, solid angle and polarization correction

  `process`(data, normalization=None)

    Process the data and apply a normalization factor :param data: input data :param normalization: normalization factor :return processed data

class `pyFAI.worker.``PixelwiseWorker`(dark=None, flat=None, solidangle=None, polarization=None, mask=None, dummy=None, delta_dummy=None, device=None)

  Bases: `object`

  Simple worker doing dark, flat, solid angle and polarization correction

  `process`(data, normalization=None)

    Process the data and apply a normalization factor :param data: input data :param normalization: normalization factor :return processed data

class `pyFAI.worker.``Worker`(azimuthalIntgrator=None, shapeIn=(2048, 2048), shapeOut=(360, 500), unit='r_mm', dummy=None, delta_dummy=None)

  Bases: `object`

  `do_2D`()
  `get_config`()

    return configuration as a dictionary

  `get_json_config`()

    return configuration as a JSON string

  `get_normalization_factor`()
  `get_unit`()
  `normalization_factor`
  `process`(data)

    Process a frame #TODO: dark, flat, sa are missing

    Param: | data: numpy array containing the input image

  `reconfig`(shape=(2048, 2048), sync=False)

    This is just to force the integrator to initialize with a given input image shape

    Parameters:

    - shape – shape of the input image
    - sync – return only when synchronized

  `reset`()

    this is just to force the integrator to initialize

  `save_config`(filename=None)
  `setDarkcurrentFile`(imagefile)
  `setExtension`(ext)

    enforce the extension of the processed data file written

  `setFlatfieldFile`(imagefile)
  `setJsonConfig`(jsonconfig)
  `setSubdir`(path)

    Set the relative or absolute path for processed data

  `set_normalization_factor`(value)
  `set_unit`(value)
  `unit`
  `warmup`(sync=False)

    Process a dummy image to ensure everything is initialized

    Parameters: | sync – wait for processing to be finished

# `io` Module

Module for “high-performance” writing in either 1D with Ascii , or 2D with FabIO or even nD with n varying from 2 to 4 using HDF5

Stand-alone module which tries to offer interface to HDF5 via H5Py and capabilities to write EDF or other formats using fabio.

Can be imported without h5py but then limited to fabio & ascii formats.

TODO: * add monitor to HDF5

class `pyFAI.io.``AsciiWriter`(filename=None, prefix='fai_', extension='.dat')

  Bases: `pyFAI.io.Writer`

  Ascii file writer (.xy or .dat)

  `init`(fai_cfg=None, lima_cfg=None)

    Creates the directory that will host the output file(s)

  `write`(data, index=0)

class `pyFAI.io.``FabioWriter`(filename=None)

  Bases: `pyFAI.io.Writer`

  Image file writer based on FabIO

  TODO !!!

  `init`(fai_cfg=None, lima_cfg=None)

    Creates the directory that will host the output file(s)

  `write`(data, index=0)

class `pyFAI.io.``HDF5Writer`(filename, hpath='data', fast_scan_width=None)

  Bases: `pyFAI.io.Writer`

  Class allowing to write HDF5 Files.

  `CONFIG` = 'pyFAI'
  `DATASET_NAME` = 'data'
  `close`()
  `flush`(radial=None, azimuthal=None)

    Update some data like axis units and so on.

    Parameters:

    - radial – position in radial direction
    - azimuthal – position in azimuthal direction

  `init`(fai_cfg=None, lima_cfg=None)

    Initializes the HDF5 file for writing :param fai_cfg: the configuration of the worker as a dictionary

  `write`(data, index=0)

    Minimalistic method to limit the overhead. :param data: array with intensities or tuple (2th,I) or (I,2th,chi)

class `pyFAI.io.``Nexus`(filename, mode='r')

  Bases: `object`

  Writer class to handle Nexus/HDF5 data Manages: entry

  > pyFAI-subentry
  >   detector

  #TODO: make it thread-safe !!!

  `close`()

    close the filename and update all entries

  `deep_copy`(name, obj, where='/', toplevel=None, excluded=None, overwrite=False)

    perform a deep copy: create a “name” entry in self containing a copy of the object

    Parameters:

    - where – path to the toplevel object (i.e. root)
    - toplevel – firectly the top level Group
    - excluded – list of keys to be excluded
    - overwrite – replace content if already existing

  `find_detector`(all=False)

    Tries to find a detector within a NeXus file, takes the first compatible detector

    Parameters: | all – return all detectors found as a list

  `get_class`(grp, class_type='NXcollection')

    return all sub-groups of the given type within a group

    Parameters:

    - grp – HDF5 group
    - class_type – name of the NeXus class

  `get_data`(grp, class_type='NXdata')

    return all dataset of the the NeXus class NXdata

    Parameters:

    - grp – HDF5 group
    - class_type – name of the NeXus class

  `get_entries`()

    retrieves all entry sorted the latest first.

    Returns: | list of HDF5 groups

  `get_entry`(name)

    Retrieves an entry from its name

    Parameters: | name – name of the entry to retrieve
    Returns: | HDF5 group of NXclass == NXentry

  `new_class`(grp, name, class_type='NXcollection')

    create a new sub-group with type class_type :param grp: parent group :param name: name of the sub-group :param class_type: NeXus class name :return: subgroup created

  `new_detector`(name='detector', entry='entry', subentry='pyFAI')

    Create a new entry/pyFAI/Detector

    Parameters:

    - detector – name of the detector
    - entry – name of the entry
    - subentry – all pyFAI description of detectors should be in a pyFAI sub-entry

  `new_entry`(entry='entry', program_name='pyFAI', title='description of experiment', force_time=None)

    Create a new entry

    Parameters:

    - entry – name of the entry
    - program_name – value of the field as string
    - title – value of the field as string

    @force_time: enforce the start_time (as string!) :return: the corresponding HDF5 group

  `new_instrument`(entry='entry', instrument_name='id00')

    Create an instrument in an entry or create both the entry and the instrument if

class `pyFAI.io.``Writer`(filename=None, extension=None)

  Bases: `object`

  Abstract class for writers.

  `CONFIG_ITEMS` = ['filename', 'dirname', 'extension', 'subdir', 'hpath']
  `flush`(*arg, **kwarg)

    To be implemented

  `init`(fai_cfg=None, lima_cfg=None)

    Creates the directory that will host the output file(s) :param fai_cfg: configuration for worker :param lima_cfg: configuration for acquisition

  `setJsonConfig`(json_config=None)

    Sets the JSON configuration

  `write`(data)

    To be implemented

`pyFAI.io.``from_isotime`(text, use_tz=False)

  Parameters: | text – string representing the time is iso format

`pyFAI.io.``get_isotime`(forceTime=None)

  Parameters: | forceTime (float) – enforce a given time (current by default)
  Returns: | the current time as an ISO8601 string
  Return type: | string

`pyFAI.io.``is_hdf5`(filename)

  Check if a file is actually a HDF5 file

  Parameters: | filename – this file has better to exist

# `calibration` Module

# `peak_picker` Module

# `massif` Module

# `blob_detection` Module

# `calibrant` Module

# `distortion` Module

class `pyFAI.distortion.``Distortion`(detector='detector', shape=None, method='LUT', device=None, workgroup=8)

  Bases: `object`

  This class applies a distortion correction on an image.

  New version compatible both with CSR and LUT...

  `calc_LUT`(*arg, **kw)
  `calc_init`()

    initialize all arrays

  `calc_pos`(*arg, **kw)
  `calc_size`(*arg, **kw)

    Considering the “half-CCD” spline from ID11 which describes a (1025,2048) detector, the physical location of pixels should go from: [-17.48634 : 1027.0543, -22.768829 : 2028.3689] We chose to discard pixels falling outside the [0:1025,0:2048] range with a lose of intensity

  `correct`(image)

    Correct an image based on the look-up table calculated ...

    Parameters: | image – 2D-array with the image
    Returns: | corrected 2D image

  `reset`(method=None, device=None, workgroup=None)

    reset the distortion correction and re-calculate the look-up table

    Parameters:

    - method – can be “lut” or “csr”, “lut” looks faster
    - device – can be None, “cpu” or “gpu” or the id as a 2-tuple of integer
    - worgroup – enforce the workgroup size for CSR.

  `uncorrect`(image)

    Take an image which has been corrected and transform it into it’s raw (with loss of information)

    Parameters: | image – 2D-array with the image
    Returns: | uncorrected 2D image and a mask (pixels in raw image

class `pyFAI.distortion.``Quad`(buffer)

  Bases: `object`

  > > > xxxxxA
  > > > xxxxxxxI’xxxxxxxx x

  > > xxxxxxxxIxxxxxx | x

  > Bxxxxxxxxxxxx | | x x | | x x | | x

  > > x | | x x | | x x | | x x | | x x | | x

  > > > x | | x x | | x x | | x x O| P A’ x

  —————–J——————+——————————–L———————–

    x | x x | x x | x

    > x | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxD CxxxxxxxxxxxxxxxxxKxxxxx

  `calc_area`()
  `calc_area_AB`(I1, I2)
  `calc_area_BC`(J1, J2)
  `calc_area_CD`(K1, K2)
  `calc_area_DA`(L1, L2)
  `calc_area_old`()
  `calc_area_vectorial`()
  `get_box`(i, j)
  `get_box_size0`()
  `get_box_size1`()
  `get_idx`(i, j)
  `get_offset0`()
  `get_offset1`()
  `init_slope`()
  `integrateAB`(start, stop, calc_area)
  `populate_box`()
  `reinit`(A0, A1, B0, B1, C0, C1, D0, D1)

`pyFAI.distortion.``test`()

# `units` Module

class `pyFAI.units.``Enum`

  Bases: `dict`

  Simple class half way between a dict and a class, behaving as an enum

`pyFAI.units.``to_unit`(obj)

# `utils` Module

Utilities, mainly for image treatment

class `pyFAI.utils.``FixedParameters`

  Bases: `set`

  Like a set, made for FixedParameters in geometry refinement

  `add_or_discard`(key, value=True)

    Add a value to a set if value, else discard it :param key: element to added or discared from set :type value: boolean. If None do nothing ! :return: None

`pyFAI.utils.``averageDark`(lstimg, center_method='mean', cutoff=None, quantiles=(0.5, 0.5))

  Averages a serie of dark (or flat) images. Centers the result on the mean or the median ... but averages all frames within cutoff*std

  Parameters:

  - lstimg – list of 2D images or a 3D stack
  - center_method – is the center calculated by a “mean” or a “median”, or “quantile”
  - cutoff – keep all data where (I-center)/std < cutoff
  - quantiles – 2-tuple of floats average out data between the two quantiles

  Returns: | 2D image averaged

`pyFAI.utils.``averageImages`(listImages, output=None, threshold=0.1, minimum=None, maximum=None, darks=None, flats=None, filter_='mean', correct_flat_from_dark=False, cutoff=None, quantiles=None, fformat='edf')

  Takes a list of filenames and create an average frame discarding all saturated pixels.

  Parameters:

  - listImages – list of string representing the filenames
  - output – name of the optional output file
  - threshold – what is the upper limit? all pixel > max*(1-threshold) are discareded.
  - minimum – minimum valid value or True
  - maximum – maximum valid value
  - darks – list of dark current images for subtraction
  - flats – list of flat field images for division
  - filter – can be “min”, “max”, “median”, “mean”, “sum”, “quantiles” (default=’mean’)
  - correct_flat_from_dark – shall the flat be re-corrected ?
  - cutoff – keep all data where (I-center)/std < cutoff
  - quantiles – 2-tuple containing the lower and upper quantile (0<q<1) to average out.
  - fformat – file format of the output image, default: edf

  Returns: | filename with the data or the data ndarray in case format=None

`pyFAI.utils.``binning`(input_img, binsize, norm=True)

  Parameters:

  - input_img – input ndarray
  - binsize – int or 2-tuple representing the size of the binning
  - norm – if False, do average instead of sum

  Returns: | binned input ndarray

`pyFAI.utils.``boundingBox`(img)

  Tries to guess the bounding box around a valid massif

  Parameters: | img – 2D array like
  Returns: | 4-typle (d0_min, d1_min, d0_max, d1_max)

`pyFAI.utils.``calc_checksum`(ary, safe=True)

  Calculate the checksum by default (or returns its buffer location if unsafe)

`pyFAI.utils.``center_of_mass`(img)

  Calculate the center of mass of of the array. Like scipy.ndimage.measurements.center_of_mass :param img: 2-D array :return: 2-tuple of float with the center of mass

`pyFAI.utils.``concatenate_cl_kernel`(filenames)

  Parameters: | filenames – filenames containing the kernels

  this method concatenates all the kernel from the list

`pyFAI.utils.``convert_CamelCase`(name)

  convert a function name in CamelCase into camel_case

`pyFAI.utils.``deg2rad`(dd)

  Convert degrees to radian in the range -pi->pi

  Parameters: | dd – angle in degrees

  Nota: depending on the platform it could be 0<2pi A branch is cheaper than a trigo operation

`pyFAI.utils.``deprecated`(func)

`pyFAI.utils.``dog`(s1, s2, shape=None)

  2D difference of gaussian typically 1 to 10 parameters

`pyFAI.utils.``dog_filter`(input_img, sigma1, sigma2, mode='reflect', cval=0.0)

  2-dimensional Difference of Gaussian filter implemented with FFTw

  Parameters:

  - input_img (array-like) – input_img array to filter
  - sigma (scalar or sequence of scalars) – standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
  - mode – {‘reflect’,’constant’,’nearest’,’mirror’, ‘wrap’}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to ‘constant’. Default is ‘reflect’
  - cval – scalar, optional Value to fill past edges of input if `mode` is ‘constant’. Default is 0.0

`pyFAI.utils.``expand`(input_img, sigma, mode='constant', cval=0.0)

  Expand array a with its reflection on boundaries

  Parameters:

  - a – 2D array
  - sigma – float or 2-tuple of floats.

  :param mode:”constant”, “nearest”, “reflect” or mirror :param cval: filling value used for constant, 0.0 by default

  Nota: sigma is the half-width of the kernel. For gaussian convolution it is adviced that it is 4*sigma_of_gaussian

`pyFAI.utils.``expand2d`(vect, size2, vertical=True)

  This expands a vector to a 2d-array.

  The resul is the same as if vertical:

  > numpy.outer(numpy.ones(size2), vect)

  else:
    numpy.outer(vect, numpy.ones( size2))

  This is a ninja optimization: replace *1 with a memcopy, saves 50% of time at the ms level.

  Parameters:

  - vect – 1d vector
  - size2 – size
  - vertical – if False,

`pyFAI.utils.``expand_args`(args)

  Takes an argv and expand it (under Windows, cmd does not convert *.tif into a list of files. Keeps only valid files (thanks to glob)

  Parameters: | args – list of files or wilcards
  Returns: | list of actual args

`pyFAI.utils.``float_`(val)

  Convert anything to a float ... or None if not applicable

`pyFAI.utils.``gaussian`(M, std)

  Return a Gaussian window of length M with standard-deviation std.

  This differs from the scipy.signal.gaussian implementation as: - The default for sym=False (needed for gaussian filtering without shift) - This implementation is normalized

  Parameters:

  - M – length of the windows (int)
  - std – standatd deviation sigma

  The FWHM is 2*numpy.sqrt(2 * numpy.pi)*std

`pyFAI.utils.``gaussian_filter`(input_img, sigma, mode='reflect', cval=0.0)

  2-dimensional Gaussian filter implemented with FFTw

  Parameters:

  - input_img (array-like) – input array to filter
  - sigma (scalar or sequence of scalars) – standard deviation for Gaussian kernel. The standard deviations of the Gaussian filter are given for each axis as a sequence, or as a single number, in which case it is equal for all axes.
  - mode – {‘reflect’,’constant’,’nearest’,’mirror’, ‘wrap’}, optional The `mode` parameter determines how the array borders are handled, where `cval` is the value when mode is equal to ‘constant’. Default is ‘reflect’
  - cval – scalar, optional Value to fill past edges of input if `mode` is ‘constant’. Default is 0.0

`pyFAI.utils.``get_calibration_dir`()

  get the full path of a calibration directory

  Returns: | the full path of the calibrant file

`pyFAI.utils.``get_cl_file`(filename)

  get the full path of a openCL file

  Returns: | the full path of the openCL source file

`pyFAI.utils.``get_ui_file`(filename)

  get the full path of a user-interface file

  Returns: | the full path of the ui

`pyFAI.utils.``int_`(val)

  Convert anything to an int ... or None if not applicable

`pyFAI.utils.``is_far_from_group`(pt, lst_pts, d2)

  Tells if a point is far from a group of points, distance greater than d2 (distance squared)

  Parameters:

  - pt – point of interest
  - lst_pts – list of points
  - d2 – minimum distance squarred

  Returns: | True If the point is far from all others.

class `pyFAI.utils.``lazy_property`(fget)

  Bases: `object`

  meant to be used for lazy evaluation of an object attribute. property should represent non-mutable data, as it replaces itself.

`pyFAI.utils.``maximum_position`(img)

  Same as scipy.ndimage.measurements.maximum_position: Find the position of the maximum of the values of the array.

  Parameters: | img – 2-D image
  Returns: | 2-tuple of int with the position of the maximum

`pyFAI.utils.``measure_offset`(img1, img2, method='numpy', withLog=False, withCorr=False)

  Measure the actual offset between 2 images :param img1: ndarray, first image :param img2: ndarray, second image, same shape as img1 :param withLog: shall we return logs as well ? boolean :return: tuple of floats with the offsets

`pyFAI.utils.``readFloatFromKeyboard`(text, dictVar)

  Read float from the keyboard ....

  Parameters:

  - text – string to be displayed
  - dictVar – dict of this type: {1: [set_dist_min],3: [set_dist_min, set_dist_guess, set_dist_max]}

`pyFAI.utils.``read_cl_file`(filename)

  Parameters: | filename – read an OpenCL file and apply a preprocessor
  Returns: | preprocessed source code

`pyFAI.utils.``relabel`(label, data, blured, max_size=None)

  Relabel limits the number of region in the label array. They are ranked relatively to their max(I0)-max(blur(I0)

  Parameters:

  - label – a label array coming out of scipy.ndimage.measurement.label
  - data – an array containing the raw data
  - blured – an array containing the blured data
  - max_size – the max number of label wanted

  :return array like label

`pyFAI.utils.``removeSaturatedPixel`(ds, threshold=0.1, minimum=None, maximum=None)

  Parameters:

  - ds – a dataset as ndarray
  - threshold – what is the upper limit? all pixel > max*(1-threshold) are discareded.
  - minimum – minumum valid value (or True for auto-guess)
  - maximum – maximum valid value

  Returns: | another dataset

`pyFAI.utils.``roundfft`(N)

  This function returns the integer >=N for which size the Fourier analysis is faster (fron the FFT point of view) Credit: Alessandro Mirone, ESRF, 2012

  Parameters: | N – interger on which one would like to do a Fourier transform
  Returns: | integer with a better choice

`pyFAI.utils.``shift`(input_img, shift_val)

  Shift an array like scipy.ndimage.interpolation.shift(input_img, shift_val, mode=”wrap”, order=0) but faster :param input_img: 2d numpy array :param shift_val: 2-tuple of integers :return: shifted image

`pyFAI.utils.``shiftFFT`(input_img, shift_val, method='fftw')

  Do shift using FFTs Shift an array like scipy.ndimage.interpolation.shift(input, shift, mode=”wrap”, order=”infinity”) but faster :param input_img: 2d numpy array :param shift_val: 2-tuple of float :return: shifted image

`pyFAI.utils.``str_`(val)

  Convert anything to a string ... but None -> “”

`pyFAI.utils.``timeit`(func)

`pyFAI.utils.``unBinning`(binnedArray, binsize, norm=True)

  Parameters:

  - binnedArray – input ndarray
  - binsize – 2-tuple representing the size of the binning
  - norm – if True (default) decrease the intensity by binning factor. If False, it is non-conservative

  Returns: | unBinned input ndarray

# `gui_utils` Module

gui_utils

Module to handle matplotlib and the Qt backend

class `pyFAI.gui_utils.``Event`(width, height)

  Bases: `object`

  Dummy class for dummy things

`pyFAI.gui_utils.``maximize_fig`(fig=None)

  Try to set the figure fullscreen

`pyFAI.gui_utils.``update_fig`(fig=None)

  Update a matplotlib figure with a Qt4 backend

  Parameters: | fig – pylab figure