          scaling = dpi / 72.0
          logger.debug("dpi: %s, scaling: %s'", dpi, scaling)
          return scaling
  
      def set_geometry(self):
          """ Set GUI geometry """
          self.root.tk.call("tk", "scaling", self.scaling)
          width = int(940 * self.scaling)
          height = int(600 * self.scaling)
          logger.debug("Geometry: %sx%s", width, height)
          self.root.geometry("{}x{}+80+80".format(str(width), str(height)))
  
      def process(self):
          """ The preview process """
 
</s> remove         self.root.geometry("{}x{}+80+80".format(str(width), str(height)))
 </s> add         self.geometry("{}x{}+80+80".format(str(width), str(height))) </s> remove     def get_scaling(self):
        """ Get dpi and update scaling for the display """
        dpi = self.root.winfo_fpixels("1i")
 </s> add     def _get_scaling(self):
        """ Get dpi and update scaling for the display.

        Returns
        -------
        float: The scaling factor for display
        """
        dpi = self.winfo_fpixels("1i") </s> remove         """ The preview process """
        self.build_ui()
        self.root.mainloop()
 </s> add         """ The entry point for the Preview tool from :file:`lib.tools.cli`.

        Launch the tkinter preview Window and run main loop.
        """
        self._build_ui()
        self.mainloop() </s> remove         self.cli_frame = ActionFrame(options_frame,
                                     self.patch.converter.args.color_adjustment.replace("-", "_"),
                                     self.patch.converter.args.mask_type.replace("-", "_"),
                                     self.patch.converter.args.scaling.replace("-", "_"),
                                     self.config_tools,
                                     self.refresh,
                                     self.samples.generate,
                                     self.tk_vars)
        self.opts_book = OptionsBook(options_frame, self.config_tools, self.refresh, self.scaling)
 </s> add         self._cli_frame = ActionFrame(
            options_frame,
            list(self._samples.alignments.mask_summary.keys()),
            self._samples.predictor.has_predicted_mask,
            self._patch.converter.cli_arguments.color_adjustment.replace("-", "_"),
            self._patch.converter.cli_arguments.mask_type.replace("-", "_"),
            self._patch.converter.cli_arguments.scaling.replace("-", "_"),
            self._config_tools,
            self._refresh,
            self._samples.generate,
            self._tk_vars)
        self._opts_book = OptionsBook(options_frame,
                                      self._config_tools,
                                      self._refresh,
                                      self._scaling) </s> remove     def scale_image(self, frame):
        """ Scale the image if requested """
        if self.scale == 1:
 </s> add     def _scale_image(self, frame):
        """ Scale the final image if requested.

        If output scale has been requested in command line arguments, scale the output
        otherwise return the final frame.

        Parameters
        ----------
        frame: :class:`numpy.ndarray`
            The final frame with faces swapped

        Returns
        -------
        :class:`numpy.ndarray`
            The final frame scaled by the requested scaling factor
        """
        if self._scale == 1:
    def _set_geometry(self):
        """ Set the GUI window geometry. """
        self.tk.call("tk", "scaling", self._scaling)
        width = int(940 * self._scaling)
        height = int(600 * self._scaling)
          scaling = dpi / 72.0
          logger.debug("dpi: %s, scaling: %s'", dpi, scaling)
          return scaling
  
    def _set_geometry(self):
        """ Set the GUI window geometry. """
        self.tk.call("tk", "scaling", self._scaling)
        width = int(940 * self._scaling)
        height = int(600 * self._scaling)
    def _set_geometry(self):
        """ Set the GUI window geometry. """
        self.tk.call("tk", "scaling", self._scaling)
        width = int(940 * self._scaling)
        height = int(600 * self._scaling)
    def _set_geometry(self):
        """ Set the GUI window geometry. """
        self.tk.call("tk", "scaling", self._scaling)
        width = int(940 * self._scaling)
        height = int(600 * self._scaling)
    def _set_geometry(self):
        """ Set the GUI window geometry. """
        self.tk.call("tk", "scaling", self._scaling)
        width = int(940 * self._scaling)
        height = int(600 * self._scaling)
    def _set_geometry(self):
        """ Set the GUI window geometry. """
        self.tk.call("tk", "scaling", self._scaling)
        width = int(940 * self._scaling)
        height = int(600 * self._scaling)
          logger.debug("Geometry: %sx%s", width, height)
          self.root.geometry("{}x{}+80+80".format(str(width), str(height)))
  
      def process(self):
          """ The preview process """
keep keep keep keep replace replace replace replace replace keep keep keep keep keep
 Smart Masks to Convert (#957)

- scripts.convert - Use Smart Masks for Convert
    * Make on-the-fly conversion an explicit option

- Move BlurMask to lib.faces_detect

- tools.preview - Fix for smart masks
    * Subclass from tk.Tk
    * Options to lib.gui.control_helper
    *variable cleanup

- lib.logger - Demote more tensorflow deprecation messages

- Documentation:
    * lib.faces_detect.BlurMask
    * plugins.convert.mask
    * lib.convert
    * scripts.convert
    * scripts.fsmedia
    * tools.preview 
tools/preview.py