Screenshot without margins

napari/_qt/_tests/test_qt_viewer.py

@@ -254,11 +254,28 @@ 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_screenshot_fit_to_data(make_napari_viewer):
+    viewer = make_napari_viewer()
+
+    np.random.seed(0)
+    # Add image
+    data = np.random.randint(150, 250, size=(250, 250))
+    viewer.add_image(data)
+    img = viewer.screenshot(flash=False, fit_to_data=True)
+    assert img.shape == (250, 250, 4)
+    assert np.all(img != np.array([0, 0, 0, 1]))
+
+    # TODO: check why this fails in the testing suite but not when testing with scratch script with same example.
+    img = viewer.screenshot(fit_to_data=True, scale=8)
+    assert img.shape == (250 * 8, 250 * 8, 4)
+    assert np.all(img != np.array([0, 0, 0, 1]))
+
+
 @pytest.mark.skip('new approach')
 def test_screenshot_dialog(make_napari_viewer, tmpdir):
     """Test save screenshot functionality."""

napari/_qt/qt_main_window.py

@@ -1504,7 +1504,12 @@ def _restart(self):
         self._qt_window.restart()
 
     def _screenshot(
-        self, size=None, scale=None, flash=True, canvas_only=False
+        self,
+        size=None,
+        scale=None,
+        flash=True,
+        canvas_only=False,
+        fit_to_data: bool = False,
     ) -> 'QImage':
         """Capture screenshot of the currently displayed viewer.
 
@@ -1524,16 +1529,39 @@ def _screenshot(
             If True, screenshot shows only the image display canvas, and
             if False include the napari viewer frame in the screenshot,
             By default, True.
+        fit_to_data: bool
+            Whether to fit a bounding box around the data to prevent margins of showing in the screenshot.
+            Currently, if this is False it means a screenshot of the current canvas will be generated with
+            black margins if visible.
 
         Returns
         -------
         img : QImage
         """
         from napari._qt.utils import add_flash_animation
 
+        canvas = self._qt_viewer.canvas
+        prev_size = canvas.size
+        if fit_to_data:
+            ndisplay = self._qt_viewer.viewer.dims.ndisplay
+            camera = self._qt_viewer.viewer.camera
+            old_center = camera.center
+            old_zoom = camera.zoom
+            if ndisplay > 2:
+                raise NotImplementedError(
+                    'margins equal to False is not yet implemented for 3D. Please set margins to True.'
+                )
+
+            self._qt_viewer.viewer.reset_view()
+            canvas.size = (
+                self._qt_viewer.viewer.layers.extent.world[1][
+                    -ndisplay:
+                ].astype(int)
+                + 1
+            )
+            self._qt_viewer.viewer.reset_view(screenshot=True)
+
         if canvas_only:
-            canvas = self._qt_viewer.canvas
-            prev_size = canvas.size
             if size is not None:
                 if len(size) != 2:
                     raise ValueError(
@@ -1557,16 +1585,25 @@ def _screenshot(
                     add_flash_animation(self._qt_viewer._welcome_widget)
             finally:
                 # make sure we always go back to the right canvas size
-                if size is not None or scale is not None:
+                if size is not None or scale is not None or fit_to_data:
                     canvas.size = prev_size
+                if fit_to_data:
+                    camera.center = old_center
+                    camera.zoom = old_zoom
         else:
             img = self._qt_window.grab().toImage()
             if flash:
                 add_flash_animation(self._qt_window)
         return img
 
     def screenshot(
-        self, path=None, size=None, scale=None, flash=True, canvas_only=False
+        self,
+        path=None,
+        size=None,
+        scale=None,
+        flash=True,
+        canvas_only=False,
+        fit_to_data: bool = False,
     ):
         """Take currently displayed viewer and convert to an image array.
 
@@ -1588,6 +1625,9 @@ def screenshot(
             If True, screenshot shows only the image display canvas, and
             if False includes the napari viewer frame in the screenshot,
             By default, True.
+        fit_to_data : bool
+            Whether to fit a bounding box around the data to prevent margins of showing in the screenshot. This fits a
+            bounding box around all data currently being displayed in the viewer (resets the view).
 
         Returns
         -------
@@ -1596,7 +1636,9 @@ def screenshot(
             upper-left corner of the rendered region.
         """
 
-        img = QImg2array(self._screenshot(size, scale, flash, canvas_only))
+        img = QImg2array(
+            self._screenshot(size, scale, flash, canvas_only, fit_to_data)
+        )
         if path is not None:
             imsave(path, img)
         return img

napari/components/viewer_model.py

@@ -377,8 +377,19 @@ def _sliced_extent_world_augmented(self) -> np.ndarray:
             )
         return self.layers._extent_world_augmented[:, self.dims.displayed]
 
-    def reset_view(self) -> None:
-        """Reset the camera view."""
+    def reset_view(self, screenshot=False) -> None:
+        """
+        Reset the camera view.
+
+        This reset has two modes, one for when viewing the data in the viewer and one for when taking a
+        screenshot with a canvas not showing margins around the data. The two differ in the scaling
+        factor of the zoom.
+
+        Parameters
+        ----------
+        screenshot: bool
+            Whether to reset the view in screenshot mode. Default is False.
+        """
 
         extent = self._sliced_extent_world_augmented
         scene_size = extent[1] - extent[0]
@@ -402,12 +413,15 @@ def reset_view(self) -> None:
         # zoom is definied as the number of canvas pixels per world pixel
         # The default value used below will zoom such that the whole field
         # of view will occupy 95% of the canvas on the most filled axis
+
+        scale_factor = 0.95 if not screenshot else 1
+
         if np.max(size) == 0:
-            self.camera.zoom = 0.95 * np.min(self._canvas_size)
+            self.camera.zoom = scale_factor * np.min(self._canvas_size)
         else:
             scale = np.array(size[-2:])
             scale[np.isclose(scale, 0)] = 1
-            self.camera.zoom = 0.95 * np.min(
+            self.camera.zoom = scale_factor * np.min(
                 np.array(self._canvas_size) / scale
             )
         self.camera.angles = (0, 0, 90)

napari/viewer.py

@@ -96,6 +96,7 @@ def screenshot(
         scale=None,
         canvas_only=True,
         flash: bool = True,
+        fit_to_data: bool = False,
     ):
         """Take currently displayed screen and convert to an image array.
 
@@ -117,6 +118,10 @@ def screenshot(
             Flag to indicate whether flash animation should be shown after
             the screenshot was captured.
             By default, True.
+        fit_to_data : bool
+            Whether to fit a bounding box around the data to prevent margins of showing in the screenshot.
+            Currently, if this is False it means a screenshot of the whole data will be generated without margins (a
+            temporary view reset is applied so the canvas has all data within the extent of the canvas).
 
         Returns
         -------
@@ -130,6 +135,7 @@ def screenshot(
             scale=scale,
             flash=flash,
             canvas_only=canvas_only,
+            fit_to_data=fit_to_data,
         )
 
     def show(self, *, block=False):