def menu_item_execute(self, window: API.DocumentWindow) -> None:
data_item = window.target_data_item
if not data_item:
return
vector_a = data_item.add_line_region(0.5, 0.5, 0.5, 0.75)
vector_a.label = "Vector a"
vector_a._graphic.end_arrow_enabled = True
vector_b = data_item.add_line_region(0.5, 0.5, 0.75, 0.5)
vector_b.label = "Vector b"
vector_b._graphic.end_arrow_enabled = True
result_data_item = self.__api.library.create_data_item_from_data_and_metadata(
DataAndMetadata.new_data_and_metadata(
numpy.zeros_like(data_item.data),
data_descriptor=data_item.xdata.data_descriptor),
title="Affine Transformed {}".format(data_item.title))
self.__api.library.create_computation(
"nion.affine_transform_image",
inputs={
"src_data_item": data_item,
"vector_a": [vector_a],
"vector_b": [vector_b]
},
outputs={"target": result_data_item})
window.display_data_item(result_data_item)
def _run_align_zlp(api: API_1_0.API, window: API_1_0.DocumentWindow, method_id: str, method_name: str):
# find the focused data item
src_display = window.target_display
if src_display and src_display.data_item:
ref_index = 0
if src_display._display_item.display_data_channel:
# Using the sequence index as reference only makes sense for "pure" sequences because the index will be
# interpreted as index in the flattened non-datum axes
if src_display.data_item.xdata.is_sequence and not src_display.data_item.xdata.is_collection:
ref_index = src_display._display_item.display_data_channel.sequence_index
def progress(i):
logging.info(f"Processing row {i} (align zlp)")
roi = src_display.selected_graphics[0] if src_display.selected_graphics else None
dst_xdata, shift_xdata = align_zlp_xdata(src_display.data_item.xdata, progress, method=method_id, roi=roi, ref_index=ref_index)
if dst_xdata:
# create a new data item in the library and set its title.
if shift_xdata:
shift_data_item = api.library.create_data_item_from_data_and_metadata(shift_xdata)
shift_data_item.title = f"Shifts ({method_name}) " + src_display.data_item.title
data_item = api.library.create_data_item_from_data_and_metadata(dst_xdata)
data_item.title = f"Aligned ({method_name}) " + src_display.data_item.title
# display the data item.
window.display_data_item(data_item)
else:
logging.error("Failed: Data is not a sequence or collection of 1D spectra.")
else:
logging.error("Failed: No data item selected.")
def menu_item_execute(self, window: API.DocumentWindow) -> None:
document_controller = window._document_controller
selected_display_items = document_controller.selected_display_items
data_items = list()
src_vector_a = None
src_vector_b = None
for i, display_item in enumerate(selected_display_items):
data_item = display_item.data_items[0] if display_item and len(
display_item.data_items) > 0 else None
if data_item and src_vector_a is None:
for computation in self.__api.library._document_model.computations:
if computation.processing_id == "nion.affine_transform_image":
if computation.get_input("src_data_item") == data_item:
src_vector_a = computation.get_input("vector_a")
if src_vector_a is not None:
src_vector_a = self.__api._new_api_object(
src_vector_a[0])
src_vector_b = computation.get_input("vector_b")
if src_vector_b is not None:
src_vector_b = self.__api._new_api_object(
src_vector_b[0])
break
else:
data_items.append(self.__api._new_api_object(data_item))
elif data_item:
data_items.append(self.__api._new_api_object(data_item))
if src_vector_a is None:
return
for data_item in data_items:
vector_a = data_item.add_line_region(src_vector_a.start[0],
src_vector_a.start[1],
src_vector_a.end[0],
src_vector_a.end[1])
vector_a.label = "Vector a"
vector_a._graphic.end_arrow_enabled = True
vector_b = data_item.add_line_region(src_vector_b.start[0],
src_vector_b.start[1],
src_vector_b.end[0],
src_vector_b.end[1])
vector_b.label = "Vector b"
vector_b._graphic.end_arrow_enabled = True
result_data_item = self.__api.library.create_data_item_from_data_and_metadata(
DataAndMetadata.new_data_and_metadata(
numpy.zeros_like(data_item.data),
data_descriptor=data_item.xdata.data_descriptor),
title="Affine Transformed {}".format(data_item.title))
self.__api.library.create_computation(
"nion.affine_transform_image",
inputs={
"src_data_item": data_item,
"vector_a": [vector_a],
"vector_b": [vector_b]
},
outputs={"target": result_data_item})
window.display_data_item(result_data_item)
def menu_item_execute(self, window: API.DocumentWindow) -> None:
data_item = window.target_data_item
if data_item:
xdata = data_item.xdata
if xdata.datum_dimension_count == 1:
signal = nion.hyperspy.xdata_to_signal(xdata, copy_data=True)
signal.set_signal_type('EELS')
signal.align_zero_loss_peak(print_stats=False)
xdata = nion.hyperspy.signal_to_xdata(signal)
data_item = window.library.create_data_item_from_data_and_metadata(
xdata)
window.display_data_item(data_item)
def align_multi_si(api: API_1_0.API, window: API_1_0.DocumentWindow):
selected_display_items = window._document_controller._get_two_data_sources()
error_msg = "Select a sequence of spectrum images and a sequence of scanned images in order to use this computation."
assert selected_display_items[0][0] is not None, error_msg
assert selected_display_items[1][0] is not None, error_msg
assert selected_display_items[0][0].data_item is not None, error_msg
assert selected_display_items[1][0].data_item is not None, error_msg
assert selected_display_items[0][0].data_item.is_sequence, error_msg
assert selected_display_items[1][0].data_item.is_sequence, error_msg
if selected_display_items[0][0].data_item.is_collection:
si_sequence_data_item = selected_display_items[0][0].data_item
haadf_sequence_data_item = selected_display_items[1][0].data_item
align_region = selected_display_items[1][1]
align_index = selected_display_items[1][0].display_data_channel.sequence_index
elif selected_display_items[1][0].data_item.is_collection:
si_sequence_data_item = selected_display_items[1][0].data_item
haadf_sequence_data_item = selected_display_items[0][0].data_item
align_region = selected_display_items[0][1]
align_index = selected_display_items[0][0].display_data_channel.sequence_index
else:
raise ValueError(error_msg)
aligned_haadf = api.library.create_data_item_from_data(numpy.zeros((1,1,1)), title="Aligned {}".format(haadf_sequence_data_item.title))
aligned_si = api.library.create_data_item_from_data(numpy.zeros((1,1,1)), title="Aligned {}".format(si_sequence_data_item.title))
inputs = {"si_sequence_data_item": api._new_api_object(si_sequence_data_item),
"haadf_sequence_data_item": api._new_api_object(haadf_sequence_data_item),
"align_index": align_index}
if align_region:
inputs["align_region"] = api._new_api_object(align_region)
computation = api.library.create_computation("eels.align_multi_si",
inputs=inputs,
outputs={"aligned_haadf": aligned_haadf,
"aligned_si": aligned_si})
computation._computation.source = aligned_si._data_item
window.display_data_item(aligned_haadf)
window.display_data_item(aligned_si)
def acquire_spectrum_image(
api: API.API, document_window: API.DocumentWindow) -> None:
try:
logging.debug("start")
self.acquisition_state_changed_event.fire({"message": "start"})
try:
eels_camera = api.get_hardware_source_by_id("orca_camera",
version="1.0")
eels_camera_parameters = eels_camera.get_frame_parameters_for_profile_by_index(
0)
scan_controller = api.get_hardware_source_by_id(
"scan_controller", version="1.0")
scan_parameters = scan_controller.get_frame_parameters_for_profile_by_index(
2)
scan_max_size = 2048
scan_parameters["size"] = min(
scan_max_size, scan_parameters["size"][0]), min(
scan_max_size, scan_parameters["size"][1])
scan_parameters["pixel_time_us"] = int(
1000 * eels_camera_parameters["exposure_ms"] * 0.75)
scan_parameters["external_clock_wait_time_ms"] = int(
eels_camera_parameters["exposure_ms"] * 1.5)
scan_parameters["external_clock_mode"] = 1
library = document_window.library
data_item = library.create_data_item(_("Spectrum Image"))
document_window.display_data_item(data_item)
# force the data to be held in memory and write delayed by grabbing a data_ref.
with library.data_ref_for_data_item(data_item) as data_ref:
flyback_pixels = 2
with contextlib.closing(
eels_camera.create_view_task(
frame_parameters=eels_camera_parameters,
buffer_size=16)) as eels_view_task:
# wait for a frame, then create the record task during the next frame, then wait for that
# frame to finish. that will position the scan at the first position. proceed with acquisition.
eels_view_task.grab_next_to_finish()
eels_view_task.grab_earliest(
) # wait for current frame to finish
with contextlib.closing(
scan_controller.create_record_task(
scan_parameters)) as scan_task:
try:
scan_height = scan_parameters["size"][0]
scan_width = scan_parameters["size"][
1] + flyback_pixels
data_and_metadata_list = eels_view_task.grab_earliest(
)
eels_data_and_metadata = data_and_metadata_list[
1]
eels_data = eels_data_and_metadata.data
frame_index_base = eels_data_and_metadata.metadata[
"hardware_source"]["frame_index"]
frame_index = eels_data_and_metadata.metadata[
"hardware_source"][
"frame_index"] - frame_index_base
while True:
if self.__aborted:
scan_task.cancel()
break
column = frame_index % scan_width
row = frame_index // scan_width
if data_ref.data is None:
data_ref.data = numpy.zeros(
scan_parameters["size"] +
(eels_data.shape[0], ),
numpy.float)
if row >= scan_height:
break
if column < data_ref.data.shape[1]:
data_ref[row,
column, :] = eels_data
self.acquisition_state_changed_event.fire(
{
"message":
"update",
"position":
(row,
column + flyback_pixels)
})
data_and_metadata_list = eels_view_task.grab_earliest(
)
eels_data_and_metadata = data_and_metadata_list[
1]
eels_data = eels_data_and_metadata.data
frame_index = eels_data_and_metadata.metadata[
"hardware_source"][
"frame_index"] - frame_index_base
except:
scan_task.cancel()
raise
finally:
self.acquisition_state_changed_event.fire(
{"message": "end"})
logging.debug("end")
except Exception as e:
import traceback
traceback.print_exc()
def measure_temperature(api: API.API, window: API.DocumentWindow):
selected_display_items = window._document_controller._get_two_data_sources(
)
document_model = window._document_controller.document_model
error_msg = "Select two data items each containing one EEL spectrum in order to use this computation."
assert selected_display_items[0][0] is not None, error_msg
assert selected_display_items[1][0] is not None, error_msg
assert selected_display_items[0][0].data_item is not None, error_msg
assert selected_display_items[1][0].data_item is not None, error_msg
assert selected_display_items[0][0].data_item.is_data_1d, error_msg
assert selected_display_items[1][0].data_item.is_data_1d, error_msg
# First find out which data item is near and which is far. Far should have the higher maximum.
if np.amax(selected_display_items[0][0].data_item.data) > np.amax(
selected_display_items[1][0].data_item.data):
far_data_item = selected_display_items[0][0].data_item
near_data_item = selected_display_items[1][0].data_item
else:
far_data_item = selected_display_items[1][0].data_item
near_data_item = selected_display_items[0][0].data_item
# Now we need to calculate the difference and display it so that we have a place to put the interval on
difference_xdata = near_data_item.xdata - far_data_item.xdata
difference_data_item = api.library.create_data_item_from_data_and_metadata(
difference_xdata,
title=
f"Difference (Near - Far), ({near_data_item.title} - {far_data_item.title})"
)
window.display_data_item(difference_data_item)
calibration = difference_xdata.dimensional_calibrations[0]
# Create the default interval from 20 meV to 100 meV
graphic = difference_data_item.add_interval_region(
calibration.convert_from_calibrated_value(0.02) /
len(difference_xdata.data),
calibration.convert_from_calibrated_value(0.1) /
len(difference_xdata.data))
gain_data_item = api.library.create_data_item(title="Gain")
gain_fit_data_item = api.library.create_data_item(title="Gain Fit")
# Create the computation
api.library.create_computation("eels.measure_temperature",
inputs={
"near_data_item":
api._new_api_object(near_data_item),
"far_data_item":
api._new_api_object(far_data_item),
"fit_interval_graphic":
graphic
},
outputs={
"gain_fit_data_item":
gain_fit_data_item,
"gain_data_item": gain_data_item,
"difference_data_item":
difference_data_item
})
# Set up the plot of Gain and Fit
window.display_data_item(gain_data_item)
window.display_data_item(gain_fit_data_item)
gain_fit_display_item = document_model.get_display_item_for_data_item(
gain_fit_data_item._data_item)
gain_fit_display_item.append_display_data_channel_for_data_item(
gain_data_item._data_item)
gain_fit_display_item._set_display_layer_properties(0,
label=_("Fit"),
fill_color=None,
stroke_color="#F00")
gain_fit_display_item._set_display_layer_properties(1,
label=_("Gain"),
fill_color="#1E90FF")
gain_fit_display_item.set_display_property("legend_position", "top-right")
gain_fit_display_item.title = "Temperature Measurement Fit"
def align_multi_si(api: API_1_0.API, window: API_1_0.DocumentWindow):
selected_display_items = window._document_controller._get_two_data_sources(
)
error_msg = "Select a sequence of spectrum images and a sequence of scanned images in order to use this computation."
assert selected_display_items[0][0] is not None, error_msg
assert selected_display_items[1][0] is not None, error_msg
assert selected_display_items[0][0].data_item is not None, error_msg
assert selected_display_items[1][0].data_item is not None, error_msg
assert selected_display_items[0][0].data_item.is_sequence, error_msg
assert selected_display_items[1][0].data_item.is_sequence, error_msg
di_1 = selected_display_items[0][0].data_item
di_2 = selected_display_items[1][0].data_item
haadf_footprint = (2, True, 0, True)
di_1_footprint = (di_1.datum_dimension_count, di_1.is_sequence,
di_1.collection_dimension_count,
di_1.metadata.get("hardware_source",
{}).get("harwdare_source_id",
"") == "superscan")
di_2_footprint = (di_2.datum_dimension_count, di_2.is_sequence,
di_2.collection_dimension_count,
di_2.metadata.get("hardware_source",
{}).get("harwdare_source_id",
"") == "superscan")
di_1_points = 0
di_2_points = 0
print(di_1_footprint, di_2_footprint)
for i in range(len(haadf_footprint)):
di_1_points -= abs(haadf_footprint[i] - di_1_footprint[i])
di_2_points -= abs(haadf_footprint[i] - di_2_footprint[i])
print(di_1_points, di_2_points)
if di_1_points > di_2_points:
assert di_1_footprint[:-1] == haadf_footprint[:-1], error_msg
haadf_sequence_data_item = api._new_api_object(di_1)
si_sequence_data_item = api._new_api_object(di_2)
elif di_2_points > di_1_points:
assert di_2_footprint[:-1] == haadf_footprint[:-1], error_msg
haadf_sequence_data_item = api._new_api_object(di_2)
si_sequence_data_item = api._new_api_object(di_1)
else:
raise ValueError(error_msg)
print('here')
align_region = None
for graphic in haadf_sequence_data_item.graphics:
if graphic.graphic_type == 'rect-graphic':
align_region = graphic
break
if align_region is None:
align_region = haadf_sequence_data_item.add_rectangle_region(
0.5, 0.5, 0.75, 0.75)
align_region.label = 'Alignment bounds'
print('here2')
align_index = haadf_sequence_data_item.display._display.display_data_channel.sequence_index
aligned_haadf = api.library.create_data_item_from_data(
numpy.zeros((1, 1, 1)),
title="Aligned {}".format(haadf_sequence_data_item.title))
aligned_si = api.library.create_data_item_from_data(
numpy.zeros((1, 1, 1)),
title="Aligned {}".format(si_sequence_data_item.title))
inputs = {
"si_sequence_data_item": si_sequence_data_item,
"haadf_sequence_data_item": haadf_sequence_data_item,
"align_index": align_index,
"align_region": align_region
}
computation = api.library.create_computation("nion.align_multi_d_sequence",
inputs=inputs,
outputs={
"aligned_haadf":
aligned_haadf,
"aligned_si": aligned_si
})
computation._computation.source = aligned_si._data_item
window.display_data_item(aligned_haadf)
window.display_data_item(aligned_si)
print('here3')