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)