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
async def explore_edges(self, document_controller):
document_model = document_controller.document_model
model_data_item = self.__model_data_item
model_display_item = document_model.get_display_item_for_data_item(
model_data_item)
pick_region = Graphics.RectangleGraphic()
pick_region.size = min(1 / 16,
16 / model_data_item.dimensional_shape[0]), min(
1 / 16,
16 / model_data_item.dimensional_shape[1])
pick_region.label = _("Explore")
model_display_item.add_graphic(pick_region)
pick_data_item = document_model.get_pick_region_new(
model_display_item,
model_display_item.data_item,
pick_region=pick_region)
if pick_data_item:
explore_interval = Graphics.IntervalGraphic()
explore_interval.interval = 0.4, 0.6
explore_interval.label = _("Explore")
explore_interval.graphic_id = "explore"
pick_data_item.source = model_data_item
pick_display_item = document_model.get_display_item_for_data_item(
pick_data_item)
pick_display_item.add_graphic(explore_interval)
document_controller.show_display_item(pick_display_item)
await self.__document_model.compute_immediate(
document_controller.event_loop,
document_model.get_data_item_computation(pick_data_item)
) # need the data to make connect_explorer_interval work; so do this here. ugh.
self.__connect_explorer_interval(document_model, pick_data_item)
def test_connection_establishes_transaction_on_source(self):
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_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_specific_parts_take_priority_when_another_selected(self):
# setup
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((10, 10)))
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)
header_height = display_panel.header_canvas_item.header_height
display_panel.root_container.layout_immediate(
(1000 + header_height, 1000))
# run test
rect_region1 = Graphics.RectangleGraphic()
rect_region1.bounds = (0.2, 0.2), (0.4, 0.4)
rect_region2 = Graphics.RectangleGraphic()
rect_region2.bounds = (0.4, 0.4), (0.4, 0.4)
display_item.add_graphic(rect_region1)
display_item.add_graphic(rect_region2)
display_item = document_model.get_display_item_for_data_item(
data_item)
# clicking on line should select it
display_panel.display_canvas_item.simulate_click((700, 700))
self.assertEqual(display_item.graphic_selection.indexes, set(
(1, )))
display_panel.display_canvas_item.simulate_click((600, 200))
self.assertEqual(display_item.graphic_selection.indexes, set(
(0, )))
def test_hit_testing_occurs_same_as_draw_order(self):
# draw order occurs from 0 -> n
# setup
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((10, 10)))
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)
header_height = display_panel.header_canvas_item.header_height
display_panel.root_container.layout_immediate(
(1000 + header_height, 1000))
# run test
rect_region1 = Graphics.RectangleGraphic()
rect_region1.bounds = (0.2, 0.2), (0.4, 0.4)
rect_region2 = Graphics.RectangleGraphic()
rect_region2.bounds = (0.4, 0.4), (0.4, 0.4)
display_item.add_graphic(rect_region1)
display_item.add_graphic(rect_region2)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel.display_canvas_item.simulate_click((500, 500))
self.assertEqual(display_item.graphic_selection.indexes, set(
(1, )))
def test_specific_parts_take_priority_over_all_part(self):
# setup
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((10, 10)))
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)
header_height = display_panel.header_canvas_item.header_height
display_panel.root_container.layout_immediate(
(1000 + header_height, 1000))
# run test
rect_region = Graphics.RectangleGraphic()
rect_region.bounds = (0.25, 0.25), (0.5, 0.5)
line_region = Graphics.LineGraphic()
line_region.start = (0.5, 0.5)
line_region.end = (0.5, 1.0)
# draws line, then rect
display_item.add_graphic(line_region)
display_item.add_graphic(rect_region)
display_item = document_model.get_display_item_for_data_item(
data_item)
# clicking on line should select it
display_panel.display_canvas_item.simulate_click((500, 600))
self.assertEqual(display_item.graphic_selection.indexes, set(
(0, )))
def test_removing_graphic_as_connection_target_results_in_consistent_state(
self):
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_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(graphic2).close()
# 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_selected_item_takes_priority_over_all_part(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((10, 10)))
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)
header_height = display_panel.header_canvas_item.header_height
display_panel.root_container.layout_immediate(
(1000 + header_height, 1000))
# run test
rect_region = Graphics.RectangleGraphic()
rect_region.bounds = (0.25, 0.25), (0.5, 0.5)
line_region = Graphics.LineGraphic()
line_region.start = (0.0, 1.0)
line_region.end = (0.75, 0.25)
# draws line, then rect
display_item.add_graphic(line_region)
display_item.add_graphic(rect_region)
display_item = document_model.get_display_item_for_data_item(
data_item)
display_panel.display_canvas_item.simulate_click((50, 950))
self.assertEqual(display_item.graphic_selection.indexes, set(
(0, )))
display_panel.display_canvas_item.simulate_click((500, 500))
self.assertEqual(display_item.graphic_selection.indexes, set(
(0, )))
def test_connection_establishes_transaction_on_parallel_source_connection(
self):
document_model = DocumentModel.DocumentModel()
with contextlib.closing(document_model):
data_item_src = DataItem.DataItem(numpy.zeros((1000, )))
data_item_dst1 = DataItem.DataItem(numpy.zeros((1000, )))
data_item_dst2 = DataItem.DataItem(numpy.zeros((1000, )))
document_model.append_data_item(data_item_src)
document_model.append_data_item(data_item_dst1)
document_model.append_data_item(data_item_dst2)
display_item_src = document_model.get_display_item_for_data_item(
data_item_src)
display_item_dst1 = document_model.get_display_item_for_data_item(
data_item_dst1)
display_item_dst2 = document_model.get_display_item_for_data_item(
data_item_dst2)
interval_src = Graphics.IntervalGraphic()
interval_dst1 = Graphics.IntervalGraphic()
interval_dst2 = Graphics.IntervalGraphic()
display_item_src.add_graphic(interval_src)
display_item_dst1.add_graphic(interval_dst1)
display_item_dst2.add_graphic(interval_dst2)
connection1 = Connection.PropertyConnection(interval_src,
"interval",
interval_dst1,
"interval",
parent=data_item_dst1)
connection2 = Connection.PropertyConnection(interval_src,
"interval",
interval_dst2,
"interval",
parent=data_item_dst2)
document_model.append_connection(connection1)
document_model.append_connection(connection2)
# check dependencies
with document_model.item_transaction(data_item_dst1):
self.assertTrue(
document_model.is_in_transaction_state(data_item_dst1))
self.assertTrue(
document_model.is_in_transaction_state(interval_dst1))
self.assertTrue(
document_model.is_in_transaction_state(interval_src))
self.assertTrue(
document_model.is_in_transaction_state(
display_item_dst2)) # from graphic
self.assertTrue(
document_model.is_in_transaction_state(interval_dst2))
self.assertTrue(
document_model.is_in_transaction_state(
display_item_src)) # from graphic
self.assertEqual(0, document_model.transaction_count)
def test_connection_establishes_transaction_on_target_data_structure(self):
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_document_model()
data_item1 = DataItem.DataItem(numpy.zeros((2, 2)))
data_item2 = DataItem.DataItem(numpy.zeros((2, 2)))
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)
interval1 = Graphics.IntervalGraphic()
interval2 = Graphics.IntervalGraphic()
display_item1.add_graphic(interval1)
display_item2.add_graphic(interval2)
data_struct1 = document_model.create_data_structure()
data_struct2 = document_model.create_data_structure()
data_struct1.set_property_value("x_interval", (0.5, 0.1))
data_struct2.set_property_value("x_interval", (0.5, 0.2))
document_model.append_data_structure(data_struct1)
document_model.append_data_structure(data_struct2)
connection1 = Connection.PropertyConnection(data_struct1,
"x_interval",
interval1,
"interval",
parent=data_item1)
connection2 = Connection.PropertyConnection(interval2,
"interval",
data_struct2,
"x_interval",
parent=data_item2)
document_model.append_connection(connection1)
document_model.append_connection(connection2)
with document_model.item_transaction(data_item1):
self.assertTrue(
document_model.is_in_transaction_state(data_item1))
self.assertTrue(
document_model.is_in_transaction_state(display_item1))
self.assertTrue(
document_model.is_in_transaction_state(data_struct1))
with document_model.item_transaction(data_item2):
self.assertTrue(
document_model.is_in_transaction_state(data_item2))
self.assertTrue(
document_model.is_in_transaction_state(display_item2))
self.assertTrue(
document_model.is_in_transaction_state(data_struct2))
self.assertEqual(0, document_model.transaction_count)
def show_probe_graphic(self):
if not self.graphic:
self.graphic = Graphics.PointGraphic()
self.graphic.graphic_id = "probe"
self.graphic.label = _("Probe")
self.graphic.position = self.probe_position_value.value
self.graphic.is_bounds_constrained = True
self.display.add_graphic(self.graphic)
self.binding = PropertyToGraphicBinding(self.probe_position_value,
"value", self.graphic,
"position")
def graphic_removed():
self.hide_probe_graphic()
# next make sure all other probe graphics get hidden so that setting the probe_position_value
# doesn't set graphics positions to None
self.hide_probe_graphics_fn()
self.probe_position_value.value = None
def display_removed():
self.hide_probe_graphic()
self.remove_region_graphic_event_listener = self.graphic.about_to_be_removed_event.listen(
graphic_removed)
self.display_about_to_be_removed_listener = self.display.about_to_be_removed_event.listen(
display_removed)
def test_target_region_stream_stops_updates_when_region_deselected(self):
target_display_item_stream = HistogramPanel.TargetDisplayItemStream(
self.document_controller).add_ref()
target_region_stream = HistogramPanel.TargetRegionStream(
target_display_item_stream).add_ref()
try:
count = 0
def new_region(graphic: Graphics.Graphic) -> None:
nonlocal count
count += 1
with contextlib.closing(
target_region_stream.value_stream.listen(
new_region)) as listener:
rect_region = Graphics.RectangleGraphic()
rect_region.bounds = (0.2, 0.2), (0.2, 0.2)
self.display_item.add_graphic(rect_region)
self.display_item.graphic_selection.set(0) # count 1
rect_region.bounds = (0.2, 0.2), (0.2, 0.2) # count 2
self.display_item.graphic_selection.clear() # count 2
count0 = count
rect_region.bounds = (0.2, 0.2), (0.2, 0.2) # count 2
rect_region.bounds = (0.2, 0.2), (0.2, 0.2) # count 2
rect_region.bounds = (0.2, 0.2), (0.2, 0.2) # count 2
self.assertEqual(count0, count)
finally:
target_region_stream.remove_ref()
target_display_item_stream.remove_ref()
def _create_graphic(self) -> Graphics.LineGraphic:
line_scan_graphic = Graphics.LineGraphic()
line_scan_graphic.graphic_id = "line_scan"
line_scan_graphic.label = _("Line Scan")
line_scan_graphic.vector = self.__stem_controller.line_scan_vector
line_scan_graphic.is_bounds_constrained = True
return line_scan_graphic
def test_background_subtraction_computation_is_removed_when_background_removed(
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)
interval = Graphics.IntervalGraphic()
interval.start = 0.2
interval.end = 0.3
display_item.add_graphic(interval)
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(document_model.data_items[-2])
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_changing_graphic_does_not_notify_display_values_change(self):
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_document_model()
# this is used to update the inspector
data_item = DataItem.DataItem(numpy.zeros((4, 4)))
document_model.append_data_item(data_item)
display_item = document_model.get_display_item_for_data_item(
data_item)
graphic = Graphics.RectangleGraphic()
display_item.add_graphic(graphic)
display_data_channel = display_item.display_data_channels[0]
class Observer:
def __init__(self) -> None:
self.count = 0
def next_calculated_display_values(self):
self.count += 1
o = Observer()
with contextlib.closing(
display_data_channel.
add_calculated_display_values_listener(
o.next_calculated_display_values)):
display_data_channel.get_calculated_display_values()
self.assertEqual(
1, o.count) # 1 will be sent when adding the listener
with display_item.display_item_changes():
graphic.bounds = ((0, 0), (1, 1))
self.assertEqual(
1, o.count) # 1 will be sent when adding the listener
def add_line_profile(data_item,
document_controller,
display_panel_id,
midpoint=0.5,
integration_width=.25):
logging.debug("midpoint: {:.4f}".format(midpoint))
logging.debug("width: {:.4f}".format(integration_width))
# next, line profile through center of crop
# please don't copy this bad example code!
crop_region = Graphics.RectangleGraphic()
crop_region.center = (midpoint, 0.5)
crop_region.size = (integration_width, 1)
crop_region.is_bounds_constrained = True
display_specifier = DataItem.DisplaySpecifier.from_data_item(
data_item)
display_specifier.display.add_graphic(crop_region)
eels_data_item = document_controller.document_model.get_projection_new(
data_item, crop_region)
if eels_data_item:
eels_data_item.title = _("EELS Summed")
document_controller.display_data_item(
DataItem.DisplaySpecifier.from_data_item(eels_data_item))
document_controller.workspace_controller.display_data_item_in_display_panel(
eels_data_item, display_panel_id)
def test_histogram_updates_when_crop_region_changes(self):
data = numpy.zeros((100, 100))
data[20:40, 20:40] = 1
data[40:60, 40:60] = 2
self.display_item.data_item.set_data(data)
self.histogram_panel._statistics_widget._statistics_func_value_model._run_until_complete(
)
stats1_text = self.histogram_panel._statistics_widget._stats1_property.value
stats2_text = self.histogram_panel._statistics_widget._stats2_property.value
rect_region = Graphics.RectangleGraphic()
rect_region.bounds = (0.2, 0.2), (0.2, 0.2)
self.display_item.add_graphic(rect_region)
self.display_item.graphic_selection.set(0)
self.histogram_panel._statistics_widget._statistics_func_value_model._run_until_complete(
)
stats1_new_text = self.histogram_panel._statistics_widget._stats1_property.value
stats2_new_text = self.histogram_panel._statistics_widget._stats2_property.value
self.assertNotEqual(stats1_text, stats1_new_text)
self.assertNotEqual(stats2_text, stats2_new_text)
rect_region.bounds = (0.4, 0.4), (0.2, 0.2)
self.histogram_panel._statistics_widget._statistics_func_value_model._run_until_complete(
)
self.assertNotEqual(
stats1_new_text,
self.histogram_panel._statistics_widget._stats1_property.value)
self.assertNotEqual(
stats2_new_text,
self.histogram_panel._statistics_widget._stats2_property.value)
def test_cursor_over_4d_data_displays_correctly(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.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_cursor_over_3d_data_displays_correct_ordering_of_indices(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.ones((100, 100, 20)))
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_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(
500, 500, Graphics.NullModifiers())
self.assertTrue(
self.__wait_for_cursor_position_text(
document_controller, info_panel,
"Position: 0.0, 50.0, 50.0"))
self.assertEqual(info_panel.label_row_2.text, "Value: 1")
self.assertIsNone(info_panel.label_row_3.text, None)
display_panel.display_canvas_item.mouse_exited()
def test_nudge_interval(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.1
region.end = 0.9
display_item.add_graphic(region)
display_panel.set_display_panel_display_item(display_item)
display_panel.display_canvas_item.layout_immediate((640, 480))
display_panel.display_canvas_item.prepare_display() # force layout
# test
document_controller.tool_mode = "pointer"
display_panel.display_canvas_item.simulate_click((240, 320))
display_panel.display_canvas_item.key_pressed(
self.app.ui.create_key_by_id("left"))
interval_region = display_item.graphics[0]
self.assertTrue(interval_region.start < 0.1)
self.assertTrue(interval_region.end < 0.9)
self.assertAlmostEqual(interval_region.end - interval_region.start,
0.8)
def test_cursor_over_2d_data_sequence_displays_correct_ordering_of_indices(
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_and_metadata = DataAndMetadata.new_data_and_metadata(
numpy.ones((20, 100, 100), numpy.float64),
data_descriptor=DataAndMetadata.DataDescriptor(True, 0, 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_item.display_data_channels[0].sequence_index = 4
display_item.calibration_style_id = "pixels-top-left"
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()
document_controller.periodic()
display_panel.display_canvas_item.mouse_position_changed(
500, 500, Graphics.NullModifiers())
document_controller.periodic()
self.assertEqual(info_panel.label_row_1.text,
"Position: 50.0, 50.0, 4.0")
self.assertEqual(info_panel.label_row_2.text, "Value: 1")
self.assertIsNone(info_panel.label_row_3.text, None)
display_panel.display_canvas_item.mouse_exited()
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_connection_updates_source_when_target_changes(self):
# setup document model
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_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)
display_data_channel_3d = display_item_3d.display_data_channels[0]
connection = Connection.PropertyConnection(display_data_channel_3d,
"slice_center",
interval,
"start",
parent=data_item_1d)
document_model.append_connection(connection)
# test to see if connection updates target when source changes
interval.start = 9
self.assertEqual(display_data_channel_3d.slice_center, 9)
def test_connection_to_graphic_puts_data_item_under_transaction(self):
with TestContext.create_memory_context() as test_context:
document_model = test_context.create_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 _create_graphic(self) -> Graphics.PointGraphic:
graphic = Graphics.PointGraphic()
graphic.graphic_id = "probe"
graphic.label = _("Probe")
graphic.position = self.__stem_controller.probe_position
graphic.is_bounds_constrained = True
graphic.color = "#F80"
return graphic
def _create_graphic(self) -> Graphics.RectangleGraphic:
subscan_graphic = Graphics.RectangleGraphic()
subscan_graphic.graphic_id = "subscan"
subscan_graphic.label = _("Subscan")
subscan_graphic.bounds = tuple(typing.cast(Geometry.FloatRect, self.__stem_controller.subscan_region))
subscan_graphic.rotation = self.__stem_controller.subscan_rotation
subscan_graphic.is_bounds_constrained = True
return subscan_graphic
def test_region_mask_wedge(self):
rect_graphic = Graphics.WedgeGraphic()
rect_graphic.angle_interval = -math.pi / 2, 0
mask = rect_graphic.get_mask((1000, 1000))
self.assertTrue(mask.data[600, 600]) # bottom right
self.assertFalse(mask.data[600, 400]) # top right
self.assertTrue(mask.data[400, 400]) # top left
self.assertFalse(mask.data[400, 600]) # bottom left
def test_histogram_statistics_with_zero_array(self):
self.display_item.data_item.set_data(
numpy.ones((10, 10), dtype=numpy.uint32))
rect_region = Graphics.RectangleGraphic()
rect_region.bounds = (10000, 10000), (1, 1)
self.display_item.add_graphic(rect_region)
self.display_item.graphic_selection.set(0)
self.histogram_panel._histogram_widget._recompute()
def test_region_mask_wedge(self):
wedge_graphic = Graphics.WedgeGraphic()
with contextlib.closing(wedge_graphic):
wedge_graphic.angle_interval = -math.pi / 2, 0
mask = wedge_graphic.get_mask((1000, 1000))
self.assertTrue(mask.data[600, 600]) # bottom right
self.assertFalse(mask.data[600, 400]) # top right
self.assertTrue(mask.data[400, 400]) # top left
self.assertFalse(mask.data[400, 600]) # bottom left
async def __update_subscan_region(self):
subscan_region = self.__update_subscan_region_value
with self.__last_data_items_lock:
scan_data_items = self.__scan_data_items
if subscan_region:
# create subscan graphics for each scan data item if it doesn't exist
if not self.__subscan_graphic_trackers:
for scan_data_item in scan_data_items:
display_item = self.__document_model.get_display_item_for_data_item(
scan_data_item)
if display_item:
subscan_graphic = Graphics.RectangleGraphic()
subscan_graphic.graphic_id = "subscan"
subscan_graphic.label = _("Subscan")
subscan_graphic.bounds = subscan_region
subscan_graphic.is_bounds_constrained = True
def subscan_graphic_property_changed(
subscan_graphic, name):
if name == "bounds":
self.__subscan_region_value.value = subscan_graphic.bounds
subscan_graphic_property_changed_listener = subscan_graphic.property_changed_event.listen(
functools.partial(subscan_graphic_property_changed,
subscan_graphic))
def graphic_removed(subscan_graphic):
self.__remove_one_subscan_graphic(subscan_graphic)
self.__subscan_state_model.value = SubscanState.DISABLED
self.__subscan_region_value.value = None
def display_removed(subscan_graphic):
self.__remove_one_subscan_graphic(subscan_graphic)
remove_region_graphic_event_listener = subscan_graphic.about_to_be_removed_event.listen(
functools.partial(graphic_removed,
subscan_graphic))
display_about_to_be_removed_listener = display_item.about_to_be_removed_event.listen(
functools.partial(display_removed,
subscan_graphic))
self.__subscan_graphic_trackers.append(
(subscan_graphic,
subscan_graphic_property_changed_listener,
remove_region_graphic_event_listener,
display_about_to_be_removed_listener))
display_item.add_graphic(subscan_graphic)
# apply new value to any existing subscan graphics
for subscan_graphic, l1, l2, l3 in self.__subscan_graphic_trackers:
subscan_graphic.bounds = subscan_region
else:
# remove any graphics
for subscan_graphic, subscan_graphic_property_changed_listener, remove_region_graphic_event_listener, display_about_to_be_removed_listener in self.__subscan_graphic_trackers:
subscan_graphic_property_changed_listener.close()
remove_region_graphic_event_listener.close()
display_about_to_be_removed_listener.close()
subscan_graphic.container.remove_graphic(subscan_graphic)
self.__subscan_graphic_trackers = list()
