Screenshot without margins

examples/export_figure.py

@@ -0,0 +1,110 @@
+"""
+Export Figure
+=============
+
+Display one shapes layer ontop of one image layer using the ``add_shapes`` and
+``add_image`` APIs. When the window is closed it will print the coordinates of
+your shapes.
+
+.. tags:: visualization-advanced
+"""
+
+import numpy as np
+from skimage import data
+
+import napari
+
+# create the viewer and window
+viewer = napari.Viewer()
+
+# add the image
+img_layer = viewer.add_image(data.camera(), name='photographer')
+img_layer.colormap = 'gray'
+
+# create a list of polygons
+polygons = [
+    np.array([[11, 13], [111, 113], [22, 246]]),
+    np.array(
+        [
+            [505, 60],
+            [402, 71],
+            [383, 42],
+            [251, 95],
+            [212, 59],
+            [131, 137],
+            [126, 187],
+            [191, 204],
+            [171, 248],
+            [211, 260],
+            [273, 243],
+            [264, 225],
+            [430, 173],
+            [512, 160],
+        ]
+    ),
+    np.array(
+        [
+            [310, 382],
+            [229, 381],
+            [209, 401],
+            [221, 411],
+            [258, 411],
+            [300, 412],
+            [306, 435],
+            [268, 434],
+            [265, 454],
+            [298, 461],
+            [307, 461],
+            [307, 507],
+            [349, 510],
+            [352, 369],
+            [330, 366],
+            [330, 366],
+        ]
+    ),
+]
+
+# add polygons
+layer = viewer.add_shapes(
+    polygons,
+    shape_type='polygon',
+    edge_width=1,
+    edge_color='coral',
+    face_color='royalblue',
+    name='shapes',
+)
+
+# add an ellipse to the layer
+ellipse = np.array([[59, 222], [110, 289], [170, 243], [119, 176]])
+layer.add(
+    ellipse,
+    shape_type='ellipse',
+    edge_width=5,
+    edge_color='coral',
+    face_color='purple',
+)
+
+labels = layer.to_labels([512, 512])
+labels_layer = viewer.add_labels(labels, name='labels')
+
+points = np.array([[100, 100], [200, 200], [333, 111]])
+size = np.array([10, 20, 20])
+viewer.add_points(points, size=size)
+
+# Export figure and change theme before and after exporting to show that the background canvas margins
+# are not in the exported figure.
+viewer.theme = "light"
+# Optionally for saving the exported figure: viewer.export_figure(path="export_figure.png")
+export_figure = viewer.export_figure()
+scaled_export_figure = viewer.export_figure(scale_factor=5)
+viewer.theme = "dark"
+
+viewer.add_image(export_figure, rgb=True, name='exported_figure')
+viewer.add_image(scaled_export_figure, rgb=True, name='scaled_exported_figure')
+viewer.reset_view()
+
+# from skimage.io import imsave
+# imsave('screenshot.png', screenshot)
+
+if __name__ == '__main__':
+    napari.run()

napari/_app_model/constants/_menus.py

@@ -96,9 +96,10 @@ class MenuGroup:
     PLUGIN_SINGLE_CONTRIBUTIONS = '3_plugin_contributions'
     # File menubar
     OPEN = '1_open'
-    PREFERENCES = '2_preferences'
-    SAVE = '3_save'
-    CLOSE = '4_close'
+    UTIL = '2_util'
+    PREFERENCES = '3_preferences'
+    SAVE = '4_save'
+    CLOSE = '5_close'
 
     class LAYERLIST_CONTEXT:
         CONVERSION = '1_conversion'

napari/_app_model/utils.py

@@ -0,0 +1,95 @@
+from typing import Union
+
+from app_model.expressions import parse_expression
+from app_model.types import Action, MenuItem, SubmenuItem
+
+from napari._app_model import get_app
+from napari._app_model.constants import MenuGroup, MenuId
+
+MenuOrSubmenu = Union[MenuItem, SubmenuItem]
+
+
+def contains_dummy_action(menu_items: list[MenuOrSubmenu]) -> bool:
+    """True if one of the menu_items is the dummy action, otherwise False.
+
+    Parameters
+    ----------
+    menu_items : list[MenuOrSubmenu]
+        menu items belonging to a given menu
+
+    Returns
+    -------
+    bool
+        True if menu_items contains dummy item otherwise false
+    """
+    for item in menu_items:
+        if hasattr(item, 'command') and 'empty_dummy' in item.command.id:
+            return True
+    return False
+
+
+def is_empty_menu(menu_id: str) -> bool:
+    """Return True if the given menu_id is empty, otherwise False
+
+    Parameters
+    ----------
+    menu_id : str
+        id of the menu to check
+
+    Returns
+    -------
+    bool
+        True if the given menu_id is empty, otherwise False
+    """
+    app = get_app()
+    if menu_id not in app.menus:
+        return True
+    if len(app.menus.get_menu(menu_id)) == 0:
+        return True
+    if len(app.menus.get_menu(menu_id)) == 1 and contains_dummy_action(
+        app.menus.get_menu(menu_id)
+    ):
+        return True
+    return False
+
+
+def no_op() -> None:
+    """Fully qualified no-op to use for dummy actions."""
+
+
+def get_dummy_action(menu_id: MenuId) -> tuple[Action, str]:
+    """Return a dummy action to be used for the given menu.
+
+    The part of the menu_id after the final `/` will form
+    a unique id_key used for the action ID and the when
+    expression context key.
+
+    Parameters
+    ----------
+    menu_id: MenuId
+        id of the menu to add the dummy action to
+
+    Returns
+    -------
+    tuple[Action, str]
+        dummy action and the `when` expression context key
+    """
+    # NOTE: this assumes the final word of each contributable
+    # menu path is unique, otherwise, we will clash. Once we
+    # move to using short menu keys, the key itself will be used
+    # here and this will no longer be a concern.
+    id_key = menu_id.split('/')[-1]
+    action = Action(
+        id=f'napari.{id_key}.empty_dummy',
+        title='Empty',
+        callback=no_op,
+        menus=[
+            {
+                'id': menu_id,
+                'group': MenuGroup.NAVIGATION,
+                'when': parse_expression(context_key := f'{id_key}_empty'),
+            }
+        ],
+        enablement=False,
+    )
+    return action, context_key

napari/_qt/_qapp_model/qactions/__init__.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
-from functools import lru_cache
+from functools import lru_cache, partial
 from itertools import chain
+from typing import TYPE_CHECKING
 
 from napari._qt._qapp_model.injection._qprocessors import QPROCESSORS
 from napari._qt._qapp_model.injection._qproviders import QPROVIDERS
 
+if TYPE_CHECKING:
+    from app_model.types import Context
+
 # Submodules should be able to import from most modules, so to
 # avoid circular imports, don't import submodules at the top level here,
 # import them inside the init_qactions function.
@@ -84,3 +88,33 @@ def init_qactions() -> None:
     app.menus.append_menu_items(
         chain(FILE_SUBMENUS, VIEW_SUBMENUS, DEBUG_SUBMENUS, LAYERS_SUBMENUS)
     )
+
+
+def add_dummy_actions(context: Context) -> None:
+    """Register dummy 'Empty' actions for all contributable menus.
+
+    Each action is registered with its own `when` condition, that
+    ensures the action is not visible once the menu is populated.
+    The context key used in the `when` condition is also added to
+    the given `context` and assigned to a partial function that
+    returns True if the menu is empty, and otherwise False.
+
+
+    Parameters
+    ----------
+    context : Context
+        context to store functional keys used in `when` conditions
+    """
+    from napari._app_model import get_app
+    from napari._app_model.constants._menus import MenuId
+    from napari._app_model.utils import get_dummy_action, is_empty_menu
+
+    app = get_app()
+
+    actions = []
+    for menu_id in MenuId.contributables():
+        dummmy_action, context_key = get_dummy_action(menu_id)
+        if dummmy_action.id not in app.commands:
+            actions.append(dummmy_action)
+            context[context_key] = partial(is_empty_menu, menu_id)
+    app.register_actions(actions)

napari/_qt/_qapp_model/qactions/_file.py

@@ -55,7 +55,7 @@
         SubmenuItem(
             submenu=MenuId.FILE_IO_UTILITIES,
             title=trans._('IO Utilities'),
-            group=MenuGroup.OPEN,
+            group=MenuGroup.UTIL,
             order=101,
         ),
     ),
@@ -64,7 +64,7 @@
         SubmenuItem(
             submenu=MenuId.FILE_ACQUIRE,
             title=trans._('Acquire'),
-            group=MenuGroup.OPEN,
+            group=MenuGroup.UTIL,
             order=101,
         ),
     ),

napari/_qt/_tests/test_qt_viewer.py

@@ -264,11 +264,52 @@ def test_screenshot(make_napari_viewer):
 
     # Take screenshot
     with pytest.warns(FutureWarning):
-        screenshot = viewer.window.qt_viewer.screenshot(flash=False)
+        viewer.window.qt_viewer.screenshot(flash=False)
     screenshot = viewer.window.screenshot(flash=False, canvas_only=True)
     assert screenshot.ndim == 3
 
 
+def test_export_figure(make_napari_viewer, tmp_path):
+    viewer = make_napari_viewer()
+
+    np.random.seed(0)
+    # Add image
+    data = np.random.randint(150, 250, size=(250, 250))
+    layer = viewer.add_image(data)
+
+    camera_center = viewer.camera.center
+    camera_zoom = viewer.camera.zoom
+    img = viewer.export_figure(flash=False, path=str(tmp_path / 'img.png'))
+
+    assert viewer.camera.center == camera_center
+    assert viewer.camera.zoom == camera_zoom
+    assert img.shape == (250, 250, 4)
+    assert np.all(img != np.array([0, 0, 0, 0]))
+
+    assert (tmp_path / 'img.png').exists()
+
+    layer.scale = [0.12, 0.24]
+    img = viewer.export_figure(flash=False)
+    # allclose accounts for rounding errors when computing size in hidpi aka
+    # retina displays
+    np.testing.assert_allclose(img.shape, (250, 499, 4), atol=1)
+
+    layer.scale = [0.12, 0.12]
+    img = viewer.export_figure(flash=False)
+    assert img.shape == (250, 250, 4)
+
+    viewer.camera.center = [100, 100]
+    camera_center = viewer.camera.center
+    camera_zoom = viewer.camera.zoom
+    img = viewer.export_figure()
+
+    assert viewer.camera.center == camera_center
+    assert viewer.camera.zoom == camera_zoom
+    assert img.shape == (250, 250, 4)
+    assert np.all(img != np.array([0, 0, 0, 0]))
+    viewer.close()
+
+
 @pytest.mark.skip('new approach')
 def test_screenshot_dialog(make_napari_viewer, tmpdir):
     """Test save screenshot functionality."""