def test_items_with_duplicate_uuid_are_loaded_properly(self): with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) with contextlib.closing(document_model): data_item = DataItem.DataItem( numpy.ones((16, 16), numpy.uint32)) document_model.append_data_item(data_item, project=profile.projects[0]) project_keys = list(profile_context.x_data_properties_map.keys()) profile_context.x_data_properties_map[ project_keys[1]] = copy.deepcopy( profile_context.x_data_properties_map[project_keys[0]]) profile_context.x_data_map[project_keys[1]] = copy.deepcopy( profile_context.x_data_map[project_keys[0]]) profile_context.x_project_properties[ project_keys[1]] = copy.deepcopy( profile_context.x_project_properties[project_keys[0]]) profile_context.x_project_properties[ project_keys[1]]["uuid"] = str(project_keys[1]) document_model = DocumentModel.DocumentModel( profile=profile_context.create_profile()) with contextlib.closing(document_model): self.assertEqual(2, len(document_model.profile.projects)) self.assertEqual(2, len(document_model.data_items)) self.assertEqual( 1, len(document_model.profile.projects[0].data_items)) self.assertEqual( 1, len(document_model.profile.projects[1].data_items)) self.assertEqual(2, len(document_model.display_items)) self.assertEqual( 1, len(document_model.profile.projects[0].display_items)) self.assertEqual( 1, len(document_model.profile.projects[1].display_items))
def test_display_item_is_added_to_same_project_as_data_item(self): with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) with contextlib.closing(document_model): data_item = DataItem.DataItem( numpy.ones((16, 16), numpy.uint32)) document_model.append_data_item(data_item, project=profile.projects[0]) document_model.append_display_item( DisplayItem.DisplayItem(data_item=data_item)) data_item = DataItem.DataItem( numpy.ones((16, 16), numpy.uint32)) document_model.append_data_item(data_item, project=profile.projects[1]) document_model.append_display_item( DisplayItem.DisplayItem(data_item=data_item)) document_model = DocumentModel.DocumentModel( profile=profile_context.create_profile()) with contextlib.closing(document_model): self.assertEqual(2, len(document_model.data_items)) self.assertEqual(4, len(document_model.display_items)) self.assertEqual( 2, len(document_model.profile.projects[0].display_items)) self.assertEqual( 2, len(document_model.profile.projects[1].display_items))
def test_add_data_structure_to_project_reloads(self): with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) with contextlib.closing(document_model): data_item = DataItem.DataItem( numpy.ones((16, 16), numpy.uint32)) document_model.append_data_item(data_item, project=profile.projects[0]) data_struct = document_model.create_data_structure() data_struct.set_referenced_object("master", data_item) document_model.append_data_structure(data_struct) data_item = DataItem.DataItem( numpy.ones((16, 16), numpy.uint32)) document_model.append_data_item(data_item, project=profile.projects[1]) data_struct = document_model.create_data_structure() data_struct.set_referenced_object("master", data_item) document_model.append_data_structure(data_struct) document_model = DocumentModel.DocumentModel( profile=profile_context.create_profile()) with contextlib.closing(document_model): self.assertEqual(2, len(document_model.data_items)) self.assertEqual(2, len(document_model.data_structures)) self.assertEqual( 1, len(document_model.profile.projects[0].data_structures)) self.assertEqual( 1, len(document_model.profile.projects[1].data_structures))
def test_profile_with_two_projects_with_data_items_reload(self): with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) with contextlib.closing(document_model): data_item = DataItem.DataItem( numpy.ones((16, 16), numpy.uint32)) document_model.append_data_item(data_item, project=profile.projects[0]) data_item = DataItem.DataItem( numpy.ones((16, 16), numpy.uint32)) document_model.append_data_item(data_item, project=profile.projects[1]) self.assertEqual( 1, len(document_model.profile.projects[0].data_items)) self.assertEqual( 1, len(document_model.profile.projects[1].data_items)) document_model = DocumentModel.DocumentModel( profile=profile_context.create_profile()) with contextlib.closing(document_model): self.assertEqual(2, len(document_model.profile.projects)) self.assertEqual(2, len(document_model.data_items)) self.assertEqual( 1, len(document_model.profile.projects[0].data_items)) self.assertEqual( 1, len(document_model.profile.projects[1].data_items)) self.assertEqual(2, len(document_model.display_items)) self.assertEqual( 1, len(document_model.profile.projects[0].display_items)) self.assertEqual( 1, len(document_model.profile.projects[1].display_items))
def test_data_item_in_computation_is_not_bound_to_another_project(self): with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) item_uuid = uuid.uuid4() with contextlib.closing(document_model): data_item0 = DataItem.DataItem(numpy.ones((16, 16), numpy.uint32), item_uuid=item_uuid) document_model.append_data_item(data_item0, project=profile.projects[0]) display_item0 = document_model.get_display_item_for_data_item( data_item0) document_model.get_invert_new(display_item0) data_item1 = DataItem.DataItem(numpy.ones((16, 16), numpy.uint32), item_uuid=item_uuid) document_model.append_data_item(data_item1, project=profile.projects[1]) display_item1 = document_model.get_display_item_for_data_item( data_item1) document_model.get_invert_new(display_item1) document_model.recompute_all() self.assertEqual(4, len(document_model.data_items)) self.assertEqual(2, len(profile.projects[0].data_items)) self.assertEqual(2, len(profile.projects[1].data_items)) self.assertEqual(1, len(profile.projects[0].computations)) self.assertEqual(1, len(profile.projects[1].computations)) self.assertEqual( data_item0, list(profile.projects[0].computations[0].input_items)[0]) self.assertEqual( data_item1, list(profile.projects[1].computations[0].input_items)[0]) document_model = DocumentModel.DocumentModel( profile=profile_context.create_profile()) profile = document_model.profile data_item0 = document_model.data_items[0] data_item1 = document_model.data_items[2] with contextlib.closing(document_model): self.assertEqual(4, len(document_model.data_items)) self.assertEqual(2, len(profile.projects[0].data_items)) self.assertEqual(2, len(profile.projects[1].data_items)) self.assertEqual(1, len(profile.projects[0].computations)) self.assertEqual(1, len(profile.projects[1].computations)) self.assertEqual( data_item0, list(profile.projects[0].computations[0].input_items)[0]) self.assertEqual( data_item1, list(profile.projects[1].computations[0].input_items)[0])
def test_connections_between_items_with_duplicated_uuids_are_connected_per_project( self): with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) with contextlib.closing(document_model): data_item1 = DataItem.DataItem(numpy.ones((4, 4))) document_model.append_data_item(data_item1, project=profile.projects[0]) display_item1 = document_model.get_display_item_for_data_item( data_item1) data_item2 = DataItem.DataItem(numpy.ones((4, 4))) document_model.append_data_item(data_item2, project=profile.projects[0]) display_item2 = document_model.get_display_item_for_data_item( data_item2) connection = Connection.PropertyConnection(display_item1, "title", display_item2, "title", parent=data_item1) document_model.append_connection(connection) project_keys = list(profile_context.x_data_properties_map.keys()) profile_context.x_data_properties_map[ project_keys[1]] = copy.deepcopy( profile_context.x_data_properties_map[project_keys[0]]) profile_context.x_data_map[project_keys[1]] = copy.deepcopy( profile_context.x_data_map[project_keys[0]]) profile_context.x_project_properties[ project_keys[1]] = copy.deepcopy( profile_context.x_project_properties[project_keys[0]]) profile_context.x_project_properties[ project_keys[1]]["uuid"] = str(project_keys[1]) document_model = DocumentModel.DocumentModel( profile=profile_context.create_profile()) with contextlib.closing(document_model): project0 = document_model.profile.projects[0] project1 = document_model.profile.projects[1] self.assertEqual(4, len(document_model.data_items)) self.assertEqual(2, len(document_model.connections)) self.assertEqual(1, len(project0.connections)) self.assertEqual(1, len(project1.connections)) self.assertEqual(4, len(document_model.display_items)) self.assertEqual(2, len(project0.display_items)) self.assertEqual(2, len(project1.display_items)) for item in project0.connections[0].connected_items: self.assertEqual(project0, Project.get_project_for_item(item)) for item in project1.connections[0].connected_items: self.assertEqual(project1, Project.get_project_for_item(item))
def test_display_items_between_items_with_duplicated_uuids_are_connected_per_project( self): with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) with contextlib.closing(document_model): data_item = DataItem.DataItem(numpy.ones((16, 1), numpy.float)) document_model.append_data_item(data_item, project=profile.projects[0]) data_item2 = DataItem.DataItem(numpy.ones((16, 1), numpy.float)) document_model.append_data_item(data_item2, project=profile.projects[0]) document_model.display_items[ 0].append_display_data_channel_for_data_item(data_item2) project_keys = list(profile_context.x_data_properties_map.keys()) profile_context.x_data_properties_map[ project_keys[1]] = copy.deepcopy( profile_context.x_data_properties_map[project_keys[0]]) profile_context.x_data_map[project_keys[1]] = copy.deepcopy( profile_context.x_data_map[project_keys[0]]) profile_context.x_project_properties[ project_keys[1]] = copy.deepcopy( profile_context.x_project_properties[project_keys[0]]) profile_context.x_project_properties[ project_keys[1]]["uuid"] = str(project_keys[1]) document_model = DocumentModel.DocumentModel( profile=profile_context.create_profile()) with contextlib.closing(document_model): project0 = document_model.profile.projects[0] project1 = document_model.profile.projects[1] self.assertEqual(4, len(document_model.data_items)) self.assertEqual(4, len(document_model.display_items)) self.assertEqual(2, len(project0.display_items)) self.assertEqual(2, len(project1.display_items)) self.assertEqual( 2, len( set(project0.display_items[0].data_items).intersection( set(project0.data_items)))) self.assertEqual( 2, len( set(project1.display_items[0].data_items).intersection( set(project1.data_items)))) for item in project0.display_items[0].data_items: self.assertEqual(project0, Project.get_project_for_item(item)) for item in project1.display_items[0].data_items: self.assertEqual(project1, Project.get_project_for_item(item))
def test_cursor_over_2d_data_sequence_displays_correct_ordering_of_indices( self): document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( self.app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): display_panel = document_controller.selected_display_panel data_and_metadata = DataAndMetadata.new_data_and_metadata( numpy.ones((20, 100, 100), numpy.float64), data_descriptor=DataAndMetadata.DataDescriptor(True, 0, 2)) data_item = DataItem.new_data_item(data_and_metadata) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_item.display_data_channels[0].sequence_index = 4 display_item.calibration_style_id = "pixels-top-left" display_panel.set_display_panel_display_item(display_item) header_height = display_panel.header_canvas_item.header_height info_panel = document_controller.find_dock_panel("info-panel") display_panel.root_container.layout_immediate( (1000 + header_height, 1000)) display_panel.display_canvas_item.mouse_entered() document_controller.periodic() display_panel.display_canvas_item.mouse_position_changed( 500, 500, Graphics.NullModifiers()) document_controller.periodic() self.assertEqual(info_panel.label_row_1.text, "Position: 50.0, 50.0, 4.0") self.assertEqual(info_panel.label_row_2.text, "Value: 1") self.assertIsNone(info_panel.label_row_3.text, None) display_panel.display_canvas_item.mouse_exited()
def test_connection_updates_source_when_target_changes(self): # setup document model document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data_item_3d = DataItem.DataItem( numpy.zeros((8, 8, 32), numpy.uint32)) data_item_1d = DataItem.DataItem(numpy.zeros((32, ), numpy.uint32)) document_model.append_data_item(data_item_3d) document_model.append_data_item(data_item_1d) display_item_1d = document_model.get_display_item_for_data_item( data_item_1d) display_item_3d = document_model.get_display_item_for_data_item( data_item_1d) interval = Graphics.IntervalGraphic() display_item_1d.add_graphic(interval) display_data_channel_3d = display_item_3d.display_data_channels[0] connection = Connection.PropertyConnection(display_data_channel_3d, "slice_center", interval, "start", parent=data_item_1d) document_model.append_connection(connection) # test to see if connection updates target when source changes interval.start = 9 self.assertEqual(display_data_channel_3d.slice_center, 9)
def test_connection_to_graphic_puts_data_item_under_transaction(self): document_model = DocumentModel.DocumentModel() with contextlib.closing(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) with document_model.item_transaction(data_struct): self.assertTrue( document_model.is_in_transaction_state(data_struct)) self.assertTrue( document_model.is_in_transaction_state(interval)) self.assertTrue( document_model.is_in_transaction_state(display_item))
def test_variables_get_updates_when_switching_data_items(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 + x") computation.create_object( "a", document_model.get_object_specifier(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) document_controller.periodic() # execute queue self.assertEqual(len(panel1._sections_for_testing), 0) panel2 = ComputationPanel.EditComputationDialog( document_controller, data_item2) 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 test_processed_data_items_sorted_by_source_data_modified_date(self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): filtered_data_items = ListModel.FilteredListModel( items_key="data_items") filtered_data_items.container = document_model filtered_data_items.sort_key = DataItem.sort_by_date_key for _ in range(4): data_item = DataItem.DataItem( numpy.zeros((16, 16), numpy.uint32)) document_model.append_data_item(data_item) time.sleep(0.01) data_item = document_model.get_invert_new( document_model.display_items[0]) document_model.recompute_all() self.assertEqual(len(filtered_data_items.items), 5) # new data item should be last self.assertEqual( filtered_data_items.items.index(document_model.data_items[4]), 4) self.assertEqual( filtered_data_items.items.index(document_model.data_items[0]), 0) self.assertEqual( list(document_model.data_items[2:5]), filtered_data_items.items[2:]) # rest of list matches
def test_sorted_filtered_model_updates_when_data_item_enters_filter(self): def sort_by_date_key(data_item): return data_item.created document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): filtered_data_items = ListModel.FilteredListModel( items_key="data_items") filtered_data_items.container = document_model filtered_data_items.filter = ListModel.EqFilter("is_live", True) filtered_data_items.sort_key = sort_by_date_key for _ in range(4): data_item = DataItem.DataItem( numpy.zeros((16, 16), numpy.uint32)) document_model.append_data_item(data_item) self.assertEqual(len(filtered_data_items.items), 0) with document_model.data_item_live(document_model.data_items[0]): document_model.data_items[0].data_item_changed_event.fire() self.assertEqual(len(filtered_data_items.items), 1) with document_model.data_item_live( document_model.data_items[2]): document_model.data_items[2].data_item_changed_event.fire() self.assertEqual(len(filtered_data_items.items), 2) self.assertTrue( filtered_data_items.items.index( document_model.data_items[0]) < filtered_data_items .items.index(document_model.data_items[2]))
def test_picking_edge_produces_properly_configured_composite(self): document_model = DocumentModel.DocumentModel() 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) model_display_item = document_model.get_display_item_for_data_item( model_data_item) elemental_mapping_controller.set_current_data_item(model_data_item) elemental_mapping_controller.add_edge( PeriodicTable.ElectronShell(14, 1, 1)) # Si-K edge_bundle = elemental_mapping_controller.build_edge_bundles( document_controller) edge_bundle[0].pick_action() self.__run_until_complete(document_controller) self.assertEqual(2, len(document_model.data_items)) eels_data_item = document_model.data_items[1] self.assertEqual(model_display_item.graphics[0], eels_data_item.source) self.assertEqual(eels_data_item, document_model.data_structures[1].source) self.assertEqual("elemental_mapping_edge_ref", document_model.data_structures[1].structure_type) self.assertEqual( document_model.data_structures[0], document_model.data_structures[1].get_referenced_object( "edge"))
def test_inserting_display_data_channel_updates_display_layer_data_indexes( self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data_item1 = DataItem.DataItem(numpy.zeros((8, ), numpy.uint32)) document_model.append_data_item(data_item1) data_item2 = DataItem.DataItem(numpy.zeros((8, ), numpy.uint32)) document_model.append_data_item(data_item2) data_item3 = DataItem.DataItem(numpy.zeros((8, ), numpy.uint32)) document_model.append_data_item(data_item3) display_item = document_model.get_display_item_for_data_item( data_item1) display_item.append_display_data_channel_for_data_item(data_item2) display_item._set_display_layer_property(0, "ref", "A") display_item._set_display_layer_property(1, "ref", "B") self.assertEqual(2, len(display_item.display_data_channels)) self.assertEqual( 0, display_item.get_display_layer_property(0, "data_index")) self.assertEqual( 1, display_item.get_display_layer_property(1, "data_index")) display_item.insert_display_data_channel( 1, DisplayItem.DisplayDataChannel(data_item=data_item3)) self.assertEqual(3, len(display_item.display_data_channels)) self.assertEqual( 0, display_item.get_display_layer_property(0, "data_index")) self.assertEqual( 2, display_item.get_display_layer_property(1, "data_index")) self.assertEqual("A", display_item.get_display_layer_property(0, "ref")) self.assertEqual("B", display_item.get_display_layer_property(1, "ref"))
def test_target_display_and_data_item(self): document_model = DocumentModel.DocumentModel() document_controller = self.app.create_document_controller(document_model, "library") with contextlib.closing(document_controller): # configure data items data_item1 = DataItem.DataItem(numpy.zeros((8, 8))) document_model.append_data_item(data_item1) data_item2 = DataItem.DataItem(numpy.zeros((8, 8))) document_model.append_data_item(data_item2) display_item1 = document_model.get_display_item_for_data_item(data_item1) display_item2 = document_model.get_display_item_for_data_item(data_item2) # configure workspace workspace_1x1 = document_controller.document_model.workspaces[0] document_controller.workspace_controller.change_workspace(workspace_1x1) display_panel = document_controller.selected_display_panel display_panel.set_display_item(display_item1) api = Facade.get_api("~1.0", "~1.0") library = api.library data_item1_ref = library.data_items[0] data_item2_ref = library.data_items[1] display_item1_ref = library.display_items[0] display_item2_ref = library.display_items[1] # first data item gets displayed because there is an empty display panel. self.assertEqual(data_item1_ref, api.application.document_windows[0].target_data_item) self.assertEqual(display_item1, api.application.document_windows[0].target_display._display_item) self.assertEqual(display_item1_ref, api.application.document_windows[0].target_display)
def test_create_data_item_from_data(self): with create_memory_profile_context() as profile_context: document_model = DocumentModel.DocumentModel(profile=profile_context.create_profile()) document_controller = self.app.create_document_controller(document_model, "library") with contextlib.closing(document_controller): data0 = numpy.arange(64).reshape(8, 8) data_item = DataItem.DataItem(data0) document_model.append_data_item(data_item) api = Facade.get_api("~1.0", "~1.0") library = api.library self.assertEqual(library.data_item_count, 1) self.assertEqual(len(library.data_items), 1) data1 = numpy.arange(128).reshape(16, 8) data2 = numpy.arange(128).reshape(8, 16) data3 = numpy.arange(16).reshape(4, 4) data_item1_ref = library.create_data_item("one") with library.data_ref_for_data_item(data_item1_ref) as data_ref: data_ref.data = data1 data_item2_ref = library.create_data_item_from_data(data2, "two") data_and_metadata = api.create_data_and_metadata(data3) data_item3_ref = library.create_data_item_from_data_and_metadata(data_and_metadata, "three") self.assertEqual(library.data_item_count, 4) self.assertTrue(numpy.array_equal(document_model.data_items[1].data, data1)) self.assertTrue(numpy.array_equal(document_model.data_items[2].data, data2)) self.assertTrue(numpy.array_equal(document_model.data_items[3].data, data3))
def test_deleting_pick_region_also_deletes_pick_composition(self): document_model = DocumentModel.DocumentModel() 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) model_display_item = document_model.get_display_item_for_data_item( model_data_item) elemental_mapping_controller.set_current_data_item(model_data_item) elemental_mapping_controller.add_edge( PeriodicTable.ElectronShell(14, 1, 1)) # Si-K edge_bundle = elemental_mapping_controller.build_edge_bundles( document_controller) edge_bundle[0].pick_action() self.__run_until_complete(document_controller) pick_region = model_display_item.graphics[0] eels_data_item = document_model.data_items[1] self.assertEqual(1, len(document_model.computations)) self.assertEqual(2, len(document_model.data_items)) self.assertEqual(2, len(document_model.data_structures)) model_display_item.remove_graphic(pick_region) self.assertEqual(0, len(document_model.computations)) self.assertEqual(1, len(document_model.data_items)) self.assertEqual(1, len(document_model.data_structures))
def test_filtered_model_updates_when_source_model_has_data_item_that_updates( self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): filtered_data_items = ListModel.FilteredListModel( items_key="data_items") filtered_data_items.container = document_model for _ in range(4): data_item = DataItem.DataItem( numpy.zeros((16, 16), numpy.uint32)) document_model.append_data_item(data_item) self.assertEqual(len(filtered_data_items.items), 4) selection = Selection.IndexedSelection() filtered_data_items2 = ListModel.FilteredListModel( items_key="data_items", container=filtered_data_items, selection=selection) filtered_data_items2.filter = ListModel.EqFilter("is_live", True) self.assertEqual(len(filtered_data_items2.items), 0) with document_model.data_item_live(document_model.data_items[0]): document_model.data_items[0].data_item_changed_event.fire() self.assertEqual(len(filtered_data_items.items), 4) # verify assumption self.assertEqual(len(filtered_data_items2.items), 1) # verify assumption self.assertTrue( document_model.data_items[0] in filtered_data_items2.items)
def test_mapping_edge_produces_properly_configured_map(self): document_model = DocumentModel.DocumentModel() 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) elemental_mapping_controller.add_edge( PeriodicTable.ElectronShell(14, 1, 1)) # Si-K edge_bundle = elemental_mapping_controller.build_edge_bundles( document_controller) edge_bundle[0].map_action() self.__run_until_complete(document_controller) self.assertEqual(2, len(document_model.data_items)) mapped_data_item = document_model.data_items[1] self.assertEqual(model_data_item, mapped_data_item.source) self.assertEqual(1, len(document_model.computations)) self.assertEqual("eels.mapping", document_model.computations[0].processing_id) self.assertEqual(mapped_data_item.dimensional_calibrations, model_data_item.dimensional_calibrations[0:2])
def test_data_item_display_thumbnail_source_produces_data_item_mime_data( self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): data_item = DataItem.DataItem(numpy.random.randn(8, 8)) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_item.display_type = "image" thumbnail_source = DataItemThumbnailWidget.DataItemThumbnailSource( app.ui) finished = threading.Event() def thumbnail_data_changed(data): finished.set() thumbnail_source.on_thumbnail_data_changed = thumbnail_data_changed thumbnail_source.set_display_item(display_item) finished.wait(1.0) finished.clear() finished.wait(1.0) mime_data = app.ui.create_mime_data() valid, thumbnail = thumbnail_source.populate_mime_data_for_drag( mime_data, Geometry.IntSize(64, 64)) self.assertTrue(valid) self.assertIsNotNone(thumbnail) self.assertTrue( mime_data.has_format(MimeTypes.DISPLAY_ITEM_MIME_TYPE))
def test_multiprofile_of_two_maps_builds_two_line_profiles(self): document_model = DocumentModel.DocumentModel() 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) elemental_mapping_controller.add_edge( PeriodicTable.ElectronShell(14, 1, 1)) # Si-K elemental_mapping_controller.add_edge( PeriodicTable.ElectronShell(32, 2, 3)) # Ge-L edge_bundle = elemental_mapping_controller.build_edge_bundles( document_controller) edge_bundle[0].map_action() self.__run_until_complete(document_controller) edge_bundle[1].map_action() self.__run_until_complete(document_controller) self.assertEqual(3, len(document_model.data_items)) elemental_mapping_controller.build_multiprofile( document_controller) self.assertEqual(5, len(document_model.data_items)) self.assertEqual(6, len(document_model.display_items)) composite_display_item = document_model.display_items[3] line_profile1_data_item = document_model.data_items[3] line_profile2_data_item = document_model.data_items[4] self.assertIn(line_profile1_data_item, composite_display_item.data_items) self.assertIn(line_profile2_data_item, composite_display_item.data_items)
def test_connection_establishes_transaction_on_source(self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data_item_src = DataItem.DataItem(numpy.zeros((1000, ))) data_item_dst = DataItem.DataItem(numpy.zeros((1000, ))) document_model.append_data_item(data_item_src) document_model.append_data_item(data_item_dst) display_item_src = document_model.get_display_item_for_data_item( data_item_src) display_item_dst = document_model.get_display_item_for_data_item( data_item_dst) interval_src = Graphics.IntervalGraphic() interval_dst = Graphics.IntervalGraphic() display_item_src.add_graphic(interval_src) display_item_dst.add_graphic(interval_dst) connection = Connection.PropertyConnection(interval_src, "interval", interval_dst, "interval", parent=data_item_dst) document_model.append_connection(connection) # check dependencies with document_model.item_transaction(data_item_dst): self.assertTrue( document_model.is_in_transaction_state(data_item_dst)) self.assertTrue( document_model.is_in_transaction_state(display_item_dst)) self.assertTrue( document_model.is_in_transaction_state(interval_dst)) self.assertTrue( document_model.is_in_transaction_state(interval_src)) self.assertTrue( document_model.is_in_transaction_state(display_item_src)) self.assertEqual(0, document_model.transaction_count)
def test_recorder_state_is_reported_properly(self): app = Application.Application(TestUI.UserInterface(), set_global=False) document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): data_item = DataItem.DataItem(numpy.ones((8, 8))) document_model.append_data_item(data_item) recorder_state_ref = ["unknown"] def recorder_state_changed(recorder_state): recorder_state_ref[0] = recorder_state recorder = RecorderPanel.Recorder(document_controller, data_item) recorder.on_recording_state_changed = recorder_state_changed with contextlib.closing(recorder): with document_model.data_item_live(data_item): count = 4 recorder.start_recording(10, 1, count) for i in range(count): recorder.continue_recording(10 + i + 0.25) data_item.set_data(data_item.data + 1) if i != count - 1: # last iteration it should fall out of transaction state since it is finished self.assertEqual(recorder_state_ref[0], "recording") else: self.assertEqual(recorder_state_ref[0], "stopped") self.assertEqual(recorder_state_ref[0], "stopped")
def test_removing_graphic_as_connection_target_results_in_consistent_state( self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data_item1 = DataItem.DataItem(numpy.zeros((20, ))) data_item2 = DataItem.DataItem(numpy.zeros((20, ))) document_model.append_data_item(data_item1) document_model.append_data_item(data_item2) display_item1 = document_model.get_display_item_for_data_item( data_item1) display_item2 = document_model.get_display_item_for_data_item( data_item2) display_item1.add_graphic(Graphics.IntervalGraphic()) display_item2.add_graphic(Graphics.IntervalGraphic()) graphic1 = display_item1.graphics[0] graphic2 = display_item2.graphics[0] document_model.append_connection( Connection.PropertyConnection(graphic1, "interval", graphic2, "interval", parent=data_item1)) display_item1.remove_graphic(graphic2) # the document must have a consistent state for item transaction to work with document_model.item_transaction(data_item1): pass with document_model.item_transaction(data_item2): pass
def test_data_item_metadata_methods(self): with create_memory_profile_context() as profile_context: document_model = DocumentModel.DocumentModel(profile=profile_context.create_profile()) document_controller = self.app.create_document_controller(document_model, "library") with contextlib.closing(document_controller): data0 = numpy.arange(64).reshape(8, 8) data_item = DataItem.DataItem(data0) data_item.set_intensity_calibration(Calibration.Calibration(0.1, 0.2, "dogs")) data_item.set_dimensional_calibrations([Calibration.Calibration(0.3, 0.4, "cats"), Calibration.Calibration(0.5, 0.6, "cats")]) metadata = {"title": "Dogs eat cats."} data_item.metadata = metadata document_model.append_data_item(data_item) api = Facade.get_api("~1.0", "~1.0") library = api.library data_item_ref = library.data_items[0] self.assertEqual(data_item_ref.intensity_calibration.units, "dogs") self.assertEqual(data_item_ref.dimensional_calibrations[1].units, "cats") self.assertEqual(data_item_ref.metadata, metadata) data_item_ref.set_intensity_calibration(api.create_calibration(0.11, 0.22, "cats")) data_item_ref.set_dimensional_calibrations([api.create_calibration(0.33, 0.44, "mice"), api.create_calibration(0.44, 0.66, "mice")]) metadata2 = {"title": "Cats eat mice."} data_item_ref.set_metadata(metadata2) self.assertAlmostEqual(data_item.intensity_calibration.offset, 0.11) self.assertAlmostEqual(data_item.dimensional_calibrations[0].offset, 0.33) self.assertEqual(data_item.metadata, metadata2)
def load_project(self, profile_context: typing.Optional[ProfileContext]) -> None: """Read project. The profile context is used during testing. """ if not self.project: # the project from the document model project: typing.Optional[Project.Project] = None # create project if it doesn't exist project_storage_system = self.make_storage(profile_context) if project_storage_system: project_storage_system.load_properties() project = Project.Project(project_storage_system) if project: self.__document_model = DocumentModel.DocumentModel( project, storage_cache=self.storage_cache) project.prepare_read_project() # sets up the uuid, used next. self.update_item_context(project) project.about_to_be_inserted(self) self.notify_property_changed( "project" ) # before reading, so document model has a chance to set up project.read_project() else: logging.getLogger("loader").warning( f"Project could not be loaded {self}.")
def test_display_data_panel_reuses_existing_display(self): with create_memory_profile_context() as profile_context: document_model = DocumentModel.DocumentModel(profile=profile_context.create_profile()) document_controller = self.app.create_document_controller(document_model, "library") with contextlib.closing(document_controller): # configure data item data_item = DataItem.DataItem(numpy.arange(64).reshape(8, 8)) document_model.append_data_item(data_item) # configure workspace d = {"type": "splitter", "orientation": "vertical", "splits": [0.5, 0.5], "children": [ {"type": "image", "uuid": "0569ca31-afd7-48bd-ad54-5e2bb9f21102", "identifier": "a", "selected": True}, {"type": "image", "uuid": "acd77f9f-2f6f-4fbf-af5e-94330b73b997", "identifier": "b"}]} workspace_2x1 = document_controller.workspace_controller.new_workspace("2x1", d) document_controller.workspace_controller.change_workspace(workspace_2x1) root_canvas_item = document_controller.workspace_controller.image_row.children[0]._root_canvas_item() root_canvas_item.layout_immediate(Geometry.IntSize(width=640, height=480)) self.assertIsNone(document_controller.workspace_controller.display_panels[0].data_item) self.assertIsNone(document_controller.workspace_controller.display_panels[1].data_item) # test display_data_item api = Facade.get_api("~1.0", "~1.0") library = api.library document_controller_ref = api.application.document_controllers[0] data_item_ref = library.data_items[0] # display data item and verify it is displayed display_panal_ref = document_controller_ref.display_data_item(data_item_ref) self.assertEqual(document_controller.workspace_controller.display_panels[0].data_item, data_item_ref._data_item) self.assertIsNone(document_controller.workspace_controller.display_panels[1].data_item) self.assertEqual(document_controller.workspace_controller.display_panels[0], display_panal_ref._display_panel) # display data item again and verify it is displayed only once display_panal_ref = document_controller_ref.display_data_item(data_item_ref) self.assertEqual(document_controller.workspace_controller.display_panels[0].data_item, data_item_ref._data_item) self.assertIsNone(document_controller.workspace_controller.display_panels[1].data_item) self.assertEqual(document_controller.workspace_controller.display_panels[0], display_panal_ref._display_panel)
def test_cursor_over_4d_data_displays_correctly(self): document_model = DocumentModel.DocumentModel() document_controller = DocumentController.DocumentController( self.app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): display_panel = document_controller.selected_display_panel data = (numpy.random.randn(100, 100, 20, 20) * 100).astype( numpy.int32) data_item = DataItem.DataItem(data) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_item.calibration_style_id = "pixels-top-left" display_item.display_data_channels[0].collection_index = 20, 30 display_panel.set_display_panel_display_item(display_item) header_height = display_panel.header_canvas_item.header_height info_panel = document_controller.find_dock_panel("info-panel") display_panel.root_container.layout_immediate( (1000 + header_height, 1000)) display_panel.display_canvas_item.mouse_entered() display_panel.display_canvas_item.mouse_position_changed( 400, 600, Graphics.NullModifiers()) document_controller.periodic() self.assertEqual(info_panel.label_row_1.text, "Position: 8.0, 12.0, 30.0, 20.0") self.assertEqual(info_panel.label_row_2.text, "Value: {}".format(data[20, 30, 12, 8])) self.assertIsNone(info_panel.label_row_3.text, None) display_panel.display_canvas_item.mouse_exited()
def test_display_data_item_returns_none_if_no_panel_available(self): with create_memory_profile_context() as profile_context: document_model = DocumentModel.DocumentModel(profile=profile_context.create_profile()) document_controller = self.app.create_document_controller(document_model, "library") with contextlib.closing(document_controller): # configure data item data_item1 = DataItem.DataItem(numpy.zeros((8, 8))) document_model.append_data_item(data_item1) data_item2 = DataItem.DataItem(numpy.zeros((8, 8))) document_model.append_data_item(data_item2) # configure workspace workspace_1x1 = document_controller.document_model.workspaces[0] document_controller.workspace_controller.change_workspace(workspace_1x1) display_panel = document_controller.selected_display_panel api = Facade.get_api("~1.0", "~1.0") library = api.library data_item1_ref = library.data_items[0] data_item2_ref = library.data_items[1] # first data item gets displayed because there is an empty display panel. self.assertEqual(api.application.document_windows[0].display_data_item(data_item1_ref)._display_panel, display_panel) # the display is already filled. display panel should be None. self.assertIsNone(api.application.document_windows[0].display_data_item(data_item2_ref)) # redisplay returns existing display panel. self.assertEqual(api.application.document_windows[0].display_data_item(data_item1_ref)._display_panel, display_panel)