async def map_new_edge(document_controller, model_data_item, edge) -> None:
document_model = document_controller.document_model
project = document_model.get_project_for_item(model_data_item)
map_data_item = DataItem.new_data_item()
map_data_item.title = "{} of {}".format(_("Map"), str(edge.electron_shell))
map_data_item.category = model_data_item.category
map_data_item.source = model_data_item
document_model.append_data_item(map_data_item, project=project)
computation = document_model.create_computation()
computation.source = map_data_item
computation.create_input_item(
"spectrum_image_xdata",
Symbolic.make_item(model_data_item, type="xdata"))
computation.create_input_item("fit_interval",
Symbolic.make_item(edge.data_structure),
property_name="fit_interval")
computation.create_input_item("signal_interval",
Symbolic.make_item(edge.data_structure),
property_name="signal_interval")
computation.processing_id = "eels.mapping"
computation.create_output_item("map", Symbolic.make_item(map_data_item))
document_model.append_computation(computation, project=project)
await document_model.compute_immediate(document_controller.event_loop,
computation)
map_display_item = document_model.get_display_item_for_data_item(
map_data_item)
document_controller.show_display_item(map_display_item)
def test_data_item_setting_slice_validates_when_data_changes(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
d = numpy.random.randn(4, 4, 12)
data_item = DataItem.DataItem(d)
document_model.append_data_item(data_item)
map = {"a": Symbolic.make_item(data_item)}
data_item2 = document_controller.processing_computation(
"target.xdata = a.xdata[:,:,0:8]", map)
document_model.recompute_all()
assert numpy.array_equal(data_item2.data, d[:, :, 0:8])
display_item = document_model.get_display_item_for_data_item(
data_item2)
display_data_channel = display_item.display_data_channels[0]
display_data_channel.slice_center = 6
display_data_channel.slice_width = 4
self.assertEqual(display_data_channel.slice_center, 6)
self.assertEqual(display_data_channel.slice_width, 4)
document_model.get_data_item_computation(
display_item.data_item
).expression = "target.xdata = a.xdata[:, :, 0:4]"
document_model.recompute_all()
self.assertEqual(display_data_channel.slice_center, 3)
self.assertEqual(display_data_channel.slice_width, 2)
def test_data_item_setting_slice_validates_when_data_changes(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
d = numpy.random.randn(4, 4, 12)
data_item = DataItem.DataItem(d)
document_model.append_data_item(data_item)
map = {"a": Symbolic.make_item(data_item)}
data_item2 = document_controller.processing_computation(
"target.xdata = a.xdata[:,:,0:8]", map)
document_model.recompute_all()
assert numpy.array_equal(data_item2.data, d[:, :, 0:8])
display_item = document_model.get_display_item_for_data_item(
data_item2)
display_data_channel = display_item.display_data_channels[0]
display_data_channel.slice_center = 6
display_data_channel.slice_width = 4
self.assertEqual(display_data_channel.slice_center, 6)
self.assertEqual(display_data_channel.slice_width, 4)
document_model.get_data_item_computation(
display_item.data_item
).expression = "target.xdata = a.xdata[:, :, 0:4]"
document_model.recompute_all()
self.assertEqual(display_data_channel.slice_center, 3)
self.assertEqual(display_data_channel.slice_width, 2)
def test_invalid_expression_shows_error_and_clears_it(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
computation = document_model.create_computation("target.xdata = -a.xdata")
computation.create_input_item("a", Symbolic.make_item(data_item1))
document_model.set_data_item_computation(data_item2, computation)
panel = ComputationPanel.EditComputationDialog(document_controller, data_item2)
document_controller.periodic() # let the inspector see the computation
document_controller.periodic() # and update the computation
expression = panel._text_edit_for_testing.text
self.assertFalse(panel._error_label_for_testing.text.strip())
panel._text_edit_for_testing.text = "target.xdata = xyz(a.xdata)"
panel._update_button.on_clicked()
# the sequence of periodic/recompute_all is intentional, to test various computation states
document_controller.periodic()
document_model.recompute_all()
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(panel._text_edit_for_testing.text, "target.xdata = xyz(a.xdata)")
self.assertTrue(len(panel._error_label_for_testing.text) > 0)
panel._text_edit_for_testing.text = expression
panel._update_button.on_clicked()
# the sequence of periodic/recompute_all is intentional, to test various computation states
document_controller.periodic()
document_model.recompute_all()
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(panel._text_edit_for_testing.text, expression)
self.assertIsNone(panel._error_label_for_testing.text)
def test_variables_get_updates_when_switching_data_items(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
computation = document_model.create_computation(
"target.xdata = a.xdata + x")
computation.create_input_item("a", Symbolic.make_item(data_item1))
computation.create_variable("x", value_type="integral", value=5)
document_model.set_data_item_computation(data_item2, computation)
panel1 = ComputationPanel.EditComputationDialog(
document_controller, data_item1)
with contextlib.closing(panel1):
document_controller.periodic() # execute queue
self.assertEqual(len(panel1._sections_for_testing), 0)
panel2 = ComputationPanel.EditComputationDialog(
document_controller, data_item2)
with contextlib.closing(panel2):
document_controller.periodic() # execute queue
self.assertEqual(len(panel2._sections_for_testing), 2)
document_controller.periodic() # execute queue
self.assertEqual(len(panel1._sections_for_testing), 0)
def read_project(self) -> None:
properties = self._raw_properties
self.__project_version = properties.get("version", None)
if not self._raw_properties:
self.__project_state = "missing"
elif self.__project_version is not None and self.__project_version in (
FileStorageSystem.PROJECT_VERSION, 2):
for item_d in properties.get("data_items", list()):
data_item = DataItem.DataItem()
data_item.begin_reading()
data_item.read_from_dict(item_d)
data_item.finish_reading()
if not self.get_item_by_uuid("data_items", data_item.uuid):
self.load_item("data_items", len(self.data_items),
data_item)
for item_d in properties.get("display_items", list()):
display_item = DisplayItem.DisplayItem()
display_item.begin_reading()
display_item.read_from_dict(item_d)
display_item.finish_reading()
if not self.get_item_by_uuid("display_items",
display_item.uuid):
self.load_item("display_items", len(self.display_items),
display_item)
for item_d in properties.get("data_structures", list()):
data_structure = DataStructure.DataStructure()
data_structure.begin_reading()
data_structure.read_from_dict(item_d)
data_structure.finish_reading()
if not self.get_item_by_uuid("data_structures",
data_structure.uuid):
self.load_item("data_structures",
len(self.data_structures), data_structure)
for item_d in properties.get("computations", list()):
computation = Symbolic.Computation()
computation.begin_reading()
computation.read_from_dict(item_d)
computation.finish_reading()
if not self.get_item_by_uuid("computations", computation.uuid):
self.load_item("computations", len(self.computations),
computation)
# TODO: handle update script and bind after reload in document model
computation.update_script(
self.container.container.container.
_processing_descriptions)
for item_d in properties.get("connections", list()):
connection = Connection.connection_factory(item_d.get)
connection.begin_reading()
connection.read_from_dict(item_d)
connection.finish_reading()
if not self.get_item_by_uuid("connections", connection.uuid):
self.load_item("connections", len(self.connections),
connection)
self.__project_state = "loaded"
elif self.__project_version is not None:
self.__project_state = "needs_upgrade"
else:
self.__project_state = "missing"
def menu_item_execute(self, window: API.DocumentWindow) -> None:
document_controller = window._document_controller
selected_display_item = document_controller.selected_display_item
data_item = (selected_display_item.data_items[0]
if selected_display_item
and len(selected_display_item.data_items) > 0 else None)
if data_item:
api_data_item = Facade.DataItem(data_item)
if not api_data_item.xdata.is_data_4d:
self.__show_tool_tips('wrong_shape')
return
map_data_item = self.__api.library.create_data_item(
title='Map 4D of ' + data_item.title)
# the following uses internal API and should not be used as example code.
computation = document_controller.document_model.create_computation(
)
computation.create_input_item(
"src",
Symbolic.make_item(
selected_display_item.
get_display_data_channel_for_data_item(data_item)))
computation.create_input_item("map_regions",
Symbolic.make_item_list([]))
computation.processing_id = "nion.map_4d.2"
document_controller.document_model.set_data_item_computation(
map_data_item._data_item, computation)
map_display_item = document_controller.document_model.get_display_item_for_data_item(
map_data_item._data_item)
document_controller.show_display_item(map_display_item)
graphic = Graphics.PointGraphic()
graphic.label = "Pick"
graphic.role = "collection_index"
map_display_item.add_graphic(graphic)
# see note above.
self.__computation_data_items.update({
str(data_item.uuid):
'source',
str(map_data_item._data_item.uuid):
'map_4d'
})
self.__show_tool_tips()
self.__display_item_changed_event_listener = (
document_controller.focused_display_item_changed_event.listen(
self.__display_item_changed))
def test_computation_inspector_panel_handles_computation_being_removed_implicitly(
self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_item = DataItem.DataItem(numpy.zeros((10, )))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
interval = Graphics.IntervalGraphic()
display_item.add_graphic(interval)
interval2 = Graphics.IntervalGraphic()
display_item.add_graphic(interval2)
data_item2 = DataItem.DataItem(numpy.zeros((10, )))
document_model.append_data_item(data_item2)
display_item2 = document_model.get_display_item_for_data_item(
data_item2)
data_item3 = DataItem.DataItem(numpy.zeros((10, )))
document_model.append_data_item(data_item3)
display_item3 = document_model.get_display_item_for_data_item(
data_item3)
computation = document_model.create_computation()
computation.create_input_item("src", Symbolic.make_item(data_item))
computation.create_input_item("interval",
Symbolic.make_item(interval))
computation.create_input_item("interval2",
Symbolic.make_item(interval2))
computation.create_output_item("dst",
Symbolic.make_item(data_item2))
computation.create_output_item("dst2",
Symbolic.make_item(data_item3))
document_model.append_computation(computation)
interval2.source = interval
display_item.append_display_data_channel_for_data_item(data_item2)
display_item.append_display_data_channel_for_data_item(data_item3)
with contextlib.closing(
ComputationPanel.InspectComputationDialog(
document_controller, computation)):
display_item.remove_graphic(interval)
def select_button_clicked():
for variable in self.computation._computation.variables:
if variable.name == "align_region":
self.computation._computation.remove_variable(variable)
graphics = document_controller.target_display.selected_graphics or list()
align_region = None
for graphic in graphics:
if graphic.graphic_type == "rect-graphic":
align_region = graphic
break
if align_region:
self.computation._computation.create_input_item("align_region", Symbolic.make_item(align_region._graphic))
def select_button_clicked():
graphics = document_controller.target_display.selected_graphics
if not graphics:
return
try:
while True:
self.computation._computation.remove_item_from_objects(
'map_regions', 0)
except IndexError:
pass
for graphic in graphics:
self.computation._computation.insert_item_into_objects(
'map_regions', 0, Symbolic.make_item(graphic._graphic))
def test_background_subtraction_computation_functions_reasonably(self):
document_model = DocumentModel.DocumentModel()
self.app._set_document_model(
document_model) # required to allow API to find document model
elemental_mapping_controller = ElementalMappingController.ElementalMappingController(
document_model)
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller), contextlib.closing(
elemental_mapping_controller):
model_data_item = self.__create_spectrum_image()
document_model.append_data_item(model_data_item)
elemental_mapping_controller.set_current_data_item(model_data_item)
si_edge = elemental_mapping_controller.add_edge(
PeriodicTable.ElectronShell(14, 1, 1)) # Si-K
spectrum_data_item = self.__create_spectrum()
document_model.append_data_item(spectrum_data_item)
spectrum_display_item = document_model.get_display_item_for_data_item(
spectrum_data_item)
spectrum_display_data_channel = spectrum_display_item.get_display_data_channel_for_data_item(
spectrum_data_item)
computation = document_model.create_computation()
computation.create_input_item(
"eels_spectrum_xdata",
Symbolic.make_item(spectrum_display_data_channel,
type="display_xdata"))
computation.create_input_item("fit_interval",
Symbolic.make_item(
si_edge.data_structure),
property_name="fit_interval")
computation.create_input_item("signal_interval",
Symbolic.make_item(
si_edge.data_structure),
property_name="signal_interval")
computation.processing_id = "eels.background_subtraction"
document_model.append_computation(computation)
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(2, len(document_model.data_items))
def test_change_variable_command_resulting_in_creating_data_item_undo_redo(
self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
# setup
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
data_item3 = DataItem.DataItem(numpy.zeros((10, )))
document_model.append_data_item(data_item3)
computation = document_model.create_computation(
"target.xdata = a.xdata[1] + x")
variable = computation.create_input_item(
"a", Symbolic.make_item(data_item3))
computation.create_variable("x", value_type="integral", value=5)
document_model.set_data_item_computation(data_item1, computation)
# verify setup
self.assertEqual(data_item3, computation.get_input("a"))
document_model.recompute_all()
document_controller.periodic()
self.assertIsNotNone(computation.error_text)
# change variable
properties = {
"variable_type": "data_item",
"specified_object": data_item2
}
command = Inspector.ChangeComputationVariableCommand(
document_controller.document_model, computation, variable,
**properties)
command.perform()
document_controller.push_undo_command(command)
# verify change and trigger computation
self.assertEqual(data_item2, computation.get_input("a"))
document_model.recompute_all()
document_controller.periodic()
self.assertIsNone(computation.error_text)
# undo and verify
document_controller.handle_undo()
self.assertEqual(data_item3, computation.get_input("a"))
document_model.recompute_all()
document_controller.periodic()
self.assertIsNotNone(computation.error_text)
# redo and verify
document_controller.handle_redo()
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(data_item2, computation.get_input("a"))
self.assertIsNone(computation.error_text)
def test_connection_establishes_transaction_on_target_data_structure_dependent(
self):
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_document_model()
data_item = DataItem.DataItem(numpy.zeros((20, )))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
interval = Graphics.IntervalGraphic()
display_item.add_graphic(interval)
data_struct = document_model.create_data_structure()
data_struct.set_property_value("x_interval", (0.5, 0.1))
document_model.append_data_structure(data_struct)
connection = Connection.PropertyConnection(data_struct,
"x_interval",
interval,
"interval",
parent=data_item)
document_model.append_connection(connection)
computed_data_item = DataItem.DataItem(numpy.zeros((100, )))
document_model.append_data_item(computed_data_item)
computation = document_model.create_computation(
Symbolic.xdata_expression("a.xdata"))
computation.create_input_item("a", Symbolic.make_item(data_item))
computation.create_input_item("d", Symbolic.make_item(data_struct))
document_model.set_data_item_computation(computed_data_item,
computation)
with document_model.item_transaction(data_item):
self.assertTrue(
document_model.is_in_transaction_state(data_item))
self.assertTrue(
document_model.is_in_transaction_state(display_item))
self.assertTrue(
document_model.is_in_transaction_state(data_struct))
self.assertTrue(
document_model.is_in_transaction_state(computed_data_item))
self.assertEqual(0, document_model.transaction_count)
def test_background_subtraction_computation_functions_reasonably(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller_with_application(
)
document_model = document_controller.document_model
elemental_mapping_controller = ElementalMappingController.ElementalMappingController(
document_model)
model_data_item = self.__create_spectrum_image()
document_model.append_data_item(model_data_item)
elemental_mapping_controller.set_current_data_item(model_data_item)
si_edge = elemental_mapping_controller.add_edge(
PeriodicTable.ElectronShell(14, 1, 1)) # Si-K
spectrum_data_item = self.__create_spectrum()
document_model.append_data_item(spectrum_data_item)
spectrum_display_item = document_model.get_display_item_for_data_item(
spectrum_data_item)
spectrum_display_data_channel = spectrum_display_item.get_display_data_channel_for_data_item(
spectrum_data_item)
computation = document_model.create_computation()
computation.create_input_item(
"eels_spectrum_xdata",
Symbolic.make_item(spectrum_display_data_channel,
type="display_xdata"))
computation.create_input_item("fit_interval",
Symbolic.make_item(
si_edge.data_structure),
property_name="fit_interval")
computation.create_input_item("signal_interval",
Symbolic.make_item(
si_edge.data_structure),
property_name="signal_interval")
computation.processing_id = "eels.background_subtraction"
document_model.append_computation(computation)
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(2, len(document_model.data_items))
def test_expression_updates_when_node_is_changed(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
computation = document_model.create_computation("target.xdata = -a.xdata")
computation.create_input_item("a", Symbolic.make_item(data_item1))
document_model.set_data_item_computation(data_item2, computation)
panel = ComputationPanel.EditComputationDialog(document_controller, data_item2)
document_controller.periodic() # execute queue
text1 = panel._text_edit_for_testing.text
document_model.get_data_item_computation(data_item2).expression = "target.xdata = -a.xdata + 1"
document_controller.periodic() # execute queue
text2 = panel._text_edit_for_testing.text
self.assertNotEqual(text2, text1)
def select_button_clicked(channel):
graphics = document_controller.target_display.selected_graphics
if not graphics:
return
try:
while True:
self.computation._computation.remove_item_from_objects(
f'map_regions_{channel}', 0)
except IndexError:
pass
for graphic in graphics:
self.computation._computation.insert_item_into_objects(
f'map_regions_{channel}', 0,
Symbolic.make_item(graphic._graphic))
title_suffix = f' ({channel.upper()})'
title = graphic.label or ''
if not title.endswith(title_suffix):
title += title_suffix
graphic.label = title
def test_change_variable_command_resulting_in_creating_data_item_undo_redo(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
# setup
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
data_item3 = DataItem.DataItem(numpy.zeros((10, )))
document_model.append_data_item(data_item3)
computation = document_model.create_computation("target.xdata = a.xdata[1] + x")
variable = computation.create_input_item("a", Symbolic.make_item(data_item3))
computation.create_variable("x", value_type="integral", value=5)
document_model.set_data_item_computation(data_item1, computation)
# verify setup
self.assertEqual(data_item3, computation.get_input("a"))
document_model.recompute_all()
document_controller.periodic()
self.assertIsNotNone(computation.error_text)
# change variable
variable_specifier = document_model.get_object_specifier(data_item2)
properties = {"variable_type": "data_item", "specifier": variable_specifier}
command = ComputationPanel.ComputationModel.ChangeVariableCommand(document_controller.document_model, computation, variable, **properties)
command.perform()
document_controller.push_undo_command(command)
# verify change and trigger computation
self.assertEqual(data_item2, computation.get_input("a"))
document_model.recompute_all()
document_controller.periodic()
self.assertIsNone(computation.error_text)
# undo and verify
document_controller.handle_undo()
self.assertEqual(data_item3, computation.get_input("a"))
document_model.recompute_all()
document_controller.periodic()
self.assertIsNotNone(computation.error_text)
# redo and verify
document_controller.handle_redo()
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(data_item2, computation.get_input("a"))
self.assertIsNone(computation.error_text)
def test_clearing_computation_clears_text_and_unbinds_or_whatever(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
computation = document_model.create_computation("target.xdata = -a.xdata")
computation.create_input_item("a", Symbolic.make_item(data_item1))
document_model.set_data_item_computation(data_item2, computation)
panel = ComputationPanel.EditComputationDialog(document_controller, data_item2)
document_controller.periodic() # execute queue
panel._text_edit_for_testing.text = ""
panel._update_button.on_clicked()
document_controller.periodic()
self.assertIsNone(document_model.get_data_item_computation(data_item2))
text2 = panel._text_edit_for_testing.text
self.assertFalse(text2)
def select_button_clicked():
graphics = Facade.DataItem(
self.computation._computation.source).graphics
if not graphics:
return
graphics_variable = self.computation._computation._get_variable(
'map_regions')
graphics_variable.disconnect_items()
if graphics_variable.bound_items_model is None:
return
num_items = len(graphics_variable.bound_items_model.items)
for _ in range(num_items):
self.computation._computation.remove_item_from_objects(
'map_regions', 0)
for graphic in graphics:
if graphic._graphic.role == 'mask':
self.computation._computation.insert_item_into_objects(
'map_regions', 0,
Symbolic.make_item(graphic._graphic,
type='graphic'))
def test_expression_updates_when_node_is_changed(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
computation = document_model.create_computation(
"target.xdata = -a.xdata")
computation.create_input_item("a", Symbolic.make_item(data_item1))
document_model.set_data_item_computation(data_item2, computation)
panel = ComputationPanel.EditComputationDialog(
document_controller, data_item2)
document_controller.periodic() # execute queue
text1 = panel._text_edit_for_testing.text
document_model.get_data_item_computation(
data_item2).expression = "target.xdata = -a.xdata + 1"
document_controller.periodic() # execute queue
text2 = panel._text_edit_for_testing.text
self.assertNotEqual(text2, text1)
def test_error_text_cleared_after_invalid_script_becomes_valid(self):
# similar to test_invalid_expression_shows_error_and_clears_it except periodic occurs before recompute at end
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
computation = document_model.create_computation(
"target.xdata = -a.xdata")
computation.create_input_item("a", Symbolic.make_item(data_item1))
document_model.set_data_item_computation(data_item2, computation)
panel = ComputationPanel.EditComputationDialog(
document_controller, data_item2)
document_controller.periodic(
) # let the inspector see the computation
document_controller.periodic() # and update the computation
expression = panel._text_edit_for_testing.text
self.assertFalse(panel._error_label_for_testing.text.strip())
panel._text_edit_for_testing.text = "target.xdata = xyz(a.xdata)"
panel._update_button.on_clicked()
# the sequence of periodic/recompute_all is intentional, to test various computation states
document_controller.periodic()
document_model.recompute_all()
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(panel._text_edit_for_testing.text,
"target.xdata = xyz(a.xdata)")
self.assertTrue(len(panel._error_label_for_testing.text) > 0)
panel._text_edit_for_testing.text = expression
panel._update_button.on_clicked()
# the sequence of periodic/recompute_all is intentional, to test various computation states
document_controller.periodic()
document_model.recompute_all()
document_model.recompute_all()
document_controller.periodic()
self.assertEqual(panel._text_edit_for_testing.text, expression)
self.assertIsNone(panel._error_label_for_testing.text)
def test_clearing_computation_clears_text_and_unbinds_or_whatever(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_item1 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((10, 10)))
document_model.append_data_item(data_item2)
computation = document_model.create_computation(
"target.xdata = -a.xdata")
computation.create_input_item("a", Symbolic.make_item(data_item1))
document_model.set_data_item_computation(data_item2, computation)
panel = ComputationPanel.EditComputationDialog(
document_controller, data_item2)
document_controller.periodic() # execute queue
panel._text_edit_for_testing.text = "" # no longer clears the computation. cm 2020-08.
panel._update_button.on_clicked()
document_controller.periodic()
self.assertIsNotNone(
document_model.get_data_item_computation(data_item2))
text2 = panel._text_edit_for_testing.text
self.assertFalse(text2)
class FloatTupleToIntTupleConverter:
def __init__(self, axis_size, axis_index):
self.axis_size = axis_size
self.axis_index = axis_index
def convert(self, value):
return int(value * self.axis_size)
def convert_back(self, value):
return (value[self.axis_index] + 0.5) / self.axis_size
class Map4DExtension:
# required for Swift to recognize this as an extension class.
extension_id = "nion.extension.libertem_map_4d"
def __init__(self, api_broker):
# grab the api object.
api = api_broker.get_api(version="1", ui_version="1")
# be sure to keep a reference or it will be closed immediately.
self.__menu_item_ref = api.create_menu_item(Map4DMenuItem(api))
def close(self):
self.__menu_item_ref.close()
Symbolic.register_computation_type('nion.libertem.map_4d', Map4D)
def register_computation(self) -> None:
Symbolic.register_computation_type(
self.processing_id, functools.partial(ProcessingComputation, self))
map_display_item.add_graphic(graphic)
# see note above.
self.__computation_data_items.update({
str(data_item.uuid):
'source',
str(map_data_item._data_item.uuid):
'map_4d'
})
self.__show_tool_tips()
self.__display_item_changed_event_listener = (
document_controller.focused_display_item_changed_event.listen(
self.__display_item_changed))
class Map4DExtension:
# required for Swift to recognize this as an extension class.
extension_id = "nion.extension.map_4d"
def __init__(self, api_broker):
# grab the api object.
api = api_broker.get_api(version="1", ui_version="1")
# be sure to keep a reference or it will be closed immediately.
self.__menu_item_ref = api.create_menu_item(Map4DMenuItem(api))
def close(self):
self.__menu_item_ref.close()
Symbolic.register_computation_type('nion.map_4d.2', Map4D)
self.computation.set_referenced_xdata("gain_data_item",
self.__gain_xdata)
self.computation.set_referenced_xdata("gain_fit_data_item",
self.__gain_fit_xdata)
self.computation.set_referenced_xdata("difference_data_item",
self.__difference_xdata)
gain_fit_display_item = self.computation.get_result(
"gain_fit_data_item").display._display_item
gain_fit_display_item._set_display_layer_properties(
0,
label=
_(f"Fit T = {self.__fit[0] - 273.15:.0f} °C \nZLP shift = {self.__fit[1]*1000.0:.2f} meV"
))
Symbolic.register_computation_type("eels.measure_temperature",
MeasureTemperature)
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.
def computation_factory(lookup_id):
return Symbolic.Computation()
def read_project(self) -> None:
if callable(self.handle_start_read):
self.handle_start_read()
properties = self._raw_properties
if properties:
project_version = properties.get("version", None)
if project_version is not None and project_version == FileStorageSystem.PROJECT_VERSION:
for item_d in properties.get("data_items", list()):
data_item = DataItem.DataItem()
data_item.begin_reading()
data_item.read_from_dict(item_d)
data_item.finish_reading()
if not self.get_item_by_uuid("data_items", data_item.uuid):
self.load_item("data_items", len(self.data_items),
data_item)
else:
data_item.close()
for item_d in properties.get("display_items", list()):
display_item = DisplayItem.DisplayItem()
display_item.begin_reading()
display_item.read_from_dict(item_d)
display_item.finish_reading()
if not self.get_item_by_uuid("display_items",
display_item.uuid):
self.load_item("display_items",
len(self.display_items), display_item)
else:
display_item.close()
for item_d in properties.get("data_structures", list()):
data_structure = DataStructure.DataStructure()
data_structure.begin_reading()
data_structure.read_from_dict(item_d)
data_structure.finish_reading()
if not self.get_item_by_uuid("data_structures",
data_structure.uuid):
self.load_item("data_structures",
len(self.data_structures),
data_structure)
else:
data_structure.close()
for item_d in properties.get("computations", list()):
computation = Symbolic.Computation()
computation.begin_reading()
computation.read_from_dict(item_d)
computation.finish_reading()
if not self.get_item_by_uuid("computations",
computation.uuid):
self.load_item("computations", len(self.computations),
computation)
# TODO: handle update script and bind after reload in document model
computation.update_script(
Project._processing_descriptions)
computation.reset()
else:
computation.close()
for item_d in properties.get("connections", list()):
connection = Connection.connection_factory(item_d.get)
connection.begin_reading()
connection.read_from_dict(item_d)
connection.finish_reading()
if not self.get_item_by_uuid("connections",
connection.uuid):
self.load_item("connections", len(self.connections),
connection)
else:
connection.close()
for item_d in properties.get("data_groups", list()):
data_group = DataGroup.data_group_factory(item_d.get)
data_group.begin_reading()
data_group.read_from_dict(item_d)
data_group.finish_reading()
if not self.get_item_by_uuid("data_groups",
data_group.uuid):
self.load_item("data_groups", len(self.data_groups),
data_group)
else:
data_group.close()
for item_d in properties.get("workspaces", list()):
workspace = WorkspaceLayout.factory(item_d.get)
workspace.begin_reading()
workspace.read_from_dict(item_d)
workspace.finish_reading()
if not self.get_item_by_uuid("workspaces", workspace.uuid):
self.load_item("workspaces", len(self.workspaces),
workspace)
else:
workspace.close()
workspace_uuid_str = properties.get("workspace_uuid", None)
if workspace_uuid_str:
self._set_persistent_property_value(
"workspace_uuid", uuid.UUID(workspace_uuid_str))
self._set_persistent_property_value(
"data_item_references",
properties.get("data_item_references", dict()))
self._set_persistent_property_value(
"mapped_items", properties.get("mapped_items", list()))
self.__has_been_read = True
if callable(self.handle_finish_read):
self.handle_finish_read()
'gain_image': [],
'gain_mode': 'custom'},
outputs={'target': dark_corrected_data_item})
computation._computation.source = dark_corrected_data_item._data_item
dark_corrected_display_item = document_controller.document_model.get_display_item_for_data_item(
dark_corrected_data_item._data_item)
document_controller.show_display_item(dark_corrected_display_item)
self.__computation_data_items.update({data_item: 'source',
total_bin_data_item._data_item: 'total bin',
dark_corrected_data_item._data_item: 'corrected'})
self.__show_tool_tips()
self.__display_item_changed_event_listener = (
document_controller.focused_display_item_changed_event.listen(self.__display_item_changed))
class DarkCorrection4DExtension:
# required for Swift to recognize this as an extension class.
extension_id = "nion.extension.4d_dark_correction"
def __init__(self, api_broker):
# grab the api object.
api = api_broker.get_api(version="1", ui_version="1")
# be sure to keep a reference or it will be closed immediately.
self.__menu_item_ref = api.create_menu_item(DarkCorrection4DMenuItem(api))
def close(self):
self.__menu_item_ref.close()
Symbolic.register_computation_type('nion.total_bin_4d_SI', TotalBin4D)
Symbolic.register_computation_type('nion.dark_correction_4d', DarkCorrection4D)
"fit_interval_graphics": fit_interval_graphics,
"signal_interval_graphic":
signal_interval_graphic,
"background_model": background_model,
},
outputs={"map": map})
window.display_data_item(map)
break
def subtract_background_from_signal(api, window):
window._document_controller.event_loop.create_task(
use_interval_as_background(api, window))
Symbolic.register_computation_type("eels.background_subtraction3",
EELSBackgroundSubtraction)
Symbolic.register_computation_type("eels.mapping3", EELSMapping)
BackgroundModel = Schema.entity("background_model", None, None, {})
def component_registered(component, component_types):
if "background-model" in component_types:
# when a background model is registered, create an empty (for now) entity type, and register it with the data
# structure so that an entity for use with the UI and computations can be created when the data structure loads.
background_model_entity = Schema.entity(component.background_model_id,
BackgroundModel, None, {})
DataStructure.DataStructure.register_entity(
background_model_entity,
entity_name=component.title,
entity_package_name=component.package_title)
