def tif_to_iq(
# Calibration info
poni_file=None, dspace_file=None, detector=None,
calibration_imagefile=None, wavelength=None,
# image info
image_path=None, out_ending='',
# Correction info
solid=False, pol=True, polarization=0.95,
# old_files info
generate_mask=False, mask_file=None, initial_m=None,
# integration info
space='Q', resolution=None, average_method='median',
plot_verbose=False):
"""
Takes TIFF images to CHI files, including masking, integrating, and CHI
writing
Parameters
----------
poni_file: str
Location of poni file, a detector geometry file produced by pyFAI.
If none is given a GUI prompt will ask for the file.
dspace_file : str
Location of the calibrant d-spacing file. This is used to generate
the poni file if no poni file is loaded.
detector: str
Name of the detector. This is used to generate
the poni file if no poni file is loaded.
calibration_imagefile : str
Location of the calibration image. This is used to generate
the poni file if no poni file is loaded
wavelength: float
The wavelength of light in angstrom. This is used to generate
the poni file if no poni file is loaded.
image_path: str or list of str or tuple of str
The image(s) to be masked and integrated. If more than one image is
passed via a list or tuple, sum the images together before proceeding.
out_ending: str
The ending to append to the output file name before the extension
solid: bool
If true, apply solid angle correction as calculated by pyFAI, else do not
pol: bool
If true, apply polarization angle correction
polarization: float
The polarization of the beam used in the polarization correction
generate_mask: bool
If true, generate mask via mask writing algorithum
mask_file: str
Location of mask file
initial_m: float
Initial guess at ring threshold mask scale factor
space: {'Q'}
Eventually will support TTH as well
resolution:
The resolution in Q or TTH of the detector
average_method: str or function
The function to use in binned statistics to calculate the average
plot_verbose: bool
If true, generate a bunch of plots related to statistics of the rings
Returns
-------
str:
The name of the chi file
str:
The name of the mask, if generated
"""
# load the calibration file/calibrate
resolution = resolution if resolution is not None else .02
a = IO.calibrate(poni_file, calibration_imagefile, dspace_file, wavelength,
detector)
# load image
xray_image, bulk_image_path_no_ext, image_path = IO.loadimage(image_path)
# mask image, expect out an array of 1s and 0s which is the mask, if the
# mask is 0 then mask that pixel
mask_array = None
if generate_mask is True:
"""This should handle all mask writing functions including binning,
applying criteria, plotting, and writing the mask out as a numpy
array where masked pixels are zero. This should also give the
option to combine the calculated mask with a previous user
generated mask."""
mask_array = Calculate.write_mask(xray_image, a, mask_file, initial_m,
resolution)
# write mask to FIT2D file for later use
mask_file_name = IO.fit2d_save(mask_array, bulk_image_path_no_ext)
elif mask_file is not None:
# LOAD THE MASK
mask_array = IO.loadmask(mask_file)
# mask_array = np.abs(mask_array-1)
if mask_array is None:
mask_array = np.ones(np.shape(xray_image))
if plot_verbose:
plt.imshow(mask_array, cmap='cubehelix'), plt.colorbar()
plt.savefig('/home/christopher/mask.png', bbox_inches='tight',
transparent=True)
plt.show()
plt.imshow(mask_array*xray_image, cmap='cubehelix'), plt.colorbar()
plt.show()
# correct for corrections
corrected_image = Calculate.corrections(xray_image, geometry_object=a,
solid=solid, pol=pol,
polarization_factor=polarization)
position_matrix = None
# TODO: Add options for tth
if space == 'Q':
position_matrix = a.qArray(np.shape(xray_image)) / 10
max_position = np.max(position_matrix)
masked_position = position_matrix * mask_array
# Integrate using the global average
independant_out_array = np.arange(0, max_position + resolution, resolution)
integrated = Calculate.statistics1d(corrected_image,
position_matrix=masked_position,
max=max_position, step=resolution,
statistic=average_method)
integrated[np.isnan(integrated)] = 0
uncertainty_array = np.sqrt(
Calculate.variance1d(corrected_image, position_matrix=masked_position,
max=max_position, step=resolution))
uncertainty_array[np.isnan(uncertainty_array)] = 0
if plot_verbose is True:
no_mask_integrated = Calculate.statistics1d(corrected_image,
position_matrix=position_matrix,
max=max_position,
step=resolution,
statistic=average_method)
integrated_mean = Calculate.statistics1d(corrected_image,
position_matrix=masked_position,
max=max_position,
step=resolution,
statistic='mean')
fig, ax = plt.subplots()
ax.plot(independant_out_array, integrated, 'g', label='Median I[Q]')
ax.plot(independant_out_array, integrated_mean, 'b', label='Mean I[Q]')
ax.plot(independant_out_array, ((integrated - integrated_mean)/((
integrated+integrated_mean)/2))*10e6,
'k', label='((Median-Mean)/('
'Median+Mean)/2)x10^6')
ax.legend(loc='upper right')
plt.xlabel('Q (1/A)')
plt.ylabel('Raw Counts')
plt.savefig('/home/christopher/integrator.png', bbox_inches='tight',
transparent=True)
plt.show()
no_mask_uncertainty_percent_array = np.sqrt(
Calculate.variance1d(corrected_image,
position_matrix=position_matrix,
max=max_position, step=resolution)) / no_mask_integrated
fig, ax = plt.subplots()
ax.plot(independant_out_array, integrated, 'g', label='I[Q]')
ax.plot(independant_out_array, no_mask_integrated, 'k', label='No '
'old_files I[Q]')
ax.plot(independant_out_array, integrated - no_mask_integrated, 'r',
label='Difference')
legend = ax.legend(loc='upper right')
plt.show()
old_settings = np.seterr(divide='ignore')
uncertainty_percent_array = uncertainty_array / integrated
uncertainty_percent_array[np.isnan(uncertainty_percent_array)] = 0
np.seterr(**old_settings)
fig, ax = plt.subplots()
ax.plot(independant_out_array, uncertainty_percent_array * 100, 'g',
label='Sigma I[Q]')
plt.xlabel('Q (1/A)')
plt.ylabel('% uncertainty')
legend = ax.legend(loc='upper right')
plt.show()
ring_std = Calculate.statistics1d(corrected_image,
position_matrix=masked_position,
max=max_position, step=resolution,
statistic=np.std) / integrated
ring_std_no_mask = Calculate.statistics1d(corrected_image,
position_matrix=position_matrix,
max=max_position,
step=resolution,
statistic=np.std) / no_mask_integrated
ring_s = Calculate.statistics1d(corrected_image,
position_matrix=masked_position,
max=max_position, step=resolution,
statistic=stats.skew)
ring_s_no_mask = Calculate.statistics1d(corrected_image,
position_matrix=position_matrix,
max=max_position,
step=resolution,
statistic=stats.skew)
fig, ax = plt.subplots()
ax.plot(independant_out_array, ring_std, 'g',
label='Ring Standard Deviation')
ax.plot(independant_out_array, ring_std_no_mask, 'b',
label='Ring Standard Deviation No old_files')
legend = ax.legend(loc='upper right')
plt.show()
fig, ax = plt.subplots()
ax.plot(independant_out_array, ring_s, 'g',
label='Ring Skew')
ax.plot(independant_out_array, ring_s_no_mask, 'b',
label='Ring Skew No old_files')
legend = ax.legend(loc='upper right')
plt.show()
# plt.plot(independant_out_array, test_uncertainty / integrated * 100)
# plt.show()
plt.plot(
independant_out_array, integrated, 'g',
independant_out_array, integrated - uncertainty_array, 'b',
independant_out_array, integrated + uncertainty_array, 'r'
)
plt.show()
# plt.plot(
# independant_out_array, integrated, 'g',
# independant_out_array, integrated - test_uncertainty, 'b',
# independant_out_array, integrated + test_uncertainty, 'r'
# )
# plt.show()
# Save file as chi file with uncertainties
out_array = np.c_[independant_out_array, integrated, uncertainty_array]
# print out_array.shape
chi_filename = os.path.splitext(bulk_image_path_no_ext)[0] + out_ending
out_file_name = IO.save_chi(out_array, a, chi_filename, mask_file, image_path)
if generate_mask is True:
return out_file_name, mask_file_name
return out_file_name
@author: Christopher J. Wright"""
__author__ = 'Christopher J. Wright'
import numpy as np
import matplotlib.pyplot as plt
import IO
import Calculate
poni_file = '/media/Seagate_Backup_Plus_Drive/Mar2014/Ni/17_21_24_NiSTD_300K-00002.poni'
geometry_object = IO.loadgeometry(poni_file)
# load image
xray_image = IO.loadimage(
'/media/Seagate_Backup_Plus_Drive/Mar2014/Ni/17_21_24_NiSTD_300K-00002.tif')
# generate radial array based on image shape
# TODO: use a more Q/angle based system
Radi = geometry_object.rArray(xray_image.shape)
angles = geometry_object.chiArray(xray_image.shape)
# create integer array of radi by division by the pixel resolution
roundR = np.around(Radi / geometry_object.pixel1).astype(int)
# define the maximum radius for creation of numpy arrays
# make maxr into an integer so it can be used as a counter
maxr = int(np.ceil(np.amax(roundR)))
pols = []
print 'start opts'