def find_orientations(cfg, hkls=None, clean=False, profile=False):
"""
Takes a config dict as input, generally a yml document
NOTE: single cfg instance, not iterator!
"""
# ...make this an attribute in cfg?
analysis_id = '%s_%s' %(
cfg.analysis_name.strip().replace(' ', '-'),
cfg.material.active.strip().replace(' ', '-'),
)
# grab planeData object
matl = cPickle.load(open('materials.cpl', 'r'))
md = dict(zip([matl[i].name for i in range(len(matl))], matl))
pd = md[cfg.material.active].planeData
# make image_series
image_series = cfg.image_series.omegaseries
# need instrument cfg later on down...
instr_cfg = get_instrument_parameters(cfg)
detector_params = np.hstack([
instr_cfg['detector']['transform']['tilt_angles'],
instr_cfg['detector']['transform']['t_vec_d'],
instr_cfg['oscillation_stage']['chi'],
instr_cfg['oscillation_stage']['t_vec_s'],
])
rdim = cfg.instrument.detector.pixels.size[0]*cfg.instrument.detector.pixels.rows
cdim = cfg.instrument.detector.pixels.size[1]*cfg.instrument.detector.pixels.columns
panel_dims = ((-0.5*cdim, -0.5*rdim),
( 0.5*cdim, 0.5*rdim),
)
# UGH! hard-coded distortion...
if instr_cfg['detector']['distortion']['function_name'] == 'GE_41RT':
distortion = (dFuncs.GE_41RT,
instr_cfg['detector']['distortion']['parameters'],
)
else:
distortion = None
min_compl = cfg.find_orientations.clustering.completeness
# start logger
logger.info("beginning analysis '%s'", cfg.analysis_name)
# load the eta_ome orientation maps
eta_ome = load_eta_ome_maps(cfg, pd, image_series, hkls=hkls, clean=clean)
ome_range = (
np.min(eta_ome.omeEdges),
np.max(eta_ome.omeEdges)
)
try:
# are we searching the full grid of orientation space?
qgrid_f = cfg.find_orientations.use_quaternion_grid
quats = np.load(qgrid_f)
logger.info("Using %s for full quaternion search", qgrid_f)
hkl_ids = None
except (IOError, ValueError, AttributeError):
# or doing a seeded search?
logger.info("Defaulting to seeded search")
hkl_seeds = cfg.find_orientations.seed_search.hkl_seeds
hkl_ids = [
eta_ome.planeData.hklDataList[i]['hklID'] for i in hkl_seeds
]
hklseedstr = ', '.join(
[str(i) for i in eta_ome.planeData.hkls.T[hkl_seeds]]
)
logger.info(
"Seeding search using hkls from %s: %s",
cfg.find_orientations.orientation_maps.file,
hklseedstr
)
quats = generate_orientation_fibers(
eta_ome,
detector_params[6],
cfg.find_orientations.threshold,
cfg.find_orientations.seed_search.hkl_seeds,
cfg.find_orientations.seed_search.fiber_ndiv,
ncpus=cfg.multiprocessing,
)
if save_as_ascii:
np.savetxt(
os.path.join(cfg.working_dir, 'trial_orientations.dat'),
quats.T,
fmt="%.18e",
delimiter="\t"
)
pass
pass # close conditional on grid search
# generate the completion maps
logger.info("Running paintgrid on %d trial orientations", quats.shape[1])
if profile:
logger.info("Profiling mode active, forcing ncpus to 1")
ncpus = 1
else:
ncpus = cfg.multiprocessing
logger.info(
"%d of %d available processors requested", ncpus, mp.cpu_count()
)
compl = idx.paintGrid(
quats,
eta_ome,
etaRange=np.radians(cfg.find_orientations.eta.range),
omeTol=np.radians(cfg.find_orientations.omega.tolerance),
etaTol=np.radians(cfg.find_orientations.eta.tolerance),
omePeriod=np.radians(cfg.find_orientations.omega.period),
threshold=cfg.find_orientations.threshold,
doMultiProc=ncpus > 1,
nCPUs=ncpus
)
if save_as_ascii:
np.savetxt(os.path.join(cfg.working_dir, 'completeness.dat'), compl)
else:
np.save(
os.path.join(
cfg.working_dir,
'scored_orientations_%s.npy' %analysis_id
),
np.vstack([quats, compl])
)
##########################################################
## Simulate N random grains to get neighborhood size ##
##########################################################
if hkl_ids is not None:
ngrains = 100
rand_q = mutil.unitVector(np.random.randn(4, ngrains))
rand_e = np.tile(2.*np.arccos(rand_q[0, :]), (3, 1)) \
* mutil.unitVector(rand_q[1:, :])
refl_per_grain = np.zeros(ngrains)
num_seed_refls = np.zeros(ngrains)
print('fo: hklids = ', hkl_ids)
for i in range(ngrains):
grain_params = np.hstack([rand_e[:, i],
xf.zeroVec.flatten(),
xf.vInv_ref.flatten()
])
sim_results = simulateGVecs(pd,
detector_params,
grain_params,
ome_range=(ome_range,),
ome_period=(ome_range[0], ome_range[0]+2*np.pi),
eta_range=np.radians(cfg.find_orientations.eta.range),
panel_dims=panel_dims,
pixel_pitch=cfg.instrument.detector.pixels.size,
distortion=distortion,
)
refl_per_grain[i] = len(sim_results[0])
# lines below fix bug when sim_results[0] is empty
if refl_per_grain[i] > 0:
num_seed_refls[i] = np.sum([sum(sim_results[0] == hkl_id) for hkl_id in hkl_ids])
else:
num_seed_refls[i] = 0
#min_samples = 2
min_samples = max(
int(np.floor(0.5*min_compl*min(num_seed_refls))),
2
)
mean_rpg = int(np.round(np.average(refl_per_grain)))
else:
min_samples = 1
mean_rpg = 1
logger.info("mean number of reflections per grain is %d", mean_rpg)
logger.info("neighborhood size estimate is %d points", min_samples)
# cluster analysis to identify orientation blobs, the final output:
qbar, cl = run_cluster(compl, quats, pd.getQSym(), cfg, min_samples=min_samples)
analysis_id = '%s_%s' %(
cfg.analysis_name.strip().replace(' ', '-'),
cfg.material.active.strip().replace(' ', '-'),
)
np.savetxt(
os.path.join(
cfg.working_dir,
'accepted_orientations_%s.dat' %analysis_id
),
qbar.T,
fmt="%.18e",
delimiter="\t")
return
def find_orientations(cfg, hkls=None, clean=False, profile=False):
"""
Takes a config dict as input, generally a yml document
NOTE: single cfg instance, not iterator!
"""
# ...make this an attribute in cfg?
analysis_id = '%s_%s' % (
cfg.analysis_name.strip().replace(' ', '-'),
cfg.material.active.strip().replace(' ', '-'),
)
# grab planeData object
matl = cPickle.load(open('materials.cpl', 'r'))
md = dict(zip([matl[i].name for i in range(len(matl))], matl))
pd = md[cfg.material.active].planeData
# make image_series
image_series = cfg.image_series.omegaseries
# need instrument cfg later on down...
instr_cfg = get_instrument_parameters(cfg)
detector_params = np.hstack([
instr_cfg['detector']['transform']['tilt_angles'],
instr_cfg['detector']['transform']['t_vec_d'],
instr_cfg['oscillation_stage']['chi'],
instr_cfg['oscillation_stage']['t_vec_s'],
])
rdim = cfg.instrument.detector.pixels.size[
0] * cfg.instrument.detector.pixels.rows
cdim = cfg.instrument.detector.pixels.size[
1] * cfg.instrument.detector.pixels.columns
panel_dims = (
(-0.5 * cdim, -0.5 * rdim),
(0.5 * cdim, 0.5 * rdim),
)
# UGH! hard-coded distortion...
if instr_cfg['detector']['distortion']['function_name'] == 'GE_41RT':
distortion = (
dFuncs.GE_41RT,
instr_cfg['detector']['distortion']['parameters'],
)
else:
distortion = None
min_compl = cfg.find_orientations.clustering.completeness
# start logger
logger.info("beginning analysis '%s'", cfg.analysis_name)
# load the eta_ome orientation maps
eta_ome = load_eta_ome_maps(cfg, pd, image_series, hkls=hkls, clean=clean)
ome_range = (np.min(eta_ome.omeEdges), np.max(eta_ome.omeEdges))
try:
# are we searching the full grid of orientation space?
qgrid_f = cfg.find_orientations.use_quaternion_grid
quats = np.load(qgrid_f)
logger.info("Using %s for full quaternion search", qgrid_f)
hkl_ids = None
except (IOError, ValueError, AttributeError):
# or doing a seeded search?
logger.info("Defaulting to seeded search")
hkl_seeds = cfg.find_orientations.seed_search.hkl_seeds
hkl_ids = [
eta_ome.planeData.hklDataList[i]['hklID'] for i in hkl_seeds
]
hklseedstr = ', '.join(
[str(i) for i in eta_ome.planeData.hkls.T[hkl_seeds]])
logger.info("Seeding search using hkls from %s: %s",
cfg.find_orientations.orientation_maps.file, hklseedstr)
quats = generate_orientation_fibers(
eta_ome,
detector_params[6],
cfg.find_orientations.threshold,
cfg.find_orientations.seed_search.hkl_seeds,
cfg.find_orientations.seed_search.fiber_ndiv,
ncpus=cfg.multiprocessing,
)
if save_as_ascii:
np.savetxt(os.path.join(cfg.working_dir, 'trial_orientations.dat'),
quats.T,
fmt="%.18e",
delimiter="\t")
pass
pass # close conditional on grid search
# generate the completion maps
logger.info("Running paintgrid on %d trial orientations", quats.shape[1])
if profile:
logger.info("Profiling mode active, forcing ncpus to 1")
ncpus = 1
else:
ncpus = cfg.multiprocessing
logger.info("%d of %d available processors requested", ncpus,
mp.cpu_count())
compl = idx.paintGrid(
quats,
eta_ome,
etaRange=np.radians(cfg.find_orientations.eta.range),
omeTol=np.radians(cfg.find_orientations.omega.tolerance),
etaTol=np.radians(cfg.find_orientations.eta.tolerance),
omePeriod=np.radians(cfg.find_orientations.omega.period),
threshold=cfg.find_orientations.threshold,
doMultiProc=ncpus > 1,
nCPUs=ncpus)
if save_as_ascii:
np.savetxt(os.path.join(cfg.working_dir, 'completeness.dat'), compl)
else:
np.save(
os.path.join(cfg.working_dir,
'scored_orientations_%s.npy' % analysis_id),
np.vstack([quats, compl]))
##########################################################
## Simulate N random grains to get neighborhood size ##
##########################################################
if hkl_ids is not None:
ngrains = 100
rand_q = mutil.unitVector(np.random.randn(4, ngrains))
rand_e = np.tile(2.*np.arccos(rand_q[0, :]), (3, 1)) \
* mutil.unitVector(rand_q[1:, :])
refl_per_grain = np.zeros(ngrains)
num_seed_refls = np.zeros(ngrains)
print('fo: hklids = ', hkl_ids)
for i in range(ngrains):
grain_params = np.hstack(
[rand_e[:, i],
xf.zeroVec.flatten(),
xf.vInv_ref.flatten()])
sim_results = simulateGVecs(
pd,
detector_params,
grain_params,
ome_range=(ome_range, ),
ome_period=(ome_range[0], ome_range[0] + 2 * np.pi),
eta_range=np.radians(cfg.find_orientations.eta.range),
panel_dims=panel_dims,
pixel_pitch=cfg.instrument.detector.pixels.size,
distortion=distortion,
)
refl_per_grain[i] = len(sim_results[0])
# lines below fix bug when sim_results[0] is empty
if refl_per_grain[i] > 0:
num_seed_refls[i] = np.sum(
[sum(sim_results[0] == hkl_id) for hkl_id in hkl_ids])
else:
num_seed_refls[i] = 0
#min_samples = 2
min_samples = max(int(np.floor(0.5 * min_compl * min(num_seed_refls))),
2)
mean_rpg = int(np.round(np.average(refl_per_grain)))
else:
min_samples = 1
mean_rpg = 1
logger.info("mean number of reflections per grain is %d", mean_rpg)
logger.info("neighborhood size estimate is %d points", min_samples)
# cluster analysis to identify orientation blobs, the final output:
qbar, cl = run_cluster(compl,
quats,
pd.getQSym(),
cfg,
min_samples=min_samples)
analysis_id = '%s_%s' % (
cfg.analysis_name.strip().replace(' ', '-'),
cfg.material.active.strip().replace(' ', '-'),
)
np.savetxt(os.path.join(cfg.working_dir,
'accepted_orientations_%s.dat' % analysis_id),
qbar.T,
fmt="%.18e",
delimiter="\t")
return
def check_indexing_plots(cfg_filename, plot_trials=False, plot_from_grains=False):
cfg = config.open(cfg_filename)[0] # use first block, like indexing
working_dir = cfg.working_dir
analysis_dir = os.path.join(working_dir, cfg.analysis_name)
#instrument parameters
icfg = get_instrument_parameters(cfg)
chi = icfg['oscillation_stage']['chi']
# load maps that were used
oem = cPickle.load(
open(cfg.find_orientations.orientation_maps.file, 'r')
)
nmaps = len(oem.dataStore)
omeEdges = np.degrees(oem.omeEdges); nome = len(omeEdges) - 1
etaEdges = np.degrees(oem.etaEdges); neta = len(etaEdges) - 1
delta_ome = abs(omeEdges[1]-omeEdges[0])
full_ome_range = xf.angularDifference(omeEdges[0], omeEdges[-1]) == 0
full_eta_range = xf.angularDifference(etaEdges[0], etaEdges[-1]) == 0
# grab plane data and figure out IDs of map HKLS
pd = oem.planeData
gvids = [pd.hklDataList[i]['hklID'] for i in np.where(pd.exclusions == False)[0].tolist()]
# load orientations
quats = np.atleast_2d(np.loadtxt(os.path.join(working_dir, 'accepted_orientations.dat')))
if plot_trials:
scored_trials = np.load(os.path.join(working_dir, 'scored_orientations.dat'))
quats = scored_orientations[:4, scored_orientations[-1, :] >= cfg.find_orientations.clustering.completeness]
pass
expMaps = np.tile(2. * np.arccos(quats[:, 0]), (3, 1))*unitVector(quats[:, 1:].T)
##########################################
# SPECIAL CASE FOR FIT GRAINS #
##########################################
if plot_from_grains:
distortion = (GE_41RT, icfg['detector']['distortion']['parameters'])
#
grain_table = np.atleast_2d(np.loadtxt(os.path.join(analysis_dir, 'grains.out')))
ngrains = len(grain_table)
#
expMaps = grain_table[:, 3:6]
tVec_c = grain_table[:, 6:9]
vInv = grain_table[:, 6:12]
#
rMat_d = xf.makeDetectorRotMat(icfg['detector']['transform']['tilt_angles'])
tVec_d = np.vstack(icfg['detector']['transform']['t_vec_d'])
#
chi = icfg['oscillation_stage']['chi']
tVec_s = np.vstack(icfg['oscillation_stage']['t_vec_s'])
#
oes = np.zeros(oem.dataStore.shape)
for i_grn in range(ngrains):
spots_table = np.loadtxt(os.path.join(analysis_dir, 'spots_%05d.out' %i_grn))
idx_m = spots_table[:, 0] >= 0
for i_map in range(nmaps):
idx_g = spots_table[:, 1] == gvids[i_map]
idx = np.logical_and(idx_m, idx_g)
nrefl = sum(idx)
omes_fit = xf.mapAngle(spots_table[idx, 9], np.radians(cfg.find_orientations.omega.period), units='radians')
xy_det = spots_table[idx, -3:]
xy_det[:, 2] = np.zeros(nrefl)
rMat_s_array = xfcapi.makeOscillRotMatArray(chi, omes_fit)
# form in-plane vectors for detector points list in DETECTOR FRAME
P2_d = xy_det.T
# in LAB FRAME
P2_l = np.dot(rMat_d, P2_d) + tVec_d # point on detector
P0_l = np.hstack(
[tVec_s + np.dot(rMat_s_array[j], tVec_c[i_grn, :].reshape(3, 1)) for j in range(nrefl)]
) # origin of CRYSTAL FRAME
# diffraction unit vector components in LAB FRAME
dHat_l = unitVector(P2_l - P0_l)
P2_l = np.dot(rMat_d, xy_det.T) + tVec_d
# angles for reference frame
dHat_ref_l = unitVector(P2_l)
# append etas and omes
etas_fit = np.arctan2(dHat_ref_l[1, :], dHat_ref_l[0, :]).flatten()
# find indices, then truncate or wrap
i_ome = cellIndices(oem.omeEdges, omes_fit)
if full_ome_range:
i_ome[i_ome < 0] = np.mod(i_ome, nome) + 1
i_ome[i_ome >= nome] = np.mod(i_ome, nome)
else:
incl = np.logical_or(i_ome >= 0, i_ome < nome)
i_ome = i_ome[incl]
j_eta = cellIndices(oem.etaEdges, etas_fit)
if full_eta_range:
j_eta[j_eta < 0] = np.mod(j_eta, neta) + 1
j_eta[j_eta >= neta] = np.mod(j_eta, neta)
else:
incl = np.logical_or(j_eta >= 0, j_eta < neta)
j_eta = j_eta[incl]
#if np.max(i_ome) >= nome or np.min(i_ome) < 0 or np.max(j_eta) >= neta or np.min(j_eta) < 0:
# import pdb; pdb.set_trace()
# add to map
oes[i_map][i_ome, j_eta] = 1
pass
pass
# simulate quaternion points
if not plot_from_grains:
oes = simulateOmeEtaMaps(omeEdges, etaEdges, pd,
expMaps,
chi=chi,
etaTol=0.01, omeTol=0.01,
etaRanges=None, omeRanges=None,
bVec=xf.bVec_ref, eVec=xf.eta_ref, vInv=xf.vInv_ref)
# tick labling
omes = np.degrees(oem.omeEdges)
etas = np.degrees(oem.etaEdges)
num_ticks = 7
xmin = np.amin(etas); xmax = np.amax(etas)
dx = (xmax - xmin) / (num_ticks - 1.); dx1 = (len(etas) - 1) / (num_ticks - 1.)
xtlab = ["%.0f" % (xmin + i*dx) for i in range(num_ticks)]
xtloc = np.array([i*dx1 for i in range(num_ticks)]) - 0.5
ymin = np.amin(omes); ymax = np.amax(omes)
dy = (ymax - ymin) / (num_ticks - 1.); dy1 = (len(omes) - 1) / (num_ticks - 1.)
ytlab = ["%.0f" % (ymin + i*dy) for i in range(num_ticks)]
ytloc = np.array([i*dy1 for i in range(num_ticks)]) - 0.5
# Plot the three kernel density estimates
n_maps = len(oem.iHKLList)
fig_list =[plt.figure(num=i+1) for i in range(n_maps)]
ax_list = [fig_list[i].gca() for i in range(n_maps)]
for i_map in range(n_maps):
y, x = np.where(oes[i_map] > 0)
ax_list[i_map].hold(True)
ax_list[i_map].imshow(oem.dataStore[i_map] > 0.1, cmap=cm.bone)
ax_list[i_map].set_title(r'Map for $\{%d %d %d\}$' %tuple(pd.hkls[:, i_map]))
ax_list[i_map].set_xlabel(r'Azimuth channel, $\eta$; $\Delta\eta=%.3f$' %delta_ome)
ax_list[i_map].set_ylabel(r'Rotation channel, $\omega$; $\Delta\omega=%.3f$' %delta_ome)
ax_list[i_map].plot(x, y, 'c+')
ax_list[i_map].xaxis.set_ticks(xtloc)
ax_list[i_map].xaxis.set_ticklabels(xtlab)
ax_list[i_map].yaxis.set_ticks(ytloc)
ax_list[i_map].yaxis.set_ticklabels(ytlab)
ax_list[i_map].axis('tight')
plt.show()
return fig_list, oes
def check_indexing_plots(cfg_filename,
plot_trials=False,
plot_from_grains=False):
cfg = config.open(cfg_filename)[0] # use first block, like indexing
working_dir = cfg.working_dir
analysis_dir = os.path.join(working_dir, cfg.analysis_name)
#instrument parameters
icfg = get_instrument_parameters(cfg)
chi = icfg['oscillation_stage']['chi']
# load maps that were used
oem = cPickle.load(open(cfg.find_orientations.orientation_maps.file, 'r'))
nmaps = len(oem.dataStore)
omeEdges = np.degrees(oem.omeEdges)
nome = len(omeEdges) - 1
etaEdges = np.degrees(oem.etaEdges)
neta = len(etaEdges) - 1
delta_ome = abs(omeEdges[1] - omeEdges[0])
full_ome_range = xf.angularDifference(omeEdges[0], omeEdges[-1]) == 0
full_eta_range = xf.angularDifference(etaEdges[0], etaEdges[-1]) == 0
# grab plane data and figure out IDs of map HKLS
pd = oem.planeData
gvids = [
pd.hklDataList[i]['hklID']
for i in np.where(pd.exclusions == False)[0].tolist()
]
# load orientations
quats = np.atleast_2d(
np.loadtxt(os.path.join(working_dir, 'accepted_orientations.dat')))
if plot_trials:
scored_trials = np.load(
os.path.join(working_dir, 'scored_orientations.dat'))
quats = scored_orientations[:4, scored_orientations[
-1, :] >= cfg.find_orientations.clustering.completeness]
pass
expMaps = np.tile(2. * np.arccos(quats[:, 0]),
(3, 1)) * unitVector(quats[:, 1:].T)
##########################################
# SPECIAL CASE FOR FIT GRAINS #
##########################################
if plot_from_grains:
distortion = (GE_41RT, icfg['detector']['distortion']['parameters'])
#
grain_table = np.atleast_2d(
np.loadtxt(os.path.join(analysis_dir, 'grains.out')))
ngrains = len(grain_table)
#
expMaps = grain_table[:, 3:6]
tVec_c = grain_table[:, 6:9]
vInv = grain_table[:, 6:12]
#
rMat_d = xf.makeDetectorRotMat(
icfg['detector']['transform']['tilt_angles'])
tVec_d = np.vstack(icfg['detector']['transform']['t_vec_d'])
#
chi = icfg['oscillation_stage']['chi']
tVec_s = np.vstack(icfg['oscillation_stage']['t_vec_s'])
#
oes = np.zeros(oem.dataStore.shape)
for i_grn in range(ngrains):
spots_table = np.loadtxt(
os.path.join(analysis_dir, 'spots_%05d.out' % i_grn))
idx_m = spots_table[:, 0] >= 0
for i_map in range(nmaps):
idx_g = spots_table[:, 1] == gvids[i_map]
idx = np.logical_and(idx_m, idx_g)
nrefl = sum(idx)
omes_fit = xf.mapAngle(spots_table[idx, 9],
np.radians(
cfg.find_orientations.omega.period),
units='radians')
xy_det = spots_table[idx, -3:]
xy_det[:, 2] = np.zeros(nrefl)
rMat_s_array = xfcapi.makeOscillRotMatArray(chi, omes_fit)
# form in-plane vectors for detector points list in DETECTOR FRAME
P2_d = xy_det.T
# in LAB FRAME
P2_l = np.dot(rMat_d, P2_d) + tVec_d # point on detector
P0_l = np.hstack([
tVec_s +
np.dot(rMat_s_array[j], tVec_c[i_grn, :].reshape(3, 1))
for j in range(nrefl)
]) # origin of CRYSTAL FRAME
# diffraction unit vector components in LAB FRAME
dHat_l = unitVector(P2_l - P0_l)
P2_l = np.dot(rMat_d, xy_det.T) + tVec_d
# angles for reference frame
dHat_ref_l = unitVector(P2_l)
# append etas and omes
etas_fit = np.arctan2(dHat_ref_l[1, :],
dHat_ref_l[0, :]).flatten()
# find indices, then truncate or wrap
i_ome = cellIndices(oem.omeEdges, omes_fit)
if full_ome_range:
i_ome[i_ome < 0] = np.mod(i_ome, nome) + 1
i_ome[i_ome >= nome] = np.mod(i_ome, nome)
else:
incl = np.logical_or(i_ome >= 0, i_ome < nome)
i_ome = i_ome[incl]
j_eta = cellIndices(oem.etaEdges, etas_fit)
if full_eta_range:
j_eta[j_eta < 0] = np.mod(j_eta, neta) + 1
j_eta[j_eta >= neta] = np.mod(j_eta, neta)
else:
incl = np.logical_or(j_eta >= 0, j_eta < neta)
j_eta = j_eta[incl]
#if np.max(i_ome) >= nome or np.min(i_ome) < 0 or np.max(j_eta) >= neta or np.min(j_eta) < 0:
# import pdb; pdb.set_trace()
# add to map
oes[i_map][i_ome, j_eta] = 1
pass
pass
# simulate quaternion points
if not plot_from_grains:
oes = simulateOmeEtaMaps(omeEdges,
etaEdges,
pd,
expMaps,
chi=chi,
etaTol=0.01,
omeTol=0.01,
etaRanges=None,
omeRanges=None,
bVec=xf.bVec_ref,
eVec=xf.eta_ref,
vInv=xf.vInv_ref)
# tick labling
omes = np.degrees(oem.omeEdges)
etas = np.degrees(oem.etaEdges)
num_ticks = 7
xmin = np.amin(etas)
xmax = np.amax(etas)
dx = (xmax - xmin) / (num_ticks - 1.)
dx1 = (len(etas) - 1) / (num_ticks - 1.)
xtlab = ["%.0f" % (xmin + i * dx) for i in range(num_ticks)]
xtloc = np.array([i * dx1 for i in range(num_ticks)]) - 0.5
ymin = np.amin(omes)
ymax = np.amax(omes)
dy = (ymax - ymin) / (num_ticks - 1.)
dy1 = (len(omes) - 1) / (num_ticks - 1.)
ytlab = ["%.0f" % (ymin + i * dy) for i in range(num_ticks)]
ytloc = np.array([i * dy1 for i in range(num_ticks)]) - 0.5
# Plot the three kernel density estimates
n_maps = len(oem.iHKLList)
fig_list = [plt.figure(num=i + 1) for i in range(n_maps)]
ax_list = [fig_list[i].gca() for i in range(n_maps)]
for i_map in range(n_maps):
y, x = np.where(oes[i_map] > 0)
ax_list[i_map].hold(True)
ax_list[i_map].imshow(oem.dataStore[i_map] > 0.1, cmap=cm.bone)
ax_list[i_map].set_title(r'Map for $\{%d %d %d\}$' %
tuple(pd.hkls[:, i_map]))
ax_list[i_map].set_xlabel(
r'Azimuth channel, $\eta$; $\Delta\eta=%.3f$' % delta_ome)
ax_list[i_map].set_ylabel(
r'Rotation channel, $\omega$; $\Delta\omega=%.3f$' % delta_ome)
ax_list[i_map].plot(x, y, 'c+')
ax_list[i_map].xaxis.set_ticks(xtloc)
ax_list[i_map].xaxis.set_ticklabels(xtlab)
ax_list[i_map].yaxis.set_ticks(ytloc)
ax_list[i_map].yaxis.set_ticklabels(ytlab)
ax_list[i_map].axis('tight')
plt.show()
return fig_list, oes
def make_dark_frame(cfg_name, nframes_use=100, nbytes_header=8192, pixel_type=np.uint16, quiet=False, output_name=None):
"""
FOR BYTE STREAM IMAGES ONLY!
nbytes_header and pixel_bytes default for raw GE
"""
cfg = config.open(cfg_name)[0] # only first block...
raw_cfg = [g for g in yaml.load_all(open(cfg_name, 'r'))] # take first block... maybe iterate?
try:
output_name = cfg.image_series.dark
except IOError:
if raw_cfg[0]['image_series'].has_key('dark') and output_name is None:
output_name = raw_cfg[0]['image_series']['dark']
if not os.path.exists(output_name):
# create if necessary
open(output_name, 'w+').close()
n_empty = cfg.image_series.images.start
image_numbers = cfg.image_series.file.ids
if isinstance(image_numbers[0], str): # then globbing
filenames = glob.glob(cfg.image_series.file.stem %cfg.image_series.file.ids[0])
else:
filenames = [cfg.image_series.file.stem %i for i in cfg.image_series.file.ids]
n_images = len(filenames)
instr_cfg = get_instrument_parameters(cfg)
nrows = instr_cfg['detector']['pixels']['rows']
ncols = instr_cfg['detector']['pixels']['columns']
pixel_bytes = pixel_type().itemsize
nbytes_frame = pixel_bytes*nrows*ncols
filename = filenames[0]
file_bytes = os.stat(filename).st_size
n_frames = getNFramesFromBytes(file_bytes, nbytes_header, nbytes_frame)
n_frames -= n_empty
n_frames_total = n_frames*n_images
if nframes_use > n_frames_total:
if not quiet:
print "Requested %d frames, which is in image spec; defaulting to %d" %(nframes_use, n_frames_total)
nframes_use = n_frames_total
ii = 0
jj = min(nframes_use, n_frames)
n_frames_cum = 0
n_frames_rem = nframes_use
frames = np.empty((nframes_use, nrows, ncols), dtype=pixel_type)
for i_frame in range(len(image_numbers)):
filename = filenames[i_frame]
if not quiet:
print "Using %d frames from '%s'" %(min(n_frames, nframes_use, n_frames_rem), filename)
nfr = jj - ii
fid = open(filename, 'rb')
fid.seek(nbytes_header+n_empty*nbytes_frame, 0) # header plus junk frames
tmp = np.frombuffer(fid.read(nfr*nbytes_frame), dtype=pixel_type).reshape(nfr, nrows, ncols)
fid.close()
# index into frames array
frames[ii:jj] = tmp
# increment...
n_frames_rem -= nfr
if n_frames_rem <= 0:
break
else:
ii = jj
jj += min(n_frames_rem, n_frames)
if not quiet:
print "\tframes left: %d" %n_frames_rem
pass
dark = np.median(frames, axis=0)
if not quiet:
print "Output file: %s" %output_name
fid = open(cfg.image_series.dark, 'wb')
fid.seek(nbytes_header)
fid.write(dark.astype(pixel_type))
fid.close()
return dark.astype(np.uint16)
