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)