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_line_plot_auto_scales_calibrated_y_axis(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
display_panel = document_controller.selected_display_panel
data = numpy.zeros((10, ))
data[5] = 75
data_item = DataItem.DataItem(data)
data_item.set_xdata(
DataAndMetadata.new_data_and_metadata(
data, Calibration.Calibration(0, 0.5, "x")))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel.set_display_panel_display_item(display_item)
display_panel.layout_immediate((640, 480))
axes = display_panel.display_canvas_item._axes
self.assertAlmostEqual(axes.calibrated_data_min, 0.0)
self.assertAlmostEqual(axes.calibrated_data_max, 40.0)
self.assertAlmostEqual(axes.uncalibrated_data_min, 0.0)
self.assertAlmostEqual(axes.uncalibrated_data_max, 80.0)
def test_display_data_is_2d_for_sequence_of_2d_collection_with_2d_datum(
self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_and_metadata = DataAndMetadata.new_data_and_metadata(
numpy.ones((3, 2, 2, 8, 8), float),
data_descriptor=DataAndMetadata.DataDescriptor(True, 2, 2))
data_item = DataItem.DataItem(numpy.ones((8, ), float))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_item.data_item.set_xdata(data_and_metadata)
display_data_channel = display_item.display_data_channels[0]
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_data_and_metadata.data_shape, (8, 8))
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_data_and_metadata.data_dtype, float)
self.assertEqual(display_data_channel.display_data_shape, (8, 8))
def test_auto_display_limits_works(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data = numpy.empty((100, 100))
data[0:50, :] = 1
data[50:100, :] = 2
data[0, 0] = 0
data[99, 99] = 3
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_panel = document_controller.selected_display_panel
display_panel.set_display_panel_display_item(display_item)
display_panel.display_canvas_item.layout_immediate((640, 480))
display_panel.enter_key_pressed()
low, high = display_item.display_data_channels[0].display_limits
self.assertAlmostEqual(low, 0.0)
self.assertAlmostEqual(high, 3.0)
def test_display_data_is_2d_for_2d_collection_with_2d_datum(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data_and_metadata = DataAndMetadata.new_data_and_metadata(
numpy.ones((2, 2, 8, 8), numpy.float64),
data_descriptor=DataAndMetadata.DataDescriptor(False, 2, 2))
data_item = DataItem.DataItem(numpy.ones((8, ), numpy.float))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_item.data_item.set_xdata(data_and_metadata)
display_data_channel = display_item.display_data_channels[0]
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_data_and_metadata.data_shape, (8, 8))
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_data_and_metadata.data_dtype, numpy.float64)
self.assertEqual(display_data_channel.display_data_shape, (8, 8))
def test_changing_slice_width_updates_data_range(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
d = numpy.zeros((8, 8, 4), numpy.uint32)
for i in range(4):
d[..., i] = i
data_item = DataItem.DataItem(d)
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).data_range, (0, 0))
display_data_channel.slice_center = 2
display_data_channel.slice_width = 4
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).data_range, (6, 6))
def test_create_rgba_sequence_should_work(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data = (numpy.random.rand(4, 64, 64, 3) * 255).astype(numpy.uint8)
data_item = DataItem.new_data_item(
DataAndMetadata.new_data_and_metadata(
data,
data_descriptor=DataAndMetadata.DataDescriptor(True, 0,
2)))
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_data_and_metadata.data_dtype, numpy.uint8)
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_data_and_metadata.data_shape[-1], 3)
def test_line_profile_graphic_is_part_transaction_for_line_plot_intervals(
self):
# this is essential for good performance while dragging intervals on a line plot
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_item = DataItem.DataItem(numpy.zeros((8, 8), numpy.uint32))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel = document_controller.selected_display_panel
display_panel.set_display_panel_display_item(display_item)
line_profile_display_item = document_controller.processing_line_profile(
)
interval_region = Graphics.IntervalGraphic()
line_profile_display_item.add_graphic(interval_region)
self.assertFalse(
document_model.is_in_transaction_state(display_item))
with document_model.item_transaction(interval_region):
self.assertTrue(
document_model.is_in_transaction_state(display_item))
def test_connection_updates_interval_descriptors_when_interval_mutates(
self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
data_item = DataItem.DataItem(numpy.zeros((8, 8), numpy.uint32))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel = document_controller.selected_display_panel
display_panel.set_display_panel_display_item(display_item)
line_profile_display_item = document_controller.processing_line_profile(
)
interval_region = Graphics.IntervalGraphic()
line_profile_display_item.add_graphic(interval_region)
interval = 0.2, 0.3
interval_region.interval = interval
line_profile_graphic = display_item.graphics[0]
interval_descriptors = line_profile_graphic.interval_descriptors
self.assertEqual(len(interval_descriptors), 1)
self.assertEqual(interval_descriptors[0]["interval"], interval)
def test_data_item_to_data_element_produces_json_compatible_dict(self):
data_item = DataItem.DataItem(numpy.zeros((16, 16)))
with contextlib.closing(data_item):
data_item.created = datetime.datetime(2013, 6, 18, 14, 5, 4,
0) # always utc
data_item.timezone = "Europe/Athens"
data_item.timezone_offset = "+0300"
data_item.source_file_path = "/path/to/source/file"
data_item._set_modified(datetime.datetime(2013, 6, 18, 14, 5, 4,
0)) # always utc
data_item.metadata = {
"description": {
"time_zone": {
"tz": "+0300",
"dst": "+60"
}
}
}
data_element = ImportExportManager.create_data_element_from_data_item(
data_item, include_data=False)
json.dumps(data_element)
def test_tool_returns_to_pointer_after_but_not_during_creating_interval(self):
# setup
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
display_panel = document_controller.selected_display_panel
data_item = DataItem.DataItem(numpy.zeros((100,)))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(data_item)
display_panel.set_display_panel_display_item(display_item)
display_panel.display_canvas_item.layout_immediate((800, 1000))
# run test
self.assertEqual(document_controller.tool_mode, "pointer")
for tool_mode in ["interval"]:
document_controller.tool_mode = tool_mode
display_panel.display_canvas_item.simulate_press((100,125))
display_panel.display_canvas_item.simulate_move((100,125))
self.assertEqual(document_controller.tool_mode, tool_mode)
display_panel.display_canvas_item.simulate_move((250,200))
display_panel.display_canvas_item.simulate_release((250,200))
self.assertEqual(document_controller.tool_mode, "pointer")
async def map_new_edge(document_controller, model_data_item, edge) -> None:
document_model = document_controller.document_model
project = document_model._project
map_data_item = DataItem.new_data_item()
map_data_item.title = "{} of {}".format(_("Map"), str(edge.electron_shell))
map_data_item.category = model_data_item.category
map_data_item.source = model_data_item
document_model.append_data_item(map_data_item)
computation = document_model.create_computation()
computation.source = map_data_item
computation.create_input_item(
"spectrum_image_xdata",
Symbolic.make_item(model_data_item, type="xdata"))
computation.create_input_item("fit_interval",
Symbolic.make_item(edge.data_structure),
property_name="fit_interval")
computation.create_input_item("signal_interval",
Symbolic.make_item(edge.data_structure),
property_name="signal_interval")
computation.create_variable(name="atomic_number",
value_type="integral",
value=edge.electron_shell.atomic_number)
computation.create_variable(name="shell_number",
value_type="integral",
value=edge.electron_shell.shell_number)
computation.create_variable(name="subshell_index",
value_type="integral",
value=edge.electron_shell.subshell_index)
computation.processing_id = "eels.mapping"
computation.create_output_item("map", Symbolic.make_item(map_data_item))
document_model.append_computation(computation)
await document_model.compute_immediate(document_controller.event_loop,
computation)
map_display_item = document_model.get_display_item_for_data_item(
map_data_item)
document_controller.show_display_item(map_display_item)
def test_memory_project_opens_with_same_uuid(self):
with create_memory_profile_context() as profile_context:
profile = profile_context.create_profile()
document_model = DocumentModel.DocumentModel(profile=profile)
with contextlib.closing(document_model):
data_item = DataItem.DataItem(
numpy.ones((16, 16), numpy.uint32))
document_model.append_data_item(data_item)
project_uuid = document_model.profile.projects[0].uuid
project_specifier = document_model.profile.projects[
0].item_specifier
profile_context.reset_profile()
document_model = DocumentModel.DocumentModel(
profile=profile_context.create_profile())
with contextlib.closing(document_model):
document_model.profile.add_project_memory(project_uuid)
self.assertEqual(project_uuid,
document_model.profile.projects[1].uuid)
self.assertEqual(
document_model.profile.projects[1],
document_model.profile.persistent_object_context.
get_registered_object(project_specifier))
def test_changing_data_updates_display_range(self):
document_model = DocumentModel.DocumentModel()
with contextlib.closing(document_model):
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]
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_range, (0, 15))
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).data_range, (0, 15))
display_item.data_item.set_data(irow // 2 + 4)
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_range, (4, 11))
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).data_range, (4, 11))
def test_line_plot_auto_scales_calibrated_y_axis(self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
display_panel = document_controller.selected_display_panel
data = numpy.zeros((10, ))
data[5] = 75
data_item = DataItem.DataItem(data)
data_item.set_xdata(
DataAndMetadata.new_data_and_metadata(
data, Calibration.Calibration(0, 0.5, "x")))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel.set_display_panel_display_item(display_item)
display_panel.display_canvas_item.layout_immediate((640, 480))
axes = display_panel.display_canvas_item._axes
self.assertAlmostEqual(axes.calibrated_data_min, 0.0)
self.assertAlmostEqual(axes.calibrated_data_max, 40.0)
self.assertAlmostEqual(axes.uncalibrated_data_min, 0.0)
self.assertAlmostEqual(axes.uncalibrated_data_max, 80.0)
async def map_new_edge(document_controller, model_data_item, edge) -> None:
document_model = document_controller.document_model
map_data_item = DataItem.new_data_item()
map_data_item.title = "{} of {}".format(_("Map"), str(edge.electron_shell))
map_data_item.category = model_data_item.category
map_data_item.source = model_data_item
document_model.append_data_item(map_data_item)
computation = document_model.create_computation()
computation.source = map_data_item
computation.create_object("spectrum_image_xdata", document_model.get_object_specifier(model_data_item, "xdata"))
computation.create_input("fit_interval", document_model.get_object_specifier(edge.data_structure), "fit_interval")
computation.create_input("signal_interval", document_model.get_object_specifier(edge.data_structure), "signal_interval")
computation.processing_id = "eels.mapping"
computation.create_result("map", document_model.get_object_specifier(map_data_item))
document_model.append_computation(computation)
await document_model.compute_immediate(document_controller.event_loop, computation)
map_display_item = document_model.get_display_item_for_data_item(map_data_item)
document_controller.show_display_item(map_display_item)
def test_pointer_tool_makes_intervals_when_other_intervals_exist(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
display_panel = document_controller.selected_display_panel
data_item = DataItem.DataItem(numpy.zeros((100, )))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
region = Graphics.IntervalGraphic()
region.start = 0.9
region.end = 0.95
display_item.add_graphic(region)
display_panel.set_display_panel_display_item(display_item)
display_panel.display_canvas_item.layout_immediate((640, 480))
# test
document_controller.tool_mode = "pointer"
display_panel.display_canvas_item.simulate_drag((240, 160),
(240, 480))
interval_region = display_item.graphics[1]
self.assertEqual(interval_region.type, "interval-graphic")
self.assertTrue(interval_region.end > interval_region.start)
def test_changing_region_properties_change_drawn_graphic_properties(self):
document_model = DocumentModel.DocumentModel()
with contextlib.closing(document_model):
data_item = DataItem.DataItem(numpy.zeros((8, 8), numpy.uint32))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
regions = list()
regions.append(Graphics.PointGraphic())
regions.append(Graphics.RectangleGraphic())
regions.append(Graphics.EllipseGraphic())
regions.append(Graphics.LineGraphic())
regions.append(Graphics.IntervalGraphic())
regions.append(Graphics.ChannelGraphic())
for region in regions:
region.label = "label"
region.is_position_locked = False
region.is_shape_locked = False
region.is_bounds_constrained = False
display_item.add_graphic(region)
drawn_graphic = display_item.graphics[-1]
self.assertEqual(region.label, drawn_graphic.label)
self.assertEqual(region.is_position_locked,
drawn_graphic.is_position_locked)
self.assertEqual(region.is_shape_locked,
drawn_graphic.is_shape_locked)
self.assertEqual(region.is_bounds_constrained,
drawn_graphic.is_bounds_constrained)
region.label = "label2"
region.is_position_locked = True
region.is_shape_locked = True
region.is_bounds_constrained = True
self.assertEqual(region.label, drawn_graphic.label)
self.assertEqual(region.is_position_locked,
drawn_graphic.is_position_locked)
self.assertEqual(region.is_shape_locked,
drawn_graphic.is_shape_locked)
self.assertEqual(region.is_bounds_constrained,
drawn_graphic.is_bounds_constrained)
def setUp(self):
TestContext.begin_leaks()
self.test_context = TestContext.create_memory_context()
self.document_controller = self.test_context.create_document_controller_with_application(
)
self.document_model = self.document_controller.document_model
data = numpy.full((10, 10), 200, dtype=numpy.uint32)
data[5, 5] = 650
self.data_item = DataItem.DataItem(data)
self.document_model.append_data_item(self.data_item)
self.display_item = self.document_model.get_display_item_for_data_item(
self.data_item)
self.histogram_panel = HistogramPanel.HistogramPanel(
self.document_controller,
"histogram-panel",
None,
debounce=False,
sample=False)
self.histogram_canvas_item = self.histogram_panel._histogram_widget._histogram_canvas_item
self.document_controller.show_display_item(self.display_item)
self.histogram_canvas_item.update_layout((0, 0), (80, 300),
immediate=True)
def test_connection_updates_interval_descriptors_when_interval_mutates(
self):
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data_item = DataItem.DataItem(numpy.zeros((8, 8), numpy.uint32))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel = document_controller.selected_display_panel
display_panel.set_display_panel_display_item(display_item)
line_profile_display_item = document_controller.processing_line_profile(
)
interval_region = Graphics.IntervalGraphic()
line_profile_display_item.add_graphic(interval_region)
interval = 0.2, 0.3
interval_region.interval = interval
line_profile_graphic = display_item.graphics[0]
interval_descriptors = line_profile_graphic.interval_descriptors
self.assertEqual(len(interval_descriptors), 1)
self.assertEqual(interval_descriptors[0]["interval"], interval)
def test_changing_data_updates_display_range(self):
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_document_model()
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]
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_range, (0, 15))
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).data_range, (0, 15))
display_item.data_item.set_data(irow // 2 + 4)
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).display_range, (4, 11))
self.assertEqual(
display_data_channel.get_calculated_display_values(
True).data_range, (4, 11))
def setUp(self):
self.app = Application.Application(TestUI.UserInterface(),
set_global=False)
self.document_model = DocumentModel.DocumentModel()
self.document_controller = DocumentController.DocumentController(
self.app.ui, self.document_model, workspace_id="library")
data = numpy.full((10, 10), 200, dtype=numpy.uint32)
data[5, 5] = 650
self.data_item = DataItem.DataItem(data)
self.document_model.append_data_item(self.data_item)
self.display_item = self.document_model.get_display_item_for_data_item(
self.data_item)
self.histogram_panel = HistogramPanel.HistogramPanel(
self.document_controller,
"histogram-panel",
None,
debounce=False,
sample=False)
self.histogram_canvas_item = self.histogram_panel._histogram_widget._histogram_canvas_item
self.document_controller.show_display_item(self.display_item)
self.histogram_canvas_item.update_layout((0, 0), (80, 300),
immediate=True)
def test_recorder_records_live_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.ones((8, 8)))
document_model.append_data_item(data_item)
recorder = RecorderPanel.Recorder(document_controller, data_item)
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)
recorder.continue_recording(10 + i + 0.75)
data_item.set_data(data_item.data + 1)
self.assertEqual(2, len(document_model.data_items))
recorded_data_item = document_model.data_items[1]
self.assertTrue(recorded_data_item.xdata.is_sequence)
self.assertEqual((4, 8, 8),
recorded_data_item.xdata.dimensional_shape)
def test_line_profile_graphic_is_part_transaction_for_line_plot_intervals(
self):
# this is essential for good performance while dragging intervals on a line plot
document_model = DocumentModel.DocumentModel()
document_controller = DocumentController.DocumentController(
self.app.ui, document_model, workspace_id="library")
with contextlib.closing(document_controller):
data_item = DataItem.DataItem(numpy.zeros((8, 8), numpy.uint32))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel = document_controller.selected_display_panel
display_panel.set_display_panel_display_item(display_item)
line_profile_display_item = document_controller.processing_line_profile(
)
interval_region = Graphics.IntervalGraphic()
line_profile_display_item.add_graphic(interval_region)
self.assertFalse(
document_model.is_in_transaction_state(display_item))
with document_model.item_transaction(interval_region):
self.assertTrue(
document_model.is_in_transaction_state(display_item))
def test_recorder_state_is_reported_properly(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
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_data_item_display_thumbnail_source_produces_data_item_mime_data(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
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(document_controller.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 = document_controller.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_cursor_over_4d_data_displays_correctly(self):
with TestContext.create_memory_context() as test_context:
document_controller = test_context.create_document_controller()
document_model = document_controller.document_model
display_panel = document_controller.selected_display_panel
data = (numpy.random.randn(100, 100, 20, 20) * 100).astype(numpy.int32)
data_item = DataItem.DataItem(data)
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(data_item)
display_item.calibration_style_id = "pixels-top-left"
display_item.display_data_channels[0].collection_index = 20, 30
display_panel.set_display_panel_display_item(display_item)
header_height = display_panel.header_canvas_item.header_height
info_panel = document_controller.find_dock_panel("info-panel")
display_panel.root_container.layout_immediate((1000 + header_height, 1000))
display_panel.display_canvas_item.mouse_entered()
display_panel.display_canvas_item.mouse_position_changed(400, 600, Graphics.NullModifiers())
document_controller.periodic()
self.assertEqual(info_panel.label_row_1.text, "Position: 8.0, 12.0, 30.0, 20.0")
self.assertEqual(info_panel.label_row_2.text, "Value: {}".format(data[20, 30, 12, 8]))
self.assertIsNone(info_panel.label_row_3.text, None)
display_panel.display_canvas_item.mouse_exited()
def test_build_table_with_calibrated_1d_data(self):
with TestContext.create_memory_context() as test_context:
calibration = Calibration.Calibration(1.0, 2.0, "nm")
document_model = test_context.create_document_model()
data_item = DataItem.DataItem(numpy.array([1.1, 1.2, 1.3, 1.4]))
data_item.set_dimensional_calibration(0, calibration)
data_item.set_intensity_calibration(
Calibration.Calibration(0, 1, "e"))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_item._set_display_layer_property(0, "label", "W")
headers, data = ImportExportManager.build_table(display_item)
self.assertEqual(2, len(headers))
self.assertEqual(2, len(data))
self.assertEqual("X (nm)", headers[0])
self.assertEqual("W (e)", headers[1])
self.assertTrue(
numpy.array_equal(
calibration.convert_to_calibrated_value(
numpy.arange(0, data_item.data.shape[0])), data[0]))
self.assertTrue(numpy.array_equal(data_item.data, data[1]))
def test_random_filtered_model_updates(self):
list_model = ListModel.ListModel("data_items")
filtered_data_items = ListModel.FilteredListModel(
items_key="data_items")
filtered_data_items.container = list_model
data_items = list()
cc = 30
for _ in range(cc):
data_item = DataItem.DataItem(numpy.zeros((16, 16), numpy.uint32))
list_model.insert_item(0, data_item)
data_items.append(data_item)
selection = Selection.IndexedSelection()
filtered_data_items2 = ListModel.FilteredListModel(
items_key="data_items",
container=filtered_data_items,
selection=selection)
import random
for xx in range(10):
c1 = [n for n in range(cc)]
c2 = [n for n in range(cc) if random.randint(0, 100) > 20]
random.shuffle(c1)
random.shuffle(c2)
def is_live_filter(data_item):
return data_items.index(data_item) in c1
def is_live_filter2(data_item):
return data_items.index(data_item) in c2
filtered_data_items.sort_key = lambda x: data_items.index(x)
with filtered_data_items.changes():
filtered_data_items.filter = ListModel.PredicateFilter(
is_live_filter)
filtered_data_items.filter = ListModel.PredicateFilter(
is_live_filter2)
self.assertEqual(
set(c2),
set([data_items.index(d) for d in filtered_data_items2.items]))
def __ensure_drift_log_data_item(self) -> None:
# must be called on main thread
if not self.__data_item:
drift_data_frame = self.__drift_tracker.drift_data_frame
delta_nm_data: numpy.typing.NDArray[typing.Any] = numpy.vstack([
drift_data_frame[0], drift_data_frame[1],
numpy.hypot(drift_data_frame[0], drift_data_frame[1])
])
data_item = DataItem.DataItem(delta_nm_data)
data_item.title = f"Drift Log"
self.__document_model.append_data_item(data_item)
display_item = self.__document_model.get_display_item_for_data_item(
data_item)
if display_item:
display_item.display_type = "line_plot"
display_item.append_display_data_channel_for_data_item(
data_item)
display_item.append_display_data_channel_for_data_item(
data_item)
display_item._set_display_layer_properties(
0,
label=_("x"),
stroke_color=display_item.get_display_layer_property(
0, "fill_color"),
fill_color=None)
display_item._set_display_layer_properties(
1,
label=_("y"),
stroke_color=display_item.get_display_layer_property(
1, "fill_color"),
fill_color=None)
display_item._set_display_layer_properties(
2,
label=_("m"),
stroke_color=display_item.get_display_layer_property(
2, "fill_color"),
fill_color=None)
self.__data_item = data_item
