def test_changing_sequence_index_updates_display_range(self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data = numpy.zeros((3, 8, 8)) data[1, ...] = 1 data[2, ...] = 2 xdata = DataAndMetadata.new_data_and_metadata( data, data_descriptor=DataAndMetadata.DataDescriptor(True, 0, 2)) data_item = DataItem.new_data_item(xdata) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_data_channel = display_item.display_data_channels[0] self.assertEqual( display_data_channel.get_calculated_display_values( True).display_range, (0, 0)) self.assertEqual( display_data_channel.get_calculated_display_values( True).data_range, (0, 0)) display_data_channel.sequence_index = 1 self.assertEqual( display_data_channel.get_calculated_display_values( True).display_range, (1, 1)) self.assertEqual( display_data_channel.get_calculated_display_values( True).data_range, (1, 1))
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_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_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_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_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)
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_collection_index_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, 3, 3) data_and_metadata = DataAndMetadata.new_data_and_metadata( d, data_descriptor=DataAndMetadata.DataDescriptor(False, 2, 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_data_channel = display_item.display_data_channels[0] display_data_channel.collection_index = 3, 3 display_data = display_data_channel.get_calculated_display_values( True).display_data_and_metadata.data self.assertTrue(numpy.array_equal(display_data, d[3, 3, ...])) d2 = numpy.random.randn(2, 2, 3, 3) data_and_metadata2 = DataAndMetadata.new_data_and_metadata( d2, data_descriptor=DataAndMetadata.DataDescriptor(False, 2, 2)) display_item.data_item.set_xdata(data_and_metadata2) display_data2 = display_data_channel.get_calculated_display_values( True).display_data_and_metadata.data self.assertTrue(numpy.array_equal(display_data2, d2[1, 1, ...]))
def test_exception_during_calculate_display_values_recovers_gracefully( 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, 3, 3) data_and_metadata = DataAndMetadata.new_data_and_metadata( d, data_descriptor=DataAndMetadata.DataDescriptor(False, 2, 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) def next_calculated_display_values(): pass display_data_channel = display_item.display_data_channels[0] listener = display_data_channel.add_calculated_display_values_listener( next_calculated_display_values) with contextlib.closing(listener): display_data = display_data_channel.get_calculated_display_values( True).display_data_and_metadata.data # now run the test display_data_channel.collection_index = 2, 2 # should trigger the thread display_data = display_data_channel.get_calculated_display_values( True).display_data_and_metadata.data display_data_channel.collection_index = 2, 2 display_data = display_data_channel.get_calculated_display_values( True).display_data_and_metadata.data self.assertTrue(numpy.array_equal(display_data, d[2, 2, ...]))
def test_reset_display_limits_on_complex_data_gives_reasonable_results( self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data = numpy.ones((16, 16), numpy.complex64) re, im = numpy.meshgrid(numpy.linspace(-0.8, 2.1, 16), numpy.linspace(-1.4, 1.4, 16)) data[:, :] = re + 1j * im 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_data_channel = display_item.display_data_channels[0] display_data_channel.reset_display_limits() # the display limit should never be less than the display data minimum display_range = display_data_channel.get_calculated_display_values( True).display_range self.assertLess( numpy.amin( display_data_channel.get_calculated_display_values( True).display_data_and_metadata.data), display_range[0]) self.assertAlmostEqual( numpy.amax( display_data_channel.get_calculated_display_values( True).display_data_and_metadata.data), display_range[1])
def test_display_range_with_partial_display_limits_is_complete(self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data_item = DataItem.DataItem(numpy.zeros((2, 2), numpy.float64)) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_data_channel = display_item.display_data_channels[0] data_item.set_data(numpy.array(range(1, 5))) display_data_channel.display_limits = None self.assertEqual( display_data_channel.get_calculated_display_values( True).display_range, (1.0, 4.0)) display_data_channel.display_limits = (2.0, None) self.assertEqual( display_data_channel.get_calculated_display_values( True).display_range, (2.0, 4.0)) display_data_channel.display_limits = (None, 3.0) self.assertEqual( display_data_channel.get_calculated_display_values( True).display_range, (1.0, 3.0)) display_data_channel.display_limits = (2.0, 3.0) self.assertEqual( display_data_channel.get_calculated_display_values( True).display_range, (2.0, 3.0))
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_data_item_setting_slice_center_validates_when_invalid(self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): data_item = DataItem.DataItem(numpy.ones((4, 4, 16), numpy.float64)) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_data_channel = display_item.display_data_channels[0] display_data_channel.slice_center = 8 display_data_channel.slice_width = 8 display_data_channel.slice_center = 0 self.assertEqual(display_data_channel.slice_center, 4) display_data_channel.slice_center = 3 self.assertEqual(display_data_channel.slice_center, 4) display_data_channel.slice_center = -1 self.assertEqual(display_data_channel.slice_center, 4) display_data_channel.slice_center = 5.5 self.assertEqual(display_data_channel.slice_center, 5) display_data_channel.slice_center = 12 self.assertEqual(display_data_channel.slice_center, 12) display_data_channel.slice_center = 13 self.assertEqual(display_data_channel.slice_center, 12) display_data_channel.slice_center = 20 self.assertEqual(display_data_channel.slice_center, 12)
def test_changing_data_notifies_data_and_display_range_change(self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): # this is used to update the inspector irow, icol = numpy.ogrid[0:16, 0:16] data_item = DataItem.DataItem(icol) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_data_channel = display_item.display_data_channels[0] class Observer(object): def __init__(self): self.data_range = None self.display_range = None def next_calculated_display_values(self): calculated_display_values = display_data_channel.get_calculated_display_values( True) self.display_range = calculated_display_values.display_range self.data_range = calculated_display_values.data_range o = Observer() listener = display_data_channel.add_calculated_display_values_listener( o.next_calculated_display_values) # wait for initial display values to update. with contextlib.closing(listener): display_item.data_item.set_data(irow // 2 + 4) self.assertEqual(o.data_range, (4, 11)) self.assertEqual(o.display_range, (4, 11))
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 test_computation_works_with_inputs_in_different_projects(self): # create two data items in different projects. select the two items in the data panel # and create a computation from the two inputs. compute and make sure no errors occur. with create_memory_profile_context() as profile_context: profile = profile_context.create_profile() profile.add_project_memory() document_model = DocumentModel.DocumentModel(profile=profile) document_controller = DocumentController.DocumentController( self.app.ui, document_model, workspace_id="library") with contextlib.closing(document_controller): data1 = ((numpy.abs(numpy.random.randn(8, 8)) + 1) * 10).astype(numpy.uint32) data2 = ((numpy.abs(numpy.random.randn(8, 8)) + 1) * 10).astype(numpy.uint32) data_item1 = DataItem.DataItem(data1) data_item2 = DataItem.DataItem(data2) document_model.append_data_item( data_item1, project=document_model.profile.projects[0]) document_model.append_data_item( data_item2, project=document_model.profile.projects[1]) display_item1 = document_model.get_display_item_for_data_item( data_item1) display_item2 = document_model.get_display_item_for_data_item( data_item2) document_controller.select_display_items_in_data_panel( [display_item1, display_item2]) self.assertEqual(2, len(document_model.data_items)) document_controller.perform_action( "processing.cross_correlate") self.assertEqual(3, len(document_model.data_items)) document_model.recompute_all() self.assertIsNone(document_model.computations[0].error_text)
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_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_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_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_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_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_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_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_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_updates_target_when_source_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) connection = Connection.PropertyConnection( display_item_3d.display_data_channels[0], "slice_center", interval, "start", parent=data_item_1d) document_model.append_connection(connection) # test to see if connection updates target when source changes display_item_3d.display_data_channels[0].slice_center = 12 self.assertEqual(interval.start, 12)
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_source_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(graphic1) # 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_display_data_of_3d_data_set_has_correct_shape_and_calibrations( self): document_model = DocumentModel.DocumentModel() with contextlib.closing(document_model): intensity_calibration = Calibration.Calibration(units="I") dim0_calibration = Calibration.Calibration(units="A") dim1_calibration = Calibration.Calibration(units="B") dim2_calibration = Calibration.Calibration(units="C") data_item = DataItem.DataItem( numpy.zeros((16, 16, 64), numpy.float64)) data_item.set_intensity_calibration(intensity_calibration) data_item.set_dimensional_calibrations( [dim0_calibration, dim1_calibration, dim2_calibration]) document_model.append_data_item(data_item) display_item = document_model.get_display_item_for_data_item( data_item) display_data_and_metadata = display_item.display_data_channels[ 0].get_calculated_display_values( True).display_data_and_metadata self.assertEqual(display_data_and_metadata.dimensional_shape, (16, 16)) self.assertEqual(display_data_and_metadata.intensity_calibration, intensity_calibration) self.assertEqual( display_data_and_metadata.dimensional_calibrations[0], dim0_calibration) self.assertEqual( display_data_and_metadata.dimensional_calibrations[1], dim1_calibration)