Ejemplo n.º 1
0
    def test_first(self):
        orig_md = [s.raw[0][0].metadata.copy() for s in self.streams]

        # Print ready format
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.001203511795256, -0.000295338300158]
        draw_merge_ratio = 0.3
        self.streams[1]._updateImage()
        exp_data_rgb = img.images_to_export_data(self.streams, view_hfw,
                                                 view_pos, draw_merge_ratio,
                                                 False)
        self.assertEqual(len(exp_data_rgb), 1)
        self.assertEqual(len(exp_data_rgb[0].shape), 3)  # RGB

        # Post-process format
        exp_data_gray = img.images_to_export_data(self.streams, view_hfw,
                                                  view_pos, draw_merge_ratio,
                                                  True)
        self.assertEqual(len(exp_data_gray), 2)
        self.assertEqual(len(exp_data_gray[0].shape), 2)  # grayscale
        self.assertEqual(exp_data_rgb[0].shape[:2], exp_data_gray[0].shape
                         )  # all exported images must have the same shape

        for s, md in zip(self.streams, orig_md):
            self.assertEqual(md, s.raw[0][0].metadata)
Ejemplo n.º 2
0
    def test_multiple_streams(self):
        orig_md = [s.raw[0].metadata.copy() for s in self.streams]

        # Print ready format
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.001203511795256, -0.000295338300158]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos,
                                             draw_merge_ratio, False)
        self.assertEqual(len(exp_data), 1)
        self.assertEqual(len(exp_data[0].shape), 3)  # RGB

        # Post-process format
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos,
                                             draw_merge_ratio, True)
        self.assertEqual(len(exp_data), 2)
        self.assertEqual(len(exp_data[0].shape), 2)  # grayscale
        self.assertEqual(len(exp_data[1].shape), 2)  # grayscale
        self.assertEqual(
            exp_data[0].shape,
            exp_data[1].shape)  # all exported images must have the same shape

        # Metadata shouldn't be modified
        for s, md in zip(self.streams, orig_md):
            self.assertEqual(md, s.raw[0].metadata)
Ejemplo n.º 3
0
 def test_no_intersection(self):
     """
     Data has no intersection with the window view
     """
     view_hfw = (0.0001039324002586505, 6.205915392651362e-05)
     view_pos = [-0.00147293527265202, -0.0004728408264424368]
     draw_merge_ratio = 0.3
     with self.assertRaises(LookupError):
         img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)
Ejemplo n.º 4
0
    def test_no_intersection(self):
        """
        Data has no intersection with the window view
        """
        view_hfw = (0.0001039324002586505, 6.205915392651362e-05)
        view_pos = [-0.00147293527265202, -0.0004728408264424368]
        draw_merge_ratio = 0.3
        with self.assertRaises(LookupError):
            img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)

        with self.assertRaises(LookupError):
            img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, True)
Ejemplo n.º 5
0
    def test_no_crop_need(self):
        """
        Data roi covers the whole window view
        """
        view_hfw = (0.00025158414075691866, 0.00017445320835792754)
        view_pos = [-0.001211588332679978, -0.00028726176273402186]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(exp_data[0].shape, (1226, 1576, 4))  # RGB
        self.assertEqual(len(exp_data), 1)

        # TODO: test also raw export
        exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(exp_data[0].shape, (1226, 1576))  # greyscale
Ejemplo n.º 6
0
    def test_no_crop_need(self):
        """
        Data roi covers the whole window view
        """
        view_hfw = (0.00025158414075691866, 0.00017445320835792754)
        view_pos = [-0.001211588332679978, -0.00028726176273402186]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(exp_data[0].shape, (1226, 1576, 4))  # RGB
        self.assertEqual(len(exp_data), 1)

        # test also raw export
        exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(exp_data[0].shape, (1226, 1576))  # greyscale
Ejemplo n.º 7
0
    def test_multiple_streams(self):
        # Print ready format
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.001203511795256, -0.000295338300158]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(len(exp_data), 1)
        self.assertEqual(len(exp_data[0].shape), 3)  # RGB

        # Post-process format
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(len(exp_data), 2)
        self.assertEqual(len(exp_data[0].shape), 2)  # grayscale
        self.assertEqual(len(exp_data[1].shape), 2)  # grayscale
        self.assertEqual(exp_data[0].shape, exp_data[1].shape)  # all exported images must have the same shape
Ejemplo n.º 8
0
    def test_multiple_streams(self):
        # Print ready format
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.001203511795256, -0.000295338300158]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(len(exp_data), 1)
        self.assertEqual(len(exp_data[0].shape), 3)  # RGB

        # Post-process format
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(len(exp_data), 2)
        self.assertEqual(len(exp_data[0].shape), 2)  # grayscale
        self.assertEqual(len(exp_data[1].shape), 2)  # grayscale
        self.assertEqual(exp_data[0].shape, exp_data[1].shape)  # all exported images must have the same shape
Ejemplo n.º 9
0
 def test_spec_pp(self):
     view_hfw = (0.00025158414075691866, 0.00017445320835792754)
     view_pos = [-0.001211588332679978, -0.00028726176273402186]
     draw_merge_ratio = 0.3
     streams = [self.streams[1], self.spec_stream]
     exp_data = img.images_to_export_data(streams, view_hfw, view_pos, draw_merge_ratio, True)
     self.assertEqual(exp_data[0].shape, (3379, 4199))  # greyscale
Ejemplo n.º 10
0
 def test_spec_pp(self):
     view_hfw = (0.00025158414075691866, 0.00017445320835792754)
     view_pos = [-0.001211588332679978, -0.00028726176273402186]
     draw_merge_ratio = 0.3
     streams = [self.streams[1], self.spec_stream]
     exp_data = img.images_to_export_data(streams, view_hfw, view_pos, draw_merge_ratio, True)
     self.assertEqual(exp_data[0].shape, (3379, 4199))  # greyscale
Ejemplo n.º 11
0
    def test_thin_column(self):
        """
        Test that minimum width limit is fulfilled in case only a very thin
        column of data is in the view
        """
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.0014443006338779269, -0.0002968821446105185]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(len(exp_data), 1)
        self.assertEqual(len(exp_data[0].shape), 3)  # RGB
        self.assertEqual(exp_data[0].shape[1], img.CROP_RES_LIMIT)

        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(len(exp_data), len(self.streams))
        self.assertEqual(len(exp_data[0].shape), 2)  # greyscale
        self.assertEqual(exp_data[0].shape[1], img.CROP_RES_LIMIT)
Ejemplo n.º 12
0
    def test_thin_column(self):
        """
        Test that minimum width limit is fulfilled in case only a very thin
        column of data is in the view
        """
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.0014443006338779269, -0.0002968821446105185]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(len(exp_data), 1)
        self.assertEqual(len(exp_data[0].shape), 3)  # RGB
        self.assertEqual(exp_data[0].shape[1], img.CROP_RES_LIMIT)

        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(len(exp_data), len(self.streams))
        self.assertEqual(len(exp_data[0].shape), 2)  # greyscale
        self.assertEqual(exp_data[0].shape[1], img.CROP_RES_LIMIT)
Ejemplo n.º 13
0
 def test_crop_need(self):
     """
     Data roi covers part of the window view thus we need to crop the
     intersection with the data
     """
     view_hfw = (0.0005031682815138373, 0.0003489064167158551)
     view_pos = [-0.001211588332679978, -0.00028726176273402186]
     draw_merge_ratio = 0.3
     exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, False)
     self.assertEqual(exp_data[0].shape, (2340, 2560, 4))  # RGB
Ejemplo n.º 14
0
 def test_crop_need(self):
     """
     Data roi covers part of the window view thus we need to crop the
     intersection with the data
     """
     view_hfw = (0.0005031682815138373, 0.0003489064167158551)
     view_pos = [-0.001211588332679978, -0.00028726176273402186]
     draw_merge_ratio = 0.3
     exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, False)
     self.assertEqual(exp_data[0].shape, (2340, 2560, 4))  # RGB
Ejemplo n.º 15
0
    def test_first(self):
        orig_md = [s.raw[0][0].metadata.copy() for s in self.streams]

        # Print ready format
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.001203511795256, -0.000295338300158]
        draw_merge_ratio = 0.3
        self.streams[1]._updateImage()
        exp_data_rgb = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(len(exp_data_rgb), 1)
        self.assertEqual(len(exp_data_rgb[0].shape), 3)  # RGB

        # Post-process format
        exp_data_gray = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(len(exp_data_gray), 2)
        self.assertEqual(len(exp_data_gray[0].shape), 2)  # grayscale
        self.assertEqual(exp_data_rgb[0].shape[:2], exp_data_gray[0].shape)  # all exported images must have the same shape

        for s, md in zip(self.streams, orig_md):
            self.assertEqual(md, s.raw[0][0].metadata)
Ejemplo n.º 16
0
 def test_crop_and_interpolation_need(self):
     """
     Data roi covers part of the window view and data resolution is below
     the minimum limit thus we need to interpolate the data in order to
     keep the shape ratio unchanged
     """
     view_hfw = (0.0010063365630276746, 0.0006978128334317102)
     view_pos = [-0.0015823014004405739, -0.0008081984265806109]
     draw_merge_ratio = 0.3
     exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, False)
     self.assertEqual(exp_data[0].shape, (182, 1673, 4))  # RGB
Ejemplo n.º 17
0
 def test_spec_pp(self):
     view_hfw = (0.00025158414075691866, 0.00017445320835792754)
     view_pos = [-0.001211588332679978, -0.00028726176273402186]
     draw_merge_ratio = 0.3
     proj = RGBSpatialProjection(self.spec_stream)
     streams = [self.streams[1], proj]
     orig_md = [s.raw[0].metadata.copy() for s in streams]
     exp_data = img.images_to_export_data(streams, view_hfw, view_pos, draw_merge_ratio, True)
     self.assertEqual(exp_data[0].shape, (3379, 4199))  # greyscale
     for s, md in zip(streams, orig_md):
         self.assertEqual(md, s.raw[0].metadata)
Ejemplo n.º 18
0
 def test_crop_and_interpolation_need(self):
     """
     Data roi covers part of the window view and data resolution is below
     the minimum limit thus we need to interpolate the data in order to
     keep the shape ratio unchanged
     """
     view_hfw = (0.0010063365630276746, 0.0006978128334317102)
     view_pos = [-0.0015823014004405739, -0.0008081984265806109]
     draw_merge_ratio = 0.3
     exp_data = img.images_to_export_data([self.streams[0]], view_hfw, view_pos, draw_merge_ratio, False)
     self.assertEqual(exp_data[0].shape, (182, 1673, 4))  # RGB
Ejemplo n.º 19
0
    def test_multiple_streams(self):
        orig_md = [s.raw[0].metadata.copy() for s in self.streams]

        # Print ready format
        view_hfw = (8.191282393266523e-05, 6.205915392651362e-05)
        view_pos = [-0.001203511795256, -0.000295338300158]
        draw_merge_ratio = 0.3
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, False)
        self.assertEqual(len(exp_data), 1)
        self.assertEqual(len(exp_data[0].shape), 3)  # RGB

        # Post-process format
        exp_data = img.images_to_export_data(self.streams, view_hfw, view_pos, draw_merge_ratio, True)
        self.assertEqual(len(exp_data), 2)
        self.assertEqual(len(exp_data[0].shape), 2)  # grayscale
        self.assertEqual(len(exp_data[1].shape), 2)  # grayscale
        self.assertEqual(exp_data[0].shape, exp_data[1].shape)  # all exported images must have the same shape

        # Metadata shouldn't be modified
        for s, md in zip(self.streams, orig_md):
            self.assertEqual(md, s.raw[0].metadata)
Ejemplo n.º 20
0
 def test_spec_pp(self):
     view_hfw = (0.00025158414075691866, 0.00017445320835792754)
     view_pos = [-0.001211588332679978, -0.00028726176273402186]
     draw_merge_ratio = 0.3
     proj = RGBSpatialProjection(self.spec_stream)
     streams = [self.streams[1], proj]
     orig_md = [s.raw[0].metadata.copy() for s in streams]
     exp_data = img.images_to_export_data(streams, view_hfw, view_pos,
                                          draw_merge_ratio, True)
     self.assertEqual(exp_data[0].shape, (3379, 4199))  # greyscale
     for s, md in zip(streams, orig_md):
         self.assertEqual(md, s.raw[0].metadata)
Ejemplo n.º 21
0
    def export(self, export_type, raw=False):
        """
        Returns the data to be exported with respect to the settings and options.

        :param export_type (string): spatial, AR, spectrum or spectrum-line
        :param raw (boolean): raw data format if True
        :param interpolate_data (boolean): apply interpolation on data if True

        returns DataArray or list of DataArray: the data to be exported, either
          an RGB image or raw data.
        raises:
            LookupError: if no data found to export
        """
        fview = self._data_model.focussedView.value
        vp = self.get_viewport_by_view(fview)
        streams = fview.getStreams()
        if export_type == 'AR':
            # TODO: set MD_ACQ_TYPE in stream code
            for i, _ in enumerate(streams):
                for r in streams[i].raw:
                    r.metadata[model.MD_ACQ_TYPE] = model.MD_AT_AR
            exported_data = ar_to_export_data(streams, raw)
        elif export_type == 'spectrum':
            spectrum = vp.stream.get_pixel_spectrum()
            spectrum_range, unit = vp.stream.get_spectrum_range()
            spectrum.metadata[model.MD_ACQ_TYPE] = model.MD_AT_SPECTRUM
            exported_data = spectrum_to_export_data(spectrum, raw, unit, spectrum_range)
        elif export_type == 'spectrum-line':
            spectrum_md = vp.stream.get_pixel_spectrum().metadata
            spectrum = vp.stream.get_line_spectrum()
            # copy only non existed values (we mainly care about MD_WL_*)
            spectrum.metadata.update({k: v for k, v in spectrum_md.iteritems() if k not in spectrum.metadata})
            spectrum_range, unit = vp.stream.get_spectrum_range()
            spectrum.metadata[model.MD_ACQ_TYPE] = model.MD_AT_SPECTRUM
            exported_data = line_to_export_data(spectrum, raw, unit, spectrum_range)
        else:
            export_type = 'spatial'
            view_px = tuple(vp.canvas.ClientSize)
            view_mpp = fview.mpp.value
            view_hfw = (view_mpp * view_px[0], view_mpp * view_px[1])
            view_pos = fview.view_pos.value
            draw_merge_ratio = fview.stream_tree.kwargs.get("merge", 0.5)
            interpolate_data = fview.interpolate_content.value
            exported_data = images_to_export_data(streams,
                                                  view_hfw, view_pos,
                                                  draw_merge_ratio, raw,
                                                  interpolate_data=interpolate_data,
                                                  logo=self._main_frame.legend_logo)

        return exported_data
Ejemplo n.º 22
0
    def export(self, export_type, raw=False):
        """
        Returns the data to be exported with respect to the settings and options.

        :param export_type (string): spatial, AR, spectrum, spectrum-temporal,
            spectrum-time, or spectrum-line
        :param raw (boolean): raw data format if True
        :param interpolate_data (boolean): apply interpolation on data if True

        returns DataArray or list of DataArray: the data to be exported, either
          an RGB image or raw data.
        raises:
            LookupError: if no data found to export
        """
        fview = self._data_model.focussedView.value
        vp = self.get_viewport_by_view(fview)
        streams = fview.stream_tree.getProjections(
        )  # Stream tree to get the DataProjection
        if export_type == 'AR':
            exported_data = ar_to_export_data(streams, raw)
        elif export_type == 'spectrum':
            exported_data = spectrum_to_export_data(streams[0], raw, vp)
        elif export_type == 'spectrum-line':
            exported_data = line_to_export_data(streams[0], raw)
        elif export_type == 'spectrum-temporal':
            exported_data = temporal_spectrum_to_export_data(streams[0], raw)
        elif export_type == 'spectrum-time':
            exported_data = chronogram_to_export_data(streams[0], raw, vp)
        else:
            view_px = tuple(vp.canvas.ClientSize)
            view_mpp = fview.mpp.value
            view_hfw = (view_mpp * view_px[0], view_mpp * view_px[1])
            view_pos = fview.view_pos.value
            draw_merge_ratio = fview.stream_tree.kwargs.get("merge", 0.5)
            interpolate_data = fview.interpolate_content.value
            exported_data = images_to_export_data(
                streams,
                view_hfw,
                view_pos,
                draw_merge_ratio,
                raw,
                vp.canvas,
                interpolate_data=interpolate_data,
                logo=self._main_frame.legend_logo)

        return exported_data
Ejemplo n.º 23
0
    def export(self, export_type, raw=False):
        """
        Returns the data to be exported with respect to the settings and options.

        :param export_type (string): spatial, AR, spectrum, spectrum-temporal,
            spectrum-time, or spectrum-line
        :param raw (boolean): raw data format if True
        :param interpolate_data (boolean): apply interpolation on data if True

        returns DataArray or list of DataArray: the data to be exported, either
          an RGB image or raw data.
        raises:
            LookupError: if no data found to export
        """
        fview = self._data_model.focussedView.value
        vp = self.get_viewport_by_view(fview)
        streams = fview.stream_tree.getProjections()  # Stream tree to get the DataProjection
        if export_type == 'AR':
            exported_data = ar_to_export_data(streams, raw)
        elif export_type == 'spectrum':
            exported_data = spectrum_to_export_data(streams[0], raw, vp)
        elif export_type == 'spectrum-line':
            exported_data = line_to_export_data(streams[0], raw)
        elif export_type == 'spectrum-temporal':
            exported_data = temporal_spectrum_to_export_data(streams[0], raw)
        elif export_type == 'spectrum-time':
            exported_data = chronogram_to_export_data(streams[0], raw, vp)
        else:
            view_px = tuple(vp.canvas.ClientSize)
            view_mpp = fview.mpp.value
            view_hfw = (view_mpp * view_px[0], view_mpp * view_px[1])
            view_pos = fview.view_pos.value
            draw_merge_ratio = fview.stream_tree.kwargs.get("merge", 0.5)
            interpolate_data = fview.interpolate_content.value
            exported_data = images_to_export_data(streams,
                                                  view_hfw, view_pos,
                                                  draw_merge_ratio, raw,
                                                  interpolate_data=interpolate_data,
                                                  logo=self._main_frame.legend_logo)

        return exported_data
Ejemplo n.º 24
0
    def export(self, dlg):
        """
        Stores the current CL data into a PNG file
        """
        f = model.ProgressiveFuture()

        # Note: the user never needs to store the raw data or the SEM data
        try:
            das = self._acquire(dlg, f)
        except CancelledError:
            logging.debug("Stopping acquisition + export, as it was cancelled")
            return
        except Exception as e:
            logging.exception("Failed to acquire CL data: %s", e)
            return

        exporter = dataio.find_fittest_converter(self.filename.value,
                                                 allowlossy=True)

        ss = self._get_acq_streams()
        for s in ss:
            if len(ss) > 1:
                # Add a -StreamName after the filename
                bn, ext = splitext(self.filename.value)
                fn = bn + "-" + s.name.value + ext
            else:
                fn = self.filename.value

            # We actually don't care about the DAs, and will get the corresponding
            # .image, as it has been projected to RGB.
            rgbi = s.image.value
            try:
                while rgbi.metadata[model.MD_ACQ_DATE] < s.raw[0].metadata[
                        model.MD_ACQ_DATE]:
                    logging.debug("Waiting a for the RGB projection")
                    time.sleep(1)
                    rgbi = s.image.value
            except KeyError:
                # No date to check => let's hope it's fine
                pass

            try:
                if self.hasDatabar.value:
                    # Use MPP and FoV so that the whole image is displayed, at 1:1
                    view_pos = rgbi.metadata[model.MD_POS]
                    pxs = rgbi.metadata[model.MD_PIXEL_SIZE]
                    # Shape is YXC
                    view_hfw = rgbi.shape[1] * pxs[0], rgbi.shape[0] * pxs[1]
                    exdata = img.images_to_export_data(
                        [s],
                        view_hfw,
                        view_pos,
                        draw_merge_ratio=1.0,
                        raw=False,
                        interpolate_data=False,
                        logo=self.main_app.main_frame.legend_logo)
                else:
                    exdata = rgbi

                exporter.export(fn, exdata)
            except Exception:
                logging.exception("Failed to store data in %s", fn)

        f.set_result(None)  # Indicate it's over
        self._update_filename()
Ejemplo n.º 25
0
    def export(self, dlg):
        """
        Stores the current CL data into a PNG file
        """
        f = model.ProgressiveFuture()

        # Note: the user never needs to store the raw data or the SEM data
        try:
            das = self._acquire(dlg, f)
        except CancelledError:
            logging.debug("Stopping acquisition + export, as it was cancelled")
            return
        except Exception as e:
            logging.exception("Failed to acquire CL data: %s", e)
            return

        exporter = dataio.find_fittest_converter(self.filename.value, allowlossy=True)

        ss = self._get_acq_streams()
        for s in ss:
            if len(ss) > 1:
                # Add a -StreamName after the filename
                bn, ext = splitext(self.filename.value)
                fn = bn + "-" + s.name.value + ext
            else:
                fn = self.filename.value

            # We actually don't care about the DAs, and will get the corresponding
            # .image, as it has been projected to RGB.
            rgbi = s.image.value
            try:
                while rgbi.metadata[model.MD_ACQ_DATE] < s.raw[0].metadata[model.MD_ACQ_DATE]:
                    logging.debug("Waiting a for the RGB projection")
                    time.sleep(1)
                    rgbi = s.image.value
            except KeyError:
                # No date to check => let's hope it's fine
                pass

            try:
                if self.hasDatabar.value:
                    # Use MPP and FoV so that the whole image is displayed, at 1:1
                    view_pos = rgbi.metadata[model.MD_POS]
                    pxs = rgbi.metadata[model.MD_PIXEL_SIZE]
                    # Shape is YXC
                    view_hfw = rgbi.shape[1] * pxs[0], rgbi.shape[0] * pxs[1]
                    exdata = img.images_to_export_data([s],
                                                       view_hfw, view_pos,
                                                       draw_merge_ratio=1.0,
                                                       raw=False,
                                                       interpolate_data=False,
                                                       logo=self.main_app.main_frame.legend_logo)
                else:
                    exdata = rgbi

                exporter.export(fn, exdata)
            except Exception:
                logging.exception("Failed to store data in %s", fn)

        f.set_result(None)  # Indicate it's over
        self._update_filename()