def convert_polar_to_raw(line):
line_data = []
for key, panel in create_hedm_instrument().detectors.items():
cart = panel.angles_to_cart(np.radians(line))
raw = panel.cartToPixel(cart)
line_data.append((key, raw))
return line_data
def __init__(self):
self.type = ViewType.cartesian
self.instr = create_hedm_instrument()
self.images_dict = HexrdConfig().current_images_dict()
# Perform some checks before proceeding
self.check_keys_match()
self.check_angles_feasible()
self.pixel_size = HexrdConfig().cartesian_pixel_size
self.warp_dict = {}
self.detector_corners = {}
dist = HexrdConfig().cartesian_virtual_plane_distance
dplane_tvec = np.array([0., 0., -dist])
rotate_x = HexrdConfig().cartesian_plane_normal_rotate_x
rotate_y = HexrdConfig().cartesian_plane_normal_rotate_y
dplane_tilt = np.radians(np.array(([rotate_x, rotate_y, 0.])))
self.dplane = DisplayPlane(tvec=dplane_tvec, tilt=dplane_tilt)
self.make_dpanel()
# Check that the image size won't be too big...
self.check_size_feasible()
self.plot_dplane()
def auto_generate_polar_params(self):
# This will automatically generate and set values for the polar
# pixel values based upon the config.
# This function does not invoke a re-render.
manager = multiprocessing.Manager()
keys = ['max_tth_ps', 'max_eta_ps', 'min_tth', 'max_tth']
results = {key: manager.list() for key in keys}
f = partial(compute_polar_params, **results)
instr = create_hedm_instrument()
with multiprocessing.Pool() as pool:
pool.map(f, instr.detectors.values())
# Set these manually so no rerender signals are fired
params = {
'pixel_size_tth': 10 * np.degrees(max(results['max_tth_ps'])),
'pixel_size_eta': 2 * np.degrees(max(results['max_eta_ps'])),
'tth_min': np.degrees(min(results['min_tth'])),
'tth_max': np.degrees(max(results['max_tth']))
}
# Sometimes, this is too big. Bring it down if it is.
px_eta = params['pixel_size_eta']
params['pixel_size_eta'] = px_eta if px_eta < 90 else 5
HexrdConfig().config['image']['polar'].update(params)
# Update all of the materials with the new tth_max
HexrdConfig().reset_tth_max_all_materials()
# Get the GUI to update with the new values
self.update_gui_from_config()
def run_calibration(self):
picks = self.generate_pick_results()
materials = self.pick_materials
instr = create_hedm_instrument()
flags = HexrdConfig().get_statuses_instrument_format()
instr.calibration_flags = flags
instr_calibrator = run_calibration(picks, instr, materials)
self.write_instrument_to_hexrd_config(instr)
# Update the lattice parameters and overlays
overlays = [self.overlays[i] for i in self.all_overlay_picks]
for overlay, calibrator in zip(overlays, instr_calibrator.calibrators):
if calibrator.calibrator_type == 'powder':
if calibrator.params.size == 0:
continue
mat_name = overlay['material']
mat = materials[mat_name]
mat.latticeParameters = calibrator.params
make_new_pdata(mat)
HexrdConfig().flag_overlay_updates_for_material(mat_name)
if mat is HexrdConfig().active_material:
HexrdConfig().active_material_modified.emit()
elif calibrator.calibrator_type == 'laue':
overlay['options']['crystal_params'] = calibrator.params
# In case any overlays changed
HexrdConfig().overlay_config_changed.emit()
HexrdConfig().calibration_complete.emit()
def _run(self):
# First, have the user pick some options
if not PowderCalibrationDialog(self.material, self.parent).exec_():
# User canceled...
return
# The options they chose are saved here
options = HexrdConfig().config['calibration']['powder']
self.instr = create_hedm_instrument()
# Assume there is only one image in each image series for now...
img_dict = {k: x[0] for k, x in HexrdConfig().imageseries_dict.items()}
statuses = self.refinement_flags_without_overlays
self.cf = statuses
self.instr.calibration_flags = statuses
kwargs = {
'instr': self.instr,
'plane_data': self.material.planeData,
'img_dict': img_dict,
'flags': self.refinement_flags,
'eta_tol': options['eta_tol'],
'pktype': options['pk_type'],
}
self.pc = PowderCalibrator(**kwargs)
self.ic = InstrumentCalibrator(self.pc)
self.extract_powder_lines()
def get_instrument_defaults(self):
self.detector_defaults.clear()
not_default = (self.ui.current_config.isChecked()
or not self.ui.default_config.isChecked())
if self.config_file and not_default:
if os.path.splitext(self.config_file)[1] in YAML_EXTS:
with open(self.config_file, 'r') as f:
self.defaults = yaml.load(f, Loader=yaml.FullLoader)
else:
try:
with h5py.File(self.config_file, 'r') as f:
instr = create_hedm_instrument()
instr.unwrap_h5_to_dict(f, self.defaults)
except Exception as e:
msg = (
f'ERROR - Could not read file: \n {e} \n'
f'File must be HDF5 or YAML.')
QMessageBox.warning(None, 'HEXRD', msg)
return False
else:
fname = f'{self.instrument.lower()}_reference_config.yml'
text = resource_loader.load_resource(hexrd_resources, fname)
self.defaults = yaml.load(text, Loader=yaml.FullLoader)
self.detector_defaults['default_config'] = self.defaults
self.set_detector_options()
return True
def __init__(self):
self.type = ViewType.cartesian
self.instr = create_hedm_instrument()
self.images_dict = HexrdConfig().current_images_dict()
# Make sure each key in the image dict is in the panel_ids
if self.images_dict.keys() != self.instr._detectors.keys():
msg = ('Images do not match the panel ids!\n' +
'Images: ' + str(list(self.images_dict.keys())) + '\n' +
'PanelIds: ' + str(list(self.instr._detectors.keys())))
raise Exception(msg)
self.pixel_size = HexrdConfig().cartesian_pixel_size
self.warp_dict = {}
self.detector_corners = {}
dist = HexrdConfig().cartesian_virtual_plane_distance
dplane_tvec = np.array([0., 0., -dist])
rotate_x = HexrdConfig().cartesian_plane_normal_rotate_x
rotate_y = HexrdConfig().cartesian_plane_normal_rotate_y
dplane_tilt = np.radians(np.array(([rotate_x, rotate_y, 0.])))
self.dplane = DisplayPlane(tvec=dplane_tvec, tilt=dplane_tilt)
self.make_dpanel()
self.plot_dplane()
def create_indexing_config():
# Creates a hexrd.config class from the indexing configuration
# Make a copy to modify
indexing_config = copy.deepcopy(HexrdConfig().indexing_config)
available_materials = list(HexrdConfig().materials.keys())
selected_material = indexing_config.get('_selected_material')
if selected_material not in available_materials:
raise Exception(f'Selected material {selected_material} not available')
material = HexrdConfig().material(selected_material)
omaps = indexing_config['find_orientations']['orientation_maps']
omaps['active_hkls'] = list(range(len(material.planeData.getHKLs())))
# Set the active material on the config
tmp = indexing_config.setdefault('material', {})
tmp['active'] = material.name
# Create the root config from the indexing config dict
config = RootConfig(indexing_config)
# Create and set instrument config
iconfig = InstrumentConfig(config)
iconfig._hedm = create_hedm_instrument()
config.instrument = iconfig
# Create and set material config
mconfig = MaterialConfig(config)
mconfig.materials = HexrdConfig().materials
config.material = mconfig
# Set this so the config won't over-write our tThWidth
config.set('material:tth_width', np.degrees(material.planeData.tThWidth))
# Use unaggregated images if possible
ims_dict = HexrdConfig().unagg_images
if ims_dict is None:
# This probably means the image series was never aggregated.
# Try using the imageseries dict.
ims_dict = HexrdConfig().imageseries_dict
# Load omega data if it is missing
load_omegas_dict = {
k: ims for k, ims in ims_dict.items() if 'omega' not in ims.metadata
}
if load_omegas_dict:
ImageLoadManager().add_omega_metadata(load_omegas_dict)
# Convert image series into OmegaImageSeries
for key, ims in ims_dict.items():
if not isinstance(ims, OmegaImageSeries):
ims_dict[key] = OmegaImageSeries(ims)
config.image_series = ims_dict
return config
def __init__(self, img, parent=None):
self.parent = parent.image_tab_widget.image_canvases[0]
self.ax = self.parent.axes_images[0]
self.raw_axes = self.parent.raw_axes[0]
self.panels = create_hedm_instrument().detectors
self.img = img
self.shape = None
self.press = None
self.total_rotation = 0
def __init__(self):
self.type = ViewType.polar
self.instr = create_hedm_instrument()
self.images_dict = HexrdConfig().current_images_dict()
# Resolution settings
# As far as I can tell, self.pixel_size won't actually change
# anything for a polar plot, so just hard-code it.
self.pixel_size = 0.5
self.draw_polar()
def __init__(self, parent=None):
self.parent = parent.image_tab_widget.image_canvases[0]
self.ax = self.parent.axes_images[0]
self.raw_axes = self.parent.raw_axes[0]
self.panels = create_hedm_instrument().detectors
self.img = None
self.shape = None
self.press = None
self.total_rotation = 0
self.translating = True
self.shape_styles = []
self.parent.setFocusPolicy(Qt.ClickFocus)
def create_indexing_config():
# Creates a hexrd.config class from the indexing configuration
# Make a copy to modify
indexing_config = copy.deepcopy(HexrdConfig().indexing_config)
material = HexrdConfig().active_material
omaps = indexing_config['find_orientations']['orientation_maps']
omaps['active_hkls'] = active_hkl_indices(material.planeData)
# Set the active material on the config
tmp = indexing_config.setdefault('material', {})
tmp['active'] = HexrdConfig().active_material_name
# Create the root config from the indexing config dict
config = RootConfig(indexing_config)
# Create and set instrument config
iconfig = InstrumentConfig()
iconfig._hedm = create_hedm_instrument()
config.instrument = iconfig
# Create and set material config
mconfig = MaterialConfig(config)
mconfig.materials = HexrdConfig().materials
config.material = mconfig
# Use unaggregated images if possible
ims_dict = ImageLoadManager().unaggregated_images
if ims_dict is None:
# This probably means the image series was never aggregated.
# Try using the imageseries dict.
ims_dict = HexrdConfig().imageseries_dict
# Load omega data if it is missing
load_omegas_dict = {
k: ims
for k, ims in ims_dict.items() if 'omega' not in ims.metadata
}
if load_omegas_dict:
ImageLoadManager().add_omega_metadata(load_omegas_dict)
# Convert image series into OmegaImageSeries
for key, ims in ims_dict.items():
ims_dict[key] = OmegaImageSeries(ims)
config.image_series = ims_dict
return config
def validate(self):
visible_overlays = self.visible_overlays
if not visible_overlays:
raise Exception('No visible overlays')
if not all(self.has_widths(x) for x in visible_overlays):
raise Exception('All visible overlays must have widths')
flags = HexrdConfig().get_statuses_instrument_format().tolist()
# Make sure the length of our flags matches up with the instruments
instr = create_hedm_instrument()
if len(flags) != len(instr.calibration_flags):
msg = ('Length of internal flags does not match '
'instr.calibration_flags')
raise Exception(msg)
# Add overlay refinements
for overlay in visible_overlays:
flags += [x[1] for x in self.get_refinements(overlay)]
if np.count_nonzero(flags) == 0:
raise Exception('There are no refinable parameters')
def dump_results(self):
# This dumps out all results to files for testing
# It is mostly intended for debug purposes
import json
import pickle
class NumpyEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.ndarray):
return obj.tolist()
return json.JSONEncoder.default(self, obj)
for name, mat in self.pick_materials.items():
# Dump out the material
mat_file_name = f'{name}.pkl'
print(f'Writing out material to {mat_file_name}')
with open(mat_file_name, 'wb') as wf:
pickle.dump(mat, wf)
pick_results = self.generate_pick_results()
out_file = 'calibration_picks.json'
print(f'Writing out picks to {out_file}')
with open(out_file, 'w') as wf:
json.dump(pick_results, wf, cls=NumpyEncoder)
# Dump out the instrument as well
instr = create_hedm_instrument()
print(f'Writing out instrument to instrument.pkl')
with open('instrument.pkl', 'wb') as wf:
pickle.dump(instr, wf)
# Dump out refinement flags
flags = HexrdConfig().get_statuses_instrument_format()
print(f'Writing out refinement flags to refinement_flags.json')
with open('refinement_flags.json', 'w') as wf:
json.dump(flags, wf, cls=NumpyEncoder)
def __init__(self):
self.type = ViewType.raw
self.instr = create_hedm_instrument()
def convert_raw_to_polar(det, line):
panel = create_hedm_instrument().detectors[det]
cart = panel.pixelToCart(line)
tth, gvec = panel.cart_to_angles(cart)
return [np.degrees(tth)]