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)