def view_mask(self): data = SimpleDataInfo({'Original mask': load_nifti(self.selectedMaskText.text()).get_data(), 'Slice mask': load_nifti(self.selectedOutputFileText.text()).get_data()}) config = MapPlotConfig() config.dimension = self.dimensionInput.value() config.slice_index = self.sliceInput.value() config.maps_to_show = ['Original mask', 'Slice mask'] start_gui(data=data, config=config, app_exec=False)
def _start_maps_visualizer(self): folder = self.selectedOutputFolder.text( ) + '/' + self._get_current_model_name() maps = mdt.load_volume_maps(folder) a_map = maps[list(maps.keys())[0]] config = MapPlotConfig() config.dimension = 2 if len(a_map.shape) > 2: config.slice_index = a_map.shape[2] // 2 start_gui(data=SimpleDataInfo.from_paths([folder]), config=config, app_exec=False)
def view_mask(self): mask = np.expand_dims(load_brain_mask(self.selectedOutputText.text()), axis=3) image_data = load_nifti(self.selectedImageText.text()).get_data() masked_image = image_data * mask data = SimpleDataInfo({ 'Masked': masked_image, 'DWI': image_data, 'Mask': mask }) config = MapPlotConfig() config.dimension = 2 config.slice_index = image_data.shape[2] // 2 config.maps_to_show = ['DWI', 'Masked', 'Mask'] start_gui(data=data, config=config, app_exec=False)
def start_gui(base_dir=None, app_exec=True): """Start the model fitting GUI. Args: base_dir (str): the starting directory for the file opening actions app_exec (boolean): if true we execute the Qt application, set to false to disable. This is only important if you want to start this GUI from within an existing Qt application. If you leave this at true in that case, this will try to start a new Qt application which may create problems. """ from mdt.gui.model_fit.qt_main import start_gui return start_gui(base_dir=base_dir, app_exec=app_exec)
def view_maps(self): if self._folder is None: return maps_to_show = [] for item in [ self.selectMaps.item(index) for index in range(self.selectMaps.count()) ]: if item.isSelected(): maps_to_show.append(item.text()) data = SimpleDataInfo.from_paths([self._folder]) config = MapPlotConfig() config.maps_to_show = maps_to_show config.dimension = self.initialDimensionChooser.value() config.slice_index = self.initialSliceChooser.value() start_gui(data=data, config=config, app_exec=False)
def view_maps(data, config=None, figure_options=None, block=True, show_maximized=False, use_qt=True, window_title=None): """View a number of maps using the MDT Maps Visualizer. Args: data (str, dict, :class:`~mdt.visualization.maps.base.DataInfo`, list, tuple): the data we are showing, either a dictionary with result maps, a string with a path name, a DataInfo object or a list with filenames and/or directories. config (str, dict, :class:`~mdt.visualization.maps.base import MapPlotConfig`): either a Yaml string or a dictionary with configuration settings or a ValidatedMapPlotConfig object to use directly figure_options (dict): figure options for the matplotlib Figure, if figsizes is not given you can also specify two ints, width and height, to indicate the pixel size of the resulting figure, together with the dpi they are used to calculate the figsize. Only used if use_qt=False. block (boolean): if we block the plots or not show_maximized (boolean): if we show the window maximized or not window_title (str): the title for the window use_qt (boolean): if we want to use the Qt GUI, or show the results directly in matplotlib """ from mdt.gui.maps_visualizer.main import start_gui from mdt.visualization.maps.base import MapPlotConfig from mdt.visualization.maps.matplotlib_renderer import MapsVisualizer from mdt.visualization.maps.base import SimpleDataInfo import matplotlib.pyplot as plt if isinstance(data, string_types): data = SimpleDataInfo.from_paths([data]) elif isinstance(data, collections.MutableMapping): data = SimpleDataInfo(data) elif isinstance(data, collections.Sequence): if all(isinstance(el, string_types) for el in data): data = SimpleDataInfo.from_paths(data) else: data = SimpleDataInfo({str(ind): v for ind, v in enumerate(data)}) elif data is None: data = SimpleDataInfo({}) if config is None: config = MapPlotConfig() elif isinstance(config, string_types): if config.strip(): config = MapPlotConfig.from_yaml(config) else: config = MapPlotConfig() elif isinstance(config, dict): config = MapPlotConfig.from_dict(config) if use_qt: start_gui(data, config, app_exec=block, show_maximized=show_maximized, window_title=window_title) else: figure_options = figure_options or {} figure_options['dpi'] = figure_options.get('dpi', 100) if 'figsize' not in figure_options: figure_options['figsize'] = (figure_options.pop('width', 1800) / figure_options['dpi'], figure_options.pop('height', 1600) / figure_options['dpi']) figure = plt.figure(**figure_options) viz = MapsVisualizer(data, figure) viz.show(config, block=block, maximize=show_maximized)
def view_maps(data, config=None, figure_options=None, block=True, show_maximized=False, use_qt=True, window_title=None, save_filename=None): """View a number of maps using the MDT Maps Visualizer. Args: data (str, dict, :class:`~mdt.visualization.maps.base.DataInfo`, list, tuple): the data we are showing, either a dictionary with result maps, a string with a path name, a DataInfo object or a list with filenames and/or directories. config (str, dict, :class:`~mdt.visualization.maps.base import MapPlotConfig`): either a Yaml string or a dictionary with configuration settings or a ValidatedMapPlotConfig object to use directly figure_options (dict): Used when ``use_qt`` is False or when ``write_figure`` is used. Sets the figure options for the matplotlib Figure. If figsizes is not given you can also specify two ints, width and height, to indicate the pixel size of the resulting figure, together with the dpi they are used to calculate the figsize. block (boolean): if we block the plots or not show_maximized (boolean): if we show the window maximized or not window_title (str): the title for the window use_qt (boolean): if we want to use the Qt GUI, or show the results directly in matplotlib save_filename (str): save the figure to file. If set, we will not display the viewer. """ from mdt.gui.maps_visualizer.main import start_gui from mdt.visualization.maps.base import MapPlotConfig from mdt.visualization.maps.matplotlib_renderer import MapsVisualizer from mdt.visualization.maps.base import SimpleDataInfo import matplotlib.pyplot as plt from mdt.gui.maps_visualizer.actions import NewDataAction from mdt.gui.maps_visualizer.base import SimpleDataConfigModel if isinstance(data, str): data = SimpleDataInfo.from_paths([data]) elif isinstance(data, collections.MutableMapping): data = SimpleDataInfo(data) elif isinstance(data, collections.Sequence): if all(isinstance(el, str) for el in data): data = SimpleDataInfo.from_paths(data) else: data = SimpleDataInfo({str(ind): v for ind, v in enumerate(data)}) elif data is None: data = SimpleDataInfo({}) if config is None: config = MapPlotConfig() elif isinstance(config, str): if config.strip(): config = MapPlotConfig.from_yaml(config) else: config = MapPlotConfig() elif isinstance(config, dict): config = MapPlotConfig.from_dict(config) config = config.create_valid(data) if not use_qt or save_filename: settings = {'dpi': 100, 'width': 1800, 'height': 1600} if save_filename: settings = {'dpi': 80, 'width': 800, 'height': 600} settings.update(figure_options or {}) if 'figsize' not in settings: settings['figsize'] = (settings['width'] / settings['dpi'], settings['height'] / settings['dpi']) del settings['width'] del settings['height'] figure = plt.figure(**settings) viz = MapsVisualizer(data, figure) if save_filename: viz.to_file(save_filename, config, dpi=settings['dpi']) else: viz.show(config, block=block, maximize=show_maximized) else: start_gui(data, config, app_exec=block, show_maximized=show_maximized, window_title=window_title)
def view_maps(data, config=None, to_file=None, to_file_options=None, block=True, show_maximized=False, use_qt=True, figure_options=None, window_title=None, enable_directory_watcher=True): """View a number of maps using the MDT Maps Visualizer. To save a file to an image, you can use (the simplest) the following two options:: to_file='filename.png', figure_options={'width': 1200, 'height': 750, 'dpi': 100} Args: data (str, dict, :class:`~mdt.visualization.maps.base.DataInfo`): the data we are showing, either a dictionary with result maps, a string with a path name or a DataInfo object config (str, dict, :class:`~mdt.visualization.maps.base import MapPlotConfig`): either a Yaml string or a dictionary with configuration settings or a ValidatedMapPlotConfig object to use directly to_file (str): if set we output the figure to a file and do not launch a GUI to_file_options (dict): extra output options for the savefig command from matplotlib, if dpi is not given, we use the dpi from the figure_options. block (boolean): if we block the plots or not show_maximized (boolean): if we show the window maximized or not use_qt (boolean): if we want to use the Qt GUI, or show the results directly in matplotlib figure_options (dict): figure options for the matplotlib Figure, if figsizes is not given you can also specify two ints, width and height, to indicate the pixel size of the resulting figure, together with the dpi they are used to calculate the figsize. window_title (str): the title for the window enable_directory_watcher (boolean): if the directory watcher should be enabled/disabled, only applicable for the QT GUI. If the directory watcher is enabled, the viewer will automatically add new maps when added to the folder and also automatically remove maps when they are removed from the directory. It is useful to disable this if you want to have multiple viewers open with old results. """ from mdt.gui.maps_visualizer.main import start_gui from mdt.visualization.maps.base import MapPlotConfig from mdt.visualization.maps.matplotlib_renderer import MapsVisualizer import matplotlib.pyplot as plt from mdt.visualization.maps.base import DataInfo if isinstance(data, string_types): data = DataInfo.from_dir(data) elif isinstance(data, dict): data = DataInfo(data) elif data is None: data = DataInfo({}) if config is None: config = MapPlotConfig() elif isinstance(config, string_types): if config.strip(): config = MapPlotConfig.from_yaml(config) else: config = MapPlotConfig() elif isinstance(config, dict): config = MapPlotConfig.from_dict(config) if to_file: figure_options = figure_options or {} figure_options['dpi'] = figure_options.get('dpi', 80) if 'figsize' not in figure_options: figure_options['figsize'] = (figure_options.pop('width', 800) / figure_options['dpi'], figure_options.pop('height', 640) / figure_options['dpi']) figure = plt.figure(**figure_options) viz = MapsVisualizer(data, figure) to_file_options = to_file_options or {} to_file_options['dpi'] = to_file_options.get('dpi', figure_options['dpi']) viz.to_file(to_file, config, **to_file_options) elif use_qt: start_gui(data, config, app_exec=block, show_maximized=show_maximized, window_title=window_title, enable_directory_watcher=enable_directory_watcher) else: figure_options = figure_options or {} figure_options['dpi'] = figure_options.get('dpi', 100) if 'figsize' not in figure_options: figure_options['figsize'] = (figure_options.pop('width', 1800) / figure_options['dpi'], figure_options.pop('height', 1600) / figure_options['dpi']) figure = plt.figure(**figure_options) viz = MapsVisualizer(data, figure) viz.show(config, block=block, maximize=show_maximized)