def test_create_data_item_from_data_as_sequence(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller_with_application()
document_model = document_controller.document_model
api = Facade.get_api("~1.0", "~1.0")
library = api.library
data_and_metadata = DataAndMetadata.new_data_and_metadata(numpy.zeros((8, 4, 5)), data_descriptor=DataAndMetadata.DataDescriptor(True, 0, 2))
data_item = library.create_data_item_from_data_and_metadata(data_and_metadata, "three")
self.assertEqual(library.data_item_count, 1)
self.assertTrue(document_model.data_items[0].is_sequence)
def test_create_empty_data_item_and_set_xdata_copies_data(self):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application()
document_model = document_controller.document_model
api = Facade.get_api("~1.0", "~1.0")
data = numpy.random.randn(2, 2)
data_item = api.library.create_data_item()
data_item.xdata = api.create_data_and_metadata_from_data(data)
data[:, :] = numpy.random.randn(2, 2)
self.assertFalse(numpy.array_equal(data, data_item.data))
def test_library_and_data_items_can_be_compared_for_equality(self):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application()
document_model = document_controller.document_model
data_item1 = DataItem.DataItem(numpy.zeros((2, 2)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((2, 2)))
document_model.append_data_item(data_item2)
api = Facade.get_api("~1.0", "~1.0")
self.assertEqual(api.library, api.library)
self.assertEqual(api.library.data_items, api.library.data_items)
def test_affine_transform_image_for_4d_data(self):
data_descriptors = [
DataAndMetadata.DataDescriptor(True, 1, 2),
DataAndMetadata.DataDescriptor(False, 2, 2),
DataAndMetadata.DataDescriptor(True, 2, 1)
]
for data_descriptor in data_descriptors:
with self.subTest(data_descriptor=data_descriptor):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application(
)
document_model = document_controller.document_model
data = numpy.zeros((5, 5, 5, 5))
if data_descriptor.collection_dimension_count == 2 and not data_descriptor.is_sequence:
data[2:-2, 1:-1] = 1
elif data_descriptor.collection_dimension_count == 2 and data_descriptor.is_sequence:
data[:, 2:-2, 1:-1] = 1
else:
data[..., 2:-2, 1:-1] = 1
xdata = DataAndMetadata.new_data_and_metadata(
data, data_descriptor=data_descriptor)
api = Facade.get_api("~1.0", "~1.0")
data_item = api.library.create_data_item_from_data_and_metadata(
xdata)
document_controller.selection.set(0)
document_controller.selected_display_panel = None # use the document controller selection
affine_transform = AffineTransformImage.AffineTransformMenuItem(
api)
affine_transform.menu_item_execute(
api.application.document_controllers[0])
document_controller.periodic()
# Can't convince the computation to update when changing the graphics, so just check that it got executed
vector_a = data_item.graphics[0]
vector_b = data_item.graphics[1]
# # Rotate by 90 degrees
vector_a.end = (0.75, 0.5)
vector_b.end = (0.5, 0.75)
# # Update computation
document_controller.periodic()
DocumentModel.evaluate_data(document_model.computations[0])
self.assertEqual(len(data_item.graphics), 2)
self.assertEqual(api.library.data_item_count, 2)
if data_descriptor.collection_dimension_count == 2 and not data_descriptor.is_sequence:
self.assertTrue(
numpy.allclose(document_model.data_items[1].data,
numpy.rot90(data)))
elif data_descriptor.collection_dimension_count == 2 and data_descriptor.is_sequence:
self.assertTrue(
numpy.allclose(document_model.data_items[1].data,
numpy.rot90(data, axes=(1, 2))))
else:
self.assertTrue(
numpy.allclose(document_model.data_items[1].data,
numpy.rot90(data, axes=(2, 3))))
def test_create_empty_data_item_and_set_xdata_copies_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):
api = Facade.get_api("~1.0", "~1.0")
data = numpy.random.randn(2, 2)
data_item = api.library.create_data_item()
data_item.xdata = api.create_data_and_metadata_from_data(data)
data[:, :] = numpy.random.randn(2, 2)
self.assertFalse(numpy.array_equal(data, data_item.data))
def test_get_data_item_by_uuid_in_second_project_succeeds(self):
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 = self.app.create_document_controller(document_model, "library")
with contextlib.closing(document_controller):
# configure data items
data_item = DataItem.DataItem(numpy.zeros((8, 8)))
document_model.append_data_item(data_item, project=profile.projects[1])
api = Facade.get_api("~1.0", "~1.0")
self.assertEqual(data_item, api.library.get_data_item_by_uuid(data_item.uuid)._data_item)
def test_target_data_item_returns_none_if_panel_is_empty(self):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application()
document_model = document_controller.document_model
# configure workspace
workspace_1x1 = document_controller.project.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")
# the display is already filled. display panel should be None.
self.assertIsNone(api.application.document_windows[0].target_data_item)
def test_facade_frame_parameter_methods(self):
document_controller, document_model, hardware_source, state_controller = self.__setup_hardware_source()
with contextlib.closing(document_controller), contextlib.closing(state_controller):
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(hardware_source.hardware_source_id, "~1.0")
hardware_source_facade.get_default_frame_parameters()
frame_parameters = hardware_source_facade.get_frame_parameters()
record_frame_parameters = hardware_source_facade.get_record_frame_parameters()
profile_frame_parameters = hardware_source_facade.get_frame_parameters_for_profile_by_index(0)
hardware_source_facade.set_frame_parameters(frame_parameters)
hardware_source_facade.set_record_frame_parameters(record_frame_parameters)
hardware_source_facade.set_frame_parameters_for_profile_by_index(0, profile_frame_parameters)
def test_register_library_computation_and_execute_it(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller_with_application()
document_model = document_controller.document_model
api = Facade.get_api("~1.0")
api.register_computation_type("computation1", self.Computation1)
data = numpy.random.randn(2, 2)
data_item = api.library.create_data_item()
data_item.set_data(data)
api.library.create_computation("computation1", inputs={"src": data_item}, outputs={"graphic": None})
document_model.recompute_all()
self.assertEqual(len(data_item.graphics), 1)
def test_register_library_computation_and_execute_it(self):
document_model = DocumentModel.DocumentModel()
document_controller = self.app.create_document_controller(document_model, "library")
with contextlib.closing(document_controller):
api = Facade.get_api("~1.0")
api.register_computation_type("computation1", self.Computation1)
data = numpy.random.randn(2, 2)
data_item = api.library.create_data_item()
data_item.set_data(data)
api.library.create_computation("computation1", inputs={"src": data_item}, outputs={"graphic": None})
document_model.recompute_all()
self.assertEqual(len(data_item.graphics), 1)
def test_library_and_data_items_can_be_compared_for_equality(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):
data_item1 = DataItem.DataItem(numpy.zeros((2, 2)))
document_model.append_data_item(data_item1)
data_item2 = DataItem.DataItem(numpy.zeros((2, 2)))
document_model.append_data_item(data_item2)
api = Facade.get_api("~1.0", "~1.0")
self.assertEqual(api.library, api.library)
self.assertEqual(api.library.data_items, api.library.data_items)
def test_graphic_is_invalid_if_source_is_removed(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller_with_application()
document_model = document_controller.document_model
api = Facade.get_api("~1.0", "~1.0")
library = api.library
data_item = library.create_data_item_from_data(numpy.zeros((16, 16)))
self.assertEqual(len(Facade.Graphic.instances), 0)
graphic = data_item.add_point_region(10, 10)
self.assertEqual(len(Facade.Graphic.instances), 1)
graphic = None
self.assertEqual(len(Facade.Graphic.instances), 0)
def test_metadata_functions(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller_with_application()
api = Facade.get_api("~1.0", "~1.0")
self.assertFalse(api.library.has_library_value("stem.session.instrument"))
self.assertIsNone(api.library.get_library_value("stem.session.instrument"))
api.library.set_library_value("stem.session.instrument", "em")
self.assertTrue(api.library.has_library_value("stem.session.instrument"))
self.assertEqual("em", api.library.get_library_value("stem.session.instrument"))
api.library.delete_library_value("stem.session.instrument")
self.assertFalse(api.library.has_library_value("stem.session.instrument"))
self.assertIsNone(api.library.get_library_value("stem.session.instrument"))
def test_graphic_is_invalid_if_source_is_removed(self):
document_model = DocumentModel.DocumentModel()
document_controller = self.app.create_document_controller(document_model, "library")
with contextlib.closing(document_controller):
api = Facade.get_api("~1.0", "~1.0")
library = api.library
data_item = library.create_data_item_from_data(numpy.zeros((16, 16)))
self.assertEqual(len(Facade.Graphic.instances), 0)
graphic = data_item.add_point_region(10, 10)
self.assertEqual(len(Facade.Graphic.instances), 1)
graphic = None
self.assertEqual(len(Facade.Graphic.instances), 0)
def test_facade_record_task_cancel(self):
document_controller, document_model, hardware_source, state_controller = self.__setup_hardware_source()
with contextlib.closing(document_controller), contextlib.closing(state_controller):
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(hardware_source.hardware_source_id, "~1.0")
record_task = hardware_source_facade.create_record_task()
with contextlib.closing(record_task):
time.sleep(self.exposure * 0.1)
record_task.cancel()
start_time = time.time()
while hardware_source.is_recording:
time.sleep(self.exposure * 0.01)
self.assertTrue(time.time() - start_time < TIMEOUT)
self.assertFalse(hardware_source_facade.is_recording)
def test_facade_view_task(self):
document_controller, document_model, hardware_source, state_controller = self.__setup_hardware_source()
with contextlib.closing(document_controller), contextlib.closing(state_controller):
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(hardware_source.hardware_source_id, "~1.0")
view_task = hardware_source_facade.create_view_task()
with contextlib.closing(view_task):
data_and_metadata_list1 = view_task.grab_next_to_finish()
self.assertTrue(hardware_source_facade.is_playing)
data_and_metadata_list2 = view_task.grab_immediate()
data_and_metadata_list3 = view_task.grab_next_to_start()
self.assertIsNotNone(data_and_metadata_list1[0].data)
self.assertIsNotNone(data_and_metadata_list2[0].data)
self.assertIsNotNone(data_and_metadata_list3[0].data)
def test_facade_record_task(self):
document_controller, document_model, hardware_source, state_controller = self.__setup_hardware_source()
with contextlib.closing(document_controller), contextlib.closing(state_controller):
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(hardware_source.hardware_source_id, "~1.0")
record_task = hardware_source_facade.create_record_task()
with contextlib.closing(record_task):
data_and_metadata_list = record_task.grab()
data_and_metadata = data_and_metadata_list[0]
self.assertIsNotNone(data_and_metadata.data)
# changing the ccd1010 (stopping) takes 600ms+ so wait until it stops recording
start_time = time.time()
while hardware_source.is_recording:
time.sleep(self.exposure * 0.01)
self.assertTrue(time.time() - start_time < TIMEOUT)
self.assertFalse(hardware_source_facade.is_recording)
def test_data_item_regions(self):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application(
)
document_model = document_controller.document_model
data_item = DataItem.DataItem(numpy.arange(64).reshape(8, 8))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
data_item_1d = DataItem.DataItem(numpy.arange(32).reshape(32))
document_model.append_data_item(data_item_1d)
display_item_1d = document_model.get_display_item_for_data_item(
data_item_1d)
api = Facade.get_api("~1.0", "~1.0")
library = api.library
data_item_ref = library.data_items[0]
data_item_1d_ref = library.data_items[1]
r0 = data_item_ref.add_point_region(0.1, 0.2)
r1 = data_item_ref.add_rectangle_region(0.3, 0.4, 0.5, 0.6)
r2 = data_item_ref.add_ellipse_region(0.3, 0.4, 0.5, 0.6)
r3 = data_item_ref.add_line_region(0.1, 0.2, 0.3, 0.4)
r4 = data_item_1d_ref.add_interval_region(0.1, 0.2)
r5 = data_item_1d_ref.add_channel_region(0.5)
r0.label = "One"
self.assertEqual(r0.type, "point-region")
self.assertEqual(r1.type, "rectangle-region")
self.assertEqual(r2.type, "ellipse-region")
self.assertEqual(r3.type, "line-region")
self.assertEqual(r4.type, "interval-region")
self.assertEqual(r5.type, "channel-region")
r4.set_property("end", 0.3)
self.assertAlmostEqual(r4.get_property("end"), 0.3)
self.assertEqual(len(display_item.graphics), 4)
self.assertEqual(len(display_item_1d.graphics), 2)
self.assertIsInstance(display_item.graphics[0],
Graphics.PointGraphic)
self.assertIsInstance(display_item.graphics[1],
Graphics.RectangleGraphic)
self.assertIsInstance(display_item.graphics[2],
Graphics.EllipseGraphic)
self.assertIsInstance(display_item.graphics[3],
Graphics.LineGraphic)
self.assertIsInstance(display_item_1d.graphics[0],
Graphics.IntervalGraphic)
self.assertIsInstance(display_item_1d.graphics[1],
Graphics.ChannelGraphic)
def test_facade_record(self):
document_controller, document_model, hardware_source, state_controller = self.__setup_hardware_source()
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(hardware_source.hardware_source_id, "~1.0")
with contextlib.closing(document_controller), contextlib.closing(state_controller):
self.assertFalse(hardware_source.is_recording) # we know this works
self.assertFalse(hardware_source_facade.is_recording)
hardware_source_facade.start_recording()
time.sleep(self.exposure * 0.5)
self.assertTrue(hardware_source.is_recording) # we know this works
self.assertTrue(hardware_source_facade.is_recording)
start_time = time.time()
while hardware_source.is_recording:
time.sleep(self.exposure * 0.1)
self.assertTrue(time.time() - start_time < TIMEOUT)
self.assertFalse(hardware_source.is_recording) # we know this works
self.assertFalse(hardware_source_facade.is_recording)
def test_facade_grab_data(self):
document_controller, document_model, hardware_source, state_controller = self.__setup_hardware_source()
with contextlib.closing(document_controller), contextlib.closing(state_controller):
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(hardware_source.hardware_source_id, "~1.0")
hardware_source_facade.start_playing()
try:
time.sleep(self.exposure * 0.5)
data_and_metadata_list1 = hardware_source_facade.grab_next_to_finish()
data_and_metadata_list2 = hardware_source_facade.grab_next_to_start()
self.assertIsNotNone(data_and_metadata_list1[0].data)
self.assertIsNotNone(data_and_metadata_list2[0].data)
finally:
hardware_source_facade.stop_playing()
start_time = time.time()
while hardware_source.is_playing:
time.sleep(self.exposure * 0.1)
self.assertTrue(time.time() - start_time < TIMEOUT)
def test_data_item_data_methods(self):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application()
document_model = document_controller.document_model
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
data1 = numpy.arange(128).reshape(16, 8)
data_item_ref = library.data_items[0]
self.assertTrue(numpy.array_equal(data_item_ref.data, data0))
data_item_ref.set_data(data1)
self.assertTrue(numpy.array_equal(data_item_ref.data, data1))
data2 = numpy.arange(128).reshape(8, 16)
data_item_ref.set_data_and_metadata(api.create_data_and_metadata(data2))
self.assertTrue(numpy.array_equal(data_item_ref.data, data2))
self.assertTrue(numpy.array_equal(data_item_ref.data_and_metadata.data, data2))
def test_library_computation_change_object_data_source_input(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller_with_application()
document_model = document_controller.document_model
api = Facade.get_api("~1.0")
api.register_computation_type("computation4", self.Computation4)
data1 = numpy.ones((2, 2)) * 1
data_item1 = api.library.create_data_item()
data_item1.set_data(data1)
data2 = numpy.ones((2, 2)) * 2
data_item2 = api.library.create_data_item()
data_item2.set_data(data2)
dst_data_item = api.library.create_data_item()
computation = api.library.create_computation("computation4", inputs={"src": {"object": data_item1, "type": "data_source"}}, outputs={"dst": dst_data_item})
document_model.recompute_all()
self.assertTrue(numpy.array_equal(dst_data_item.data, data1))
computation.set_input_value("src", {"object": data_item2, "type": "data_source"})
document_model.recompute_all()
self.assertTrue(numpy.array_equal(dst_data_item.data, data2))
def test_data_item_data_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)
document_model.append_data_item(data_item)
api = Facade.get_api("~1.0", "~1.0")
library = api.library
data1 = numpy.arange(128).reshape(16, 8)
data_item_ref = library.data_items[0]
self.assertTrue(numpy.array_equal(data_item_ref.data, data0))
data_item_ref.set_data(data1)
self.assertTrue(numpy.array_equal(data_item_ref.data, data1))
data2 = numpy.arange(128).reshape(8, 16)
data_item_ref.set_data_and_metadata(api.create_data_and_metadata(data2))
self.assertTrue(numpy.array_equal(data_item_ref.data, data2))
self.assertTrue(numpy.array_equal(data_item_ref.data_and_metadata.data, data2))
def test_background_subtraction_computation_is_removed_when_last_interval_deleted(
self):
with TestContext.create_memory_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application(
)
document_model = document_controller.document_model
data_item = self.__create_spectrum()
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
interval1 = Graphics.IntervalGraphic()
interval1.start = 0.2
interval1.end = 0.3
display_item.add_graphic(interval1)
interval2 = Graphics.IntervalGraphic()
interval2.start = 0.4
interval2.end = 0.5
display_item.add_graphic(interval2)
api = Facade.get_api("~1.0", "~1.0")
library = api.library
api_data_item = library.data_items[0]
api_display_item = api_data_item.display
api_intervals = copy.copy(api_display_item.graphics)
BackgroundSubtraction.add_background_subtraction_computation(
api, library, api_display_item, api_data_item, api_intervals)
self.assertEqual(3, len(document_model.data_items))
self.assertEqual(3, len(document_model.display_items))
self.assertEqual(3, len(display_item.data_items))
self.assertEqual(3, len(display_item.display_layers))
self.assertEqual(1, len(document_model.data_structures))
self.assertEqual(1, len(document_model.computations))
document_model.remove_data_item(interval2)
self.assertEqual(3, len(document_model.data_items))
self.assertEqual(3, len(document_model.display_items))
self.assertEqual(3, len(display_item.data_items))
self.assertEqual(3, len(display_item.display_layers))
self.assertEqual(1, len(document_model.data_structures))
self.assertEqual(1, len(document_model.computations))
document_model.remove_data_item(interval1)
self.assertEqual(1, len(document_model.data_items))
self.assertEqual(1, len(document_model.display_items))
self.assertEqual(0, len(document_model.data_structures))
self.assertEqual(0, len(document_model.computations))
def test_library_computation_change_object_data_source_input(self):
document_model = DocumentModel.DocumentModel()
document_controller = self.app.create_document_controller(document_model, "library")
with contextlib.closing(document_controller):
api = Facade.get_api("~1.0")
api.register_computation_type("computation4", self.Computation4)
data1 = numpy.ones((2, 2)) * 1
data_item1 = api.library.create_data_item()
data_item1.set_data(data1)
data2 = numpy.ones((2, 2)) * 2
data_item2 = api.library.create_data_item()
data_item2.set_data(data2)
dst_data_item = api.library.create_data_item()
computation = api.library.create_computation("computation4", inputs={"src": {"object": data_item1, "type": "data_source"}}, outputs={"dst": dst_data_item})
document_model.recompute_all()
self.assertTrue(numpy.array_equal(dst_data_item.data, data1))
computation.set_input_value("src", {"object": data_item2, "type": "data_source"})
document_model.recompute_all()
self.assertTrue(numpy.array_equal(dst_data_item.data, data2))
def test_facade_abort_record(self):
document_controller, document_model, hardware_source, state_controller = self.__setup_hardware_source()
with contextlib.closing(document_controller), contextlib.closing(state_controller):
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(hardware_source.hardware_source_id, "~1.0")
self.assertFalse(hardware_source.is_recording) # we know this works
self.assertFalse(hardware_source_facade.is_recording)
# hardware_source.stages_per_frame = 5
hardware_source_facade.start_recording()
time.sleep(self.exposure * 0.1)
self.assertTrue(hardware_source.is_recording) # we know this works
self.assertTrue(hardware_source_facade.is_recording)
hardware_source_facade.abort_recording()
start_time = time.time()
while hardware_source.is_recording:
time.sleep(self.exposure * 0.01)
self.assertTrue(time.time() - start_time < TIMEOUT)
# TODO: figure out a way to test whether abort actually aborts or just stops
self.assertFalse(hardware_source.is_recording) # we know this works
self.assertFalse(hardware_source_facade.is_recording)
def test_facade_record_data_with_immediate_close(self):
with self._make_scan_context() as scan_context:
document_controller, document_model, hardware_source, scan_state_controller = scan_context.objects
api = Facade.get_api("~1.0", "~1.0")
hardware_source_facade = api.get_hardware_source_by_id(
hardware_source.hardware_source_id, "~1.0")
scan_frame_parameters = hardware_source_facade.get_frame_parameters_for_profile_by_index(
2)
scan_frame_parameters[
"external_clock_wait_time_ms"] = 20000 # int(camera_frame_parameters["exposure_ms"] * 1.5)
scan_frame_parameters["external_clock_mode"] = 1
scan_frame_parameters["ac_line_sync"] = False
scan_frame_parameters["ac_frame_sync"] = False
# this tests an issue for a race condition where thread for record task isn't started before the task
# is canceled, resulting in the close waiting for the thread and the thread waiting for the acquire.
# this reduces the problem, but it's still possible that during external sync, the acquisition starts
# before being canceled and must timeout.
with contextlib.closing(
hardware_source_facade.create_record_task(
scan_frame_parameters)) as task:
pass
def test_display_data_item_returns_none_if_no_panel_available(self):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application()
document_model = document_controller.document_model
# 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.project.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_controller = profile_context.create_document_controller_with_application()
document_model = document_controller.document_model
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_data_item_metadata_methods(self):
with create_memory_profile_context() as profile_context:
document_controller = profile_context.create_document_controller_with_application()
document_model = document_controller.document_model
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)
