本文整理汇总了Python中pyFAI.azimuthalIntegrator.AzimuthalIntegrator.integrate2d方法的典型用法代码示例。如果您正苦于以下问题：Python AzimuthalIntegrator.integrate2d方法的具体用法？Python AzimuthalIntegrator.integrate2d怎么用？Python AzimuthalIntegrator.integrate2d使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类pyFAI.azimuthalIntegrator.AzimuthalIntegrator的用法示例。
在下文中一共展示了AzimuthalIntegrator.integrate2d方法的6个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: run
# 需要导入模块: from pyFAI.azimuthalIntegrator import AzimuthalIntegrator [as 别名]
# 或者: from pyFAI.azimuthalIntegrator.AzimuthalIntegrator import integrate2d [as 别名]
def run(self):
ai = AzimuthalIntegrator(
dist=self.__distance,
poni1=self.__poni1,
poni2=self.__poni2,
rot1=self.__rotation1,
rot2=self.__rotation2,
rot3=self.__rotation3,
detector=self.__detector,
wavelength=self.__wavelength)
numberPoint1D = 1024
numberPointRadial = 400
numberPointAzimuthal = 360
# FIXME error model, method
self.__result1d = ai.integrate1d(
data=self.__image,
npt=numberPoint1D,
unit=self.__radialUnit,
mask=self.__mask,
polarization_factor=self.__polarizationFactor)
self.__result2d = ai.integrate2d(
data=self.__image,
npt_rad=numberPointRadial,
npt_azim=numberPointAzimuthal,
unit=self.__radialUnit,
mask=self.__mask,
polarization_factor=self.__polarizationFactor)
if self.__calibrant:
rings = self.__calibrant.get_2th()
rings = filter(lambda x: x <= self.__result1d.radial[-1], rings)
rings = list(rings)
try:
rings = utils.from2ThRad(rings, self.__radialUnit, self.__wavelength, ai)
except ValueError:
message = "Convertion to unit %s not supported. Ring marks ignored"
_logger.warning(message, self.__radialUnit)
rings = []
else:
rings = []
self.__ringAngles = rings示例2: TestMultiGeometry
# 需要导入模块: from pyFAI.azimuthalIntegrator import AzimuthalIntegrator [as 别名]
# 或者: from pyFAI.azimuthalIntegrator.AzimuthalIntegrator import integrate2d [as 别名]
class TestMultiGeometry(unittest.TestCase):
def setUp(self):
unittest.TestCase.setUp(self)
self.data = fabio.open(UtilsTest.getimage("1788/moke.tif")).data
self.lst_data = [self.data[:250, :300], self.data[250:, :300], self.data[:250, 300:], self.data[250:, 300:]]
self.det = Detector(1e-4, 1e-4)
self.det.max_shape = (500, 600)
self.sub_det = Detector(1e-4, 1e-4)
self.sub_det.max_shape = (250, 300)
self.ai = AzimuthalIntegrator(0.1, 0.03, 0.03, detector=self.det)
self.range = (0, 23)
self.ais = [AzimuthalIntegrator(0.1, 0.030, 0.03, detector=self.sub_det),
AzimuthalIntegrator(0.1, 0.005, 0.03, detector=self.sub_det),
AzimuthalIntegrator(0.1, 0.030, 0.00, detector=self.sub_det),
AzimuthalIntegrator(0.1, 0.005, 0.00, detector=self.sub_det),
]
self.mg = MultiGeometry(self.ais, radial_range=self.range, unit="2th_deg")
self.N = 390
def tearDown(self):
unittest.TestCase.tearDown(self)
self.data = None
self.lst_data = None
self.det = None
self.sub_det = None
self.ai = None
self.ais = None
self.mg = None
def test_integrate1d(self):
tth_ref, I_ref = self.ai.integrate1d(self.data, radial_range=self.range, npt=self.N, unit="2th_deg", method="splitpixel")
obt = self.mg.integrate1d(self.lst_data, self.N)
tth_obt, I_obt = obt
self.assertEqual(abs(tth_ref - tth_obt).max(), 0, "Bin position is the same")
# intensity need to be scaled by solid angle 1e-4*1e-4/0.1**2 = 1e-6
delta = (abs(I_obt * 1e6 - I_ref).max())
self.assertLessEqual(delta, 5e-5, "Intensity is the same delta=%s" % delta)
def test_integrate2d(self):
ref = self.ai.integrate2d(self.data, self.N, 360, radial_range=self.range, azimuth_range=(-180, 180), unit="2th_deg", method="splitpixel", all=True)
obt = self.mg.integrate2d(self.lst_data, self.N, 360, all=True)
self.assertEqual(abs(ref["radial"] - obt["radial"]).max(), 0, "Bin position is the same")
self.assertEqual(abs(ref["azimuthal"] - obt["azimuthal"]).max(), 0, "Bin position is the same")
# intensity need to be scaled by solid angle 1e-4*1e-4/0.1**2 = 1e-6
delta = abs(obt["I"] * 1e6 - ref["I"])[obt["count"] >= 1] # restict on valid pixel
delta_cnt = abs(obt["count"] - ref["count"])
delta_sum = abs(obt["sum"] * 1e6 - ref["sum"])
if delta.max() > 1:
logger.warning("TestMultiGeometry.test_integrate2d gave intensity difference of %s" % delta.max())
if logger.level <= logging.DEBUG:
from matplotlib import pyplot as plt
f = plt.figure()
a1 = f.add_subplot(2, 2, 1)
a1.imshow(ref["sum"])
a2 = f.add_subplot(2, 2, 2)
a2.imshow(obt["sum"])
a3 = f.add_subplot(2, 2, 3)
a3.imshow(delta_sum)
a4 = f.add_subplot(2, 2, 4)
a4.plot(delta_sum.sum(axis=0))
f.show()
raw_input()
self.assertLess(delta_cnt.max(), 0.001, "pixel count is the same delta=%s" % delta_cnt.max())
self.assertLess(delta_sum.max(), 0.03, "pixel sum is the same delta=%s" % delta_sum.max())
self.assertLess(delta.max(), 0.004, "pixel intensity is the same (for populated pixels) delta=%s" % delta.max())示例3: CalibrationModel
# 需要导入模块: from pyFAI.azimuthalIntegrator import AzimuthalIntegrator [as 别名]
# 或者: from pyFAI.azimuthalIntegrator.AzimuthalIntegrator import integrate2d [as 别名]
#.........这里部分代码省略.........
else:
try:
self.tth, self.int = self.spectrum_geometry.integrate1d(self.img_model.img_data, num_points,
method=method,
unit=unit,
mask=mask,
polarization_factor=polarization_factor,
filename=filename)
except NameError:
self.tth, self.int = self.spectrum_geometry.integrate1d(self.img_model.img_data, num_points,
method='csr',
unit=unit,
mask=mask,
polarization_factor=polarization_factor,
filename=filename)
logger.info('1d integration of {0}: {1}s.'.format(os.path.basename(self.img_model.filename), time.time() - t1))
ind = np.where((self.int > 0) & (~np.isnan(self.int)))
self.tth = self.tth[ind]
self.int = self.int[ind]
return self.tth, self.int
def integrate_2d(self, mask=None, polarization_factor=None, unit='2th_deg', method='csr', dimensions=(2048, 2048)):
if polarization_factor is None:
polarization_factor = self.polarization_factor
if self.cake_geometry._polarization is not None:
if self.img_model.img_data.shape != self.cake_geometry._polarization.shape:
# resetting the integrator if the polarization correction matrix has not the same shape as the image
self.cake_geometry.reset()
t1 = time.time()
res = self.cake_geometry.integrate2d(self.img_model._img_data, dimensions[0], dimensions[1], method=method,
mask=mask,
unit=unit, polarization_factor=polarization_factor)
logger.info('2d integration of {0}: {1}s.'.format(os.path.basename(self.img_model.filename), time.time() - t1))
self.cake_img = res[0]
self.cake_tth = res[1]
self.cake_azi = res[2]
return self.cake_img
def create_point_array(self, points, points_ind):
res = []
for i, point_list in enumerate(points):
if point_list.shape == (2,):
res.append([point_list[0], point_list[1], points_ind[i]])
else:
for point in point_list:
res.append([point[0], point[1], points_ind[i]])
return np.array(res)
def get_point_array(self):
return self.create_point_array(self.points, self.points_index)
def get_calibration_parameter(self):
pyFAI_parameter = self.cake_geometry.getPyFAI()
pyFAI_parameter['polarization_factor'] = self.polarization_factor
try:
fit2d_parameter = self.cake_geometry.getFit2D()
fit2d_parameter['polarization_factor'] = self.polarization_factor
except TypeError:
fit2d_parameter = None
try:
pyFAI_parameter['wavelength'] = self.spectrum_geometry.wavelength
fit2d_parameter['wavelength'] = self.spectrum_geometry.wavelength示例4: CalibrationData
# 需要导入模块: from pyFAI.azimuthalIntegrator import AzimuthalIntegrator [as 别名]
# 或者: from pyFAI.azimuthalIntegrator.AzimuthalIntegrator import integrate2d [as 别名]
#.........这里部分代码省略.........
else:
try:
self.tth, self.int = self.spectrum_geometry.integrate1d(self.img_data.img_data, num_points,
method=method,
unit=unit,
mask=mask,
polarization_factor=polarization_factor,
filename=filename)
except NameError:
self.tth, self.int = self.spectrum_geometry.integrate1d(self.img_data.img_data, num_points,
method='lut',
unit=unit,
mask=mask,
polarization_factor=polarization_factor,
filename=filename)
logger.info('1d integration of {}: {}s.'.format(os.path.basename(self.img_data.filename), time.time() - t1))
ind = np.where((self.int > 0) & (~np.isnan(self.int)))
self.tth = self.tth[ind]
self.int = self.int[ind]
return self.tth, self.int
def integrate_2d(self, mask=None, polarization_factor=None, unit='2th_deg', method='csr', dimensions=(2048, 2048)):
if polarization_factor is None:
polarization_factor = self.polarization_factor
if self.cake_geometry._polarization is not None:
if self.img_data.img_data.shape != self.cake_geometry._polarization.shape:
# resetting the integrator if the polarization correction matrix has not the same shape as the image
self.cake_geometry.reset()
t1 = time.time()
res = self.cake_geometry.integrate2d(self.img_data._img_data, dimensions[0], dimensions[1], method=method,
mask=mask,
unit=unit, polarization_factor=polarization_factor)
logger.info('2d integration of {}: {}s.'.format(os.path.basename(self.img_data.filename), time.time() - t1))
self.cake_img = res[0]
self.cake_tth = res[1]
self.cake_azi = res[2]
return self.cake_img
def create_point_array(self, points, points_ind):
res = []
for i, point_list in enumerate(points):
if point_list.shape == (2,):
res.append([point_list[0], point_list[1], points_ind[i]])
else:
for point in point_list:
res.append([point[0], point[1], points_ind[i]])
return np.array(res)
def get_point_array(self):
return self.create_point_array(self.points, self.points_index)
def get_calibration_parameter(self):
pyFAI_parameter = self.cake_geometry.getPyFAI()
pyFAI_parameter['polarization_factor'] = self.polarization_factor
try:
fit2d_parameter = self.cake_geometry.getFit2D()
fit2d_parameter['polarization_factor'] = self.polarization_factor
except TypeError:
fit2d_parameter = None
try:
pyFAI_parameter['wavelength'] = self.spectrum_geometry.wavelength
fit2d_parameter['wavelength'] = self.spectrum_geometry.wavelength示例5: run
# 需要导入模块: from pyFAI.azimuthalIntegrator import AzimuthalIntegrator [as 别名]
# 或者: from pyFAI.azimuthalIntegrator.AzimuthalIntegrator import integrate2d [as 别名]
def run(self):
ai = AzimuthalIntegrator(
dist=self.__distance,
poni1=self.__poni1,
poni2=self.__poni2,
rot1=self.__rotation1,
rot2=self.__rotation2,
rot3=self.__rotation3,
detector=self.__detector,
wavelength=self.__wavelength)
# FIXME Add error model
method1d = method_registry.Method(1, self.__method.split, self.__method.algo, self.__method.impl, None)
methods = method_registry.IntegrationMethod.select_method(method=method1d)
if len(methods) == 0:
method1d = method_registry.Method(1, method1d.split, "*", "*", None)
_logger.warning("Downgrade 1D integration method to %s", method1d)
else:
method1d = methods[0].method
method2d = method_registry.Method(2, self.__method.split, self.__method.algo, self.__method.impl, None)
methods = method_registry.IntegrationMethod.select_method(method=method2d)
if len(methods) == 0:
method2d = method_registry.Method(2, method2d.split, "*", "*", None)
_logger.warning("Downgrade 2D integration method to %s", method2d)
else:
method2d = methods[0].method
self.__result1d = ai.integrate1d(
method=method1d,
data=self.__image,
npt=self.__nPointsRadial,
unit=self.__radialUnit,
mask=self.__mask,
polarization_factor=self.__polarizationFactor)
self.__result2d = ai.integrate2d(
method=method2d,
data=self.__image,
npt_rad=self.__nPointsRadial,
npt_azim=self.__nPointsAzimuthal,
unit=self.__radialUnit,
mask=self.__mask,
polarization_factor=self.__polarizationFactor)
# Create an image masked where data exists
self.__resultMask2d = None
if self.__mask is not None:
if self.__mask.shape == self.__image.shape:
maskData = numpy.ones(shape=self.__image.shape, dtype=numpy.float32)
maskData[self.__mask == 0] = float("NaN")
if self.__displayMask:
self.__resultMask2d = ai.integrate2d(
method=method2d,
data=maskData,
npt_rad=self.__nPointsRadial,
npt_azim=self.__nPointsAzimuthal,
unit=self.__radialUnit,
polarization_factor=self.__polarizationFactor)
else:
_logger.warning("Inconsistency between image and mask sizes. %s != %s", self.__image.shape, self.__mask.shape)
try:
self.__directDist = ai.getFit2D()["directDist"]
except Exception:
# The geometry could not fit this param
_logger.debug("Backtrace", exc_info=True)
self.__directDist = None
if self.__calibrant:
rings = self.__calibrant.get_2th()
try:
rings = unitutils.from2ThRad(rings, self.__radialUnit, self.__wavelength, self.__directDist)
except ValueError:
message = "Convertion to unit %s not supported. Ring marks ignored"
_logger.warning(message, self.__radialUnit)
rings = []
# Filter the rings which are not part of the result
rings = filter(lambda x: self.__result1d.radial[0] <= x <= self.__result1d.radial[-1], rings)
rings = list(rings)
else:
rings = []
self.__ringAngles = rings
self.__ai = ai示例6: CalibrateDialog
# 需要导入模块: from pyFAI.azimuthalIntegrator import AzimuthalIntegrator [as 别名]
# 或者: from pyFAI.azimuthalIntegrator.AzimuthalIntegrator import integrate2d [as 别名]
#.........这里部分代码省略.........
self.pattern_geometry.refine2()
fix = []
else:
fix = ['wavelength']
if not self.parameters['distance'].vary:
fix.append('dist')
self.pattern_geometry.refine2_wavelength(fix=fix)
self.read_parameters()
self.is_calibrated = True
self.create_cake_geometry()
self.pattern_geometry.reset()
def create_cake_geometry(self):
self.cake_geometry = AzimuthalIntegrator()
pyFAI_parameter = self.pattern_geometry.getPyFAI()
pyFAI_parameter['wavelength'] = self.pattern_geometry.wavelength
self.cake_geometry.setPyFAI(dist=pyFAI_parameter['dist'],
poni1=pyFAI_parameter['poni1'],
poni2=pyFAI_parameter['poni2'],
rot1=pyFAI_parameter['rot1'],
rot2=pyFAI_parameter['rot2'],
rot3=pyFAI_parameter['rot3'],
pixel1=pyFAI_parameter['pixel1'],
pixel2=pyFAI_parameter['pixel2'])
self.cake_geometry.wavelength = pyFAI_parameter['wavelength']
def plot_cake(self):
if 'Cake Plot' in plotviews:
plotview = plotviews['Cake Plot']
else:
plotview = NXPlotView('Cake Plot')
if not self.is_calibrated:
raise NeXusError('No refinement performed')
res = self.cake_geometry.integrate2d(self.counts,
1024, 1024,
method='csr',
unit='2th_deg',
correctSolidAngle=True)
self.cake_data = NXdata(res[0], (NXfield(res[2], name='azimumthal_angle'),
NXfield(res[1], name='polar_angle')))
self.cake_data['title'] = self.entry['instrument/calibration/title']
plotview.plot(self.cake_data, log=True)
wavelength = self.parameters['wavelength'].value
polar_angles = [2 * np.degrees(np.arcsin(wavelength/(2*d)))
for d in self.calibrant.dSpacing]
plotview.vlines([polar_angle for polar_angle in polar_angles
if polar_angle < plotview.xaxis.max],
linestyle=':', color='r')
def read_parameters(self):
pyFAI = self.pattern_geometry.getPyFAI()
fit2d = self.pattern_geometry.getFit2D()
self.parameters['wavelength'].value = self.pattern_geometry.wavelength * 1e10
self.parameters['distance'].value = pyFAI['dist'] * 1e3
self.parameters['yaw'].value = np.degrees(pyFAI['rot1'])
self.parameters['pitch'].value = np.degrees(pyFAI['rot2'])
self.parameters['roll'].value = np.degrees(pyFAI['rot3'])
self.parameters['xc'].value = fit2d['centerX']
self.parameters['yc'].value = fit2d['centerY']
def restore_parameters(self):
self.parameters.restore_parameters()
def save_parameters(self):
if not self.is_calibrated:
raise NeXusError('No refinement performed')