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)
