class ApplyTransform(QpWidget): """ Widget for applying previously calculated transformations """ def __init__(self, **kwargs): super(ApplyTransform, self).__init__(name="Apply Transform", icon="reg", desc="Apply previously calculated transformations", group="Registration", **kwargs) self.reg_methods = [] for method in get_plugins("reg-methods"): try: self.reg_methods.append(method(self.ivm)) except: traceback.print_exc() self.warn("Failed to create registration method: %s", method) def init_ui(self): layout = QtGui.QVBoxLayout() self.setLayout(layout) title = TitleWidget(self, help="reg") layout.addWidget(title) if not self.reg_methods: layout.addWidget(QtGui.QLabel("No registration methods found")) layout.addStretch(1) return self.options = OptionBox("General Options") self.options.add("Transform", TransformOption(self.ivm), key="transform") self.options.add("Apply to data", DataOption(self.ivm), key="data") self.options.add("Interpolation", ChoiceOption(["Nearest neighbour", "Linear", "Spline"], [0, 1, 3], default=1), key="interp-order") self.options.add("Output name", OutputNameOption(src_data=self.options.option("data"), suffix="_reg"), key="output-name") self.options.option("transform").sig_changed.connect(self._transform_changed) layout.addWidget(self.options) self.details = TransformDetails() layout.addWidget(self.details) layout.addWidget(RunButton(self)) layout.addStretch(1) self._transform_changed() def processes(self): return { "ApplyTransform" : self.options.values(), } def activate(self): self._transform_changed() def _transform_changed(self): trans_name = self.options.option("transform").value transform = self.ivm.data.get(trans_name, None) if transform is None or "QpReg" not in transform.metadata: transform = self.ivm.extras.get(trans_name, None) if transform is not None and "QpReg" in transform.metadata: self.details.transform = transform
class SimMotionWidget(QpWidget): """ Widget to simulate random motion on a 4D data set """ def __init__(self, **kwargs): super(SimMotionWidget, self).__init__(name="Simulate motion", icon="reg", desc="Simulate random motion on a 4D data set", group="Simulation", **kwargs) def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) title = TitleWidget(self, title="Simulate Motion", help="sim_motion") vbox.addWidget(title) self.option_box = OptionBox("Options") data = self.option_box.add("Data set", DataOption(self.ivm, include_4d=True, include_3d=False), key="data") self.option_box.add("Motion standard deviation (mm)", NumericOption(minval=0, maxval=5, default=1, decimals=2), key="std") self.option_box.add("Padding (mm)", NumericOption(minval=0, maxval=10, default=5, decimals=1), key="padding", checked=True) self.option_box.add("Output name", OutputNameOption(src_data=data, suffix="_moving"), key="output-name") vbox.addWidget(self.option_box) run_btn = QtGui.QPushButton('Run', self) run_btn.clicked.connect(self.run) vbox.addWidget(run_btn) vbox.addStretch(1) def batch_options(self): return "SimMotion", self.option_box.values() def run(self): options = self.batch_options()[1] process = SimMotionProcess(self.ivm) process.execute(options)
class VbOptions(OptionsWidget): def __init__(self, ivm, parent, acq_options): OptionsWidget.__init__(self, ivm, parent) self.acq_options = acq_options vbox = QtWidgets.QVBoxLayout() self.setLayout(vbox) cite = Citation(FAB_CITE_TITLE, FAB_CITE_AUTHOR, FAB_CITE_JOURNAL) vbox.addWidget(cite) self._optbox = OptionBox() self._optbox.add("<b>Model options</b>") self._optbox.add("Infer constant signal offset", BoolOption(default=True), key="infer-sig0") self._optbox.add("Infer delay", BoolOption(default=True), key="infer-delay") self._optbox.add("<b>Model fitting options</b>") self._optbox.add("Number of iterations", NumericOption(minval=0, maxval=100, default=10, intonly=True), key="max-iterations") #self._optbox.add("Spatial regularization", BoolOption(default=True), key="spatial") self._optbox.add("<b>Output options</b>") self._optbox.add("Output variance maps", BoolOption(), key="output-var") self._optbox.add("Output data name suffix", TextOption(), checked=True, key="output-suffix") vbox.addWidget(self._optbox) vbox.addWidget(RunWidget(self, save_option=True)) vbox.addStretch(1) def processes(self): opts = {} opts.update(self.acq_options.options()) opts.update(self._optbox.values()) self.debug("CvrPetCo2Vb options: %s", opts) processes = [ { "CvrPetCo2Vb": opts }, ] return processes
class AslDataModelView: def __init__(self, ivm): self.model = AslDataModel(ivm) self.gui = OptionBox() self.gui.add("Bolus duration", NumericOption(minval=0, maxval=5, default=1.8), key="tau") self.gui.add("Labelling", ChoiceOption(["CASL/pCASL", "PASL"], [True, False], default=True), key="casl") self.gui.add("PLDs", NumberListOption([0.25, 0.5, 0.75, 1.0, 1.25, 1.5]), key="plds") self.gui.add("Time per slice (ms)", NumericOption(minval=0, maxval=1000, default=0, intonly=True), key="slicedt") self.gui.add("Data format", ChoiceOption(["Differenced data", "Label/Control pairs"], ["diff", "tc"]), key="iaf") self.gui.add("Repeats", NumericOption(minval=1, maxval=100, default=1, intonly=True), key="repeats") self.gui.add("Group by", ChoiceOption(["PLDs", "Repeats"], ["tis", "rpt"]), key="ibf") self.gui.add("Inversion efficiency", NumericOption(minval=0.5, maxval=1.0, default=0.85), key="alpha") self.gui.add("M0", NumericOption(minval=0, maxval=2000, default=1000), key="m0") self.gui.add("TR (s)", NumericOption(minval=0, maxval=10, default=4), key="tr") self.gui.add("TE (ms)", NumericOption(minval=0, maxval=1000, default=13), key="te") self.gui.add("Tissue/arterial partition coefficient", NumericOption(minval=0, maxval=1, default=0.9), key="pct") #self.gui.add("Arterial component", BoolOption(), key="incart") self.gui.sig_changed.connect(self._update_options) self._update_options() def _update_options(self): self.model.options.update(self.gui.values())
class CheckerboardModelView: """ View for CheckerboardModel """ def __init__(self, ivm): self.model = CheckerboardModel(ivm) self.gui = OptionBox() self.gui.add("Number of voxels per patch (approx)", NumericOption(minval=1, maxval=1000, default=20, intonly=True), key="voxels-per-patch") self.gui.sig_changed.connect(self._update_options) def _update_options(self): self.model.options.update(self.gui.values())
class FastStructureModelView: """ View for FastStructureModel """ def __init__(self, ivm): self.model = FastStructureModel(ivm) self.gui = OptionBox() self.gui.add("Structural image (brain extracted)", DataOption(self.model._ivm, explicit=True), key="struc") self.gui.add("Image type", ChoiceOption(["T1 weighted", "T2 weighted", "Proton Density"], return_values=[1, 2, 3]), key="type") self.gui.sig_changed.connect(self._update_options) def _update_options(self): self.model.options.update(self.gui.values())
class DscDataModelView: def __init__(self, ivm): self.model = DscDataModel(ivm) self.gui = OptionBox() self.gui.add("Time between volumes (s)", NumericOption(minval=0, maxval=5, default=1.0), key="delt") self.gui.add("TE (s)", NumericOption(minval=0, maxval=5, default=1.0), key="te") self.gui.add("AIF", NumberListOption(), key="aif") self.gui.sig_changed.connect(self._update_options) self._update_options() def _update_options(self): self.model.options.update(self.gui.values())
class SpinEchoDataModelView: def __init__(self, ivm): self.model = SpinEchoDataModel(ivm) self.gui = OptionBox() self.gui.add("TR (s)", NumericOption(minval=0, maxval=10, default=4.8), key="tr") self.gui.add("TE (ms)", NumericOption(minval=0, maxval=1000, default=0), key="te") self.gui.add("M0", NumericOption(minval=0, maxval=10000, default=1000), key="m0") self.gui.sig_changed.connect(self._update_options) self._update_options() def _update_options(self): self.model.options.update(self.gui.values())
class FslWidget(QpWidget): """ Widget providing interface to FSL program """ def __init__(self, **kwargs): QpWidget.__init__(self, icon="fsl.png", group="FSL", **kwargs) self.prog = kwargs["prog"] def init_ui(self, run_box=True): self.vbox = QtGui.QVBoxLayout() self.setLayout(self.vbox) title = TitleWidget(self, help="fsl", subtitle="%s %s" % (self.description, __version__)) self.vbox.addWidget(title) cite = Citation(*CITATIONS.get(self.prog, CITATIONS["fsl"])) self.vbox.addWidget(cite) self.options = OptionBox("%s options" % self.prog.upper()) self.vbox.addWidget(self.options) if run_box: self.run_box = RunBox(self.get_process, self.get_options) self.vbox.addWidget(self.run_box) self.vbox.addStretch(1) fsldir = FslDirWidget() self.vbox.addWidget(fsldir) fsldir.sig_changed.connect(self._fsldir_changed) self._fsldir_changed(fsldir.fsldir) def _fsldir_changed(self, fsldir): self.options.setVisible(bool(fsldir)) if hasattr(self, "run_box"): self.run_box.setVisible(bool(fsldir)) def batch_options(self): return self.get_process().PROCESS_NAME, self.get_options() def get_options(self): return self.options.values()
class AddNoiseWidget(QpWidget): """ Add noise to data """ def __init__(self, **kwargs): super(AddNoiseWidget, self).__init__(name="Add noise", icon="noise", desc="Add random noise to a data set", group="Simulation", **kwargs) def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) title = TitleWidget(self, title="Add Noise", help="noise") vbox.addWidget(title) self.option_box = OptionBox("Options") data = self.option_box.add("Data set", DataOption(self.ivm), key="data") self.option_box.add("Gaussian standard deviation", NumericOption(minval=0, maxval=100, default=50), key="std") self.option_box.add("Output name", OutputNameOption(src_data=data, suffix="_noisy"), key="output-name") vbox.addWidget(self.option_box) run_btn = QtGui.QPushButton('Run', self) run_btn.clicked.connect(self.run) vbox.addWidget(run_btn) vbox.addStretch(1) def batch_options(self): return "AddNoise", self.option_box.values() def run(self): options = self.batch_options()[1] process = AddNoiseProcess(self.ivm) process.execute(options)
class GlmOptions(OptionsWidget): def __init__(self, ivm, parent, acq_options): OptionsWidget.__init__(self, ivm, parent) self.acq_options = acq_options vbox = QtWidgets.QVBoxLayout() self.setLayout(vbox) self._optbox = OptionBox() self._optbox.add("<b>Model options</b>") self._optbox.add("Delay minimum (s)", NumericOption(minval=-100, maxval=100, default=0), key="delay-min") self._optbox.add("Delay maximum (s)", NumericOption(minval=-100, maxval=100, default=0), key="delay-max") self._optbox.add("Delay step (s)", NumericOption(minval=-5, maxval=5, default=1), key="delay-step") self._optbox.add("<b>Output options</b>") self._optbox.add("Output data name suffix", TextOption(), checked=True, key="output-suffix") vbox.addWidget(self._optbox) vbox.addWidget(RunWidget(self, save_option=True)) vbox.addStretch(1) def processes(self): opts = {} opts.update(self.acq_options.options()) opts.update(self._optbox.values()) self.debug("CvrPetCo2Glm options: %s", opts) processes = [ { "CvrPetCo2Glm": opts }, ] return processes
class AifWidget(QtGui.QWidget): """ Widget allowing choice of AIF """ def __init__(self, ivm): QtGui.QWidget.__init__(self) self.ivm = ivm vbox = QtGui.QVBoxLayout() self.setLayout(vbox) self.optbox = OptionBox() self.optbox.add( "AIF source", ChoiceOption(["Global sequence of values", "Voxelwise image"], ["global", "voxelwise"]), key="aif_source") self.optbox.option("aif_source").sig_changed.connect( self._aif_source_changed) self.optbox.add("AIF", NumberListOption(), key="aif") self.optbox.add("AIF image", DataOption(self.ivm), key="suppdata") self.optbox.add("AIF type", ChoiceOption(["DSC signal", "Concentration"], [False, True]), key="aifconc") vbox.addWidget(self.optbox) vbox.addStretch() self._aif_source_changed() def options(self): """ :return: Dictionary of options selected for the AIF""" opts = self.optbox.values() opts.pop("aif_source") return opts def _aif_source_changed(self): global_aif = self.optbox.option("aif_source").value == "global" self.optbox.set_visible("aif", global_aif) self.optbox.set_visible("suppdata", not global_aif)
class SequenceOptions(QtGui.QWidget): """ Widget containing options for the CEST sequence """ sig_b0_changed = QtCore.Signal(float) def __init__(self, ivm=None): QtGui.QWidget.__init__(self) self._ivm = ivm vbox = QtGui.QVBoxLayout() self.setLayout(vbox) self.optbox = OptionBox() vbox.addWidget(self.optbox) self.optbox.add("CEST data", DataOption(self._ivm), key="data") self.optbox.add("ROI", DataOption(self._ivm, rois=True, data=False), key="mask") self.optbox.add("Frequency offsets", NumberListOption(), key="freqs") self.optbox.add("B0", ChoiceOption(B0_DEFAULTS), key="b0") self.optbox.add("Custom B0 (T)", NumericOption(minval=0.0, maxval=15, default=3.0, decimals=3), key="b0_custom") # FIXME multiple B1 values self.optbox.add("B1 (\u03bcT)", NumericOption(minval=0.0, maxval=2, default=0.55, decimals=6), key="b1") self.optbox.add( "Saturation", ChoiceOption(["Continuous Saturation", "Pulsed Saturation"], ["continuous", "pulsed"]), key="sat") self.optbox.add("Saturation time (s)", NumericOption(minval=0.0, maxval=5, default=2, decimals=2), key="sat_time") self.optbox.add("Pulse Magnitudes", NumberListOption(), key="pulse_mag") self.optbox.add("Pulse Durations (s)", NumberListOption(), key="pulse_dur") self.optbox.add("Pulse Repeats", NumberListOption(), key="pulse_repeats") self.optbox.option("b0").sig_changed.connect(self._b0_changed) self.optbox.option("b0_custom").sig_changed.connect(self._b0_changed) self.optbox.option("sat").sig_changed.connect(self._sat_changed) self.warn_box = WarningBox() vbox.addWidget(self.warn_box) # B1 field #hbox = QtGui.QHBoxLayout() #self.unsat_cb = QtGui.QCheckBox("Unsaturated") #self.unsat_cb.stateChanged.connect(self.update_ui) #hbox.addWidget(self.unsat_cb) #self.unsat_combo = QtGui.QComboBox() #self.unsat_combo.addItem("first") #self.unsat_combo.addItem("last") #self.unsat_combo.addItem("first and last ") #hbox.addWidget(self.unsat_combo) #hbox.addStretch(1) #grid.addLayout(hbox, 2, 2) vbox.addStretch(1) self._sat_changed() self._b0_changed() def _sat_changed(self): pulsed = self.optbox.option("sat").value == "pulsed" self.optbox.set_visible("pulse_mag", pulsed) self.optbox.set_visible("pulse_dur", pulsed) self.optbox.set_visible("pulse_repeats", pulsed) def _b0_changed(self): b0_sel = self.optbox.option("b0").value if b0_sel == "Custom": self.optbox.set_visible("b0_custom", True) b0 = self.optbox.option("b0_custom").value else: self.optbox.set_visible("b0_custom", False) b0 = float(b0_sel[:-1]) self.sig_b0_changed.emit(b0) def _get_dataspec(self, options): dataspec = [] freqs = options.pop("freqs") b1 = options.pop("b1") / 1e6 if options["sat"] == "pulsed": repeats = options.pop("pulse_repeats") else: repeats = 1 for idx, freq in enumerate(freqs): #if self.unsat_cb.isChecked(): # self.debug("Unsat", idx, self.unsat_combo.currentIndex()) # if idx == 0 and self.unsat_combo.currentIndex() in (0, 2): # b1 = 0 # elif idx == len(freqs)-1 and self.unsat_combo.currentIndex() in (1, 2): # b1 = 0 dataspec.append([freq, b1, repeats]) #self.debug(dataspec) return dataspec def _get_ptrain(self, options): ptrain = [] if options.pop("sat") == "pulsed": pms = options.pop("pulse_mag") pds = options.pop("pulse_dur") if len(pms) != len(pds): raise QpException( "Pulse magnitude and duration must contain the same number of values" ) for pm, pd in zip(pms, pds): ptrain.append([pm, pd]) else: ptrain.append([1, options.pop("sat_time")]) #self.debug(ptrain) return ptrain def options(self): options = self.optbox.values() options["spec"] = self._get_dataspec(options) options["ptrain"] = self._get_ptrain(options) options.pop("b0") options.pop("b0_custom", None) return options
class FabberWidget(QpWidget): """ Widget for running Fabber model fitting """ def __init__(self, **kwargs): QpWidget.__init__(self, **kwargs) self._fabber_options = { "degree" : 2, "noise" : "white", "save-mean" : True, "save-model-fit" : True, "save-model-extras" : True, } self._fabber_params = [] def init_ui(self): self.vbox = QtGui.QVBoxLayout() self.setLayout(self.vbox) title = TitleWidget(self, subtitle="Plugin %s" % __version__, help="fabber") self.vbox.addWidget(title) cite = Citation(FAB_CITE_TITLE, FAB_CITE_AUTHOR, FAB_CITE_JOURNAL) self.vbox.addWidget(cite) self.options = OptionBox("Options") self.options.sig_changed.connect(self._options_changed) self.vbox.addWidget(self.options) self.warn_box = WarningBox("") self.warn_box.setVisible(False) self.vbox.addWidget(self.warn_box) def _model_group_changed(self): models = FabberProcess.api().get_models(model_group=self._fabber_options.get("model-group", None)) self.debug("Models: %s", models) self.options.option("model").setChoices(models) def _options_changed(self): self._fabber_options.update(self.options.values()) if self._fabber_options.get("model-group", None) == "ALL": self._fabber_options["model-group"] = None self.debug("Options changed:\n%s", self._fabber_options) self._update_params() def _fix_data_params(self, api): """ Given a set of Fabber options, replace those that should be data items with a Numpy array """ options = dict(self._fabber_options) known_options = api.get_options(generic=True, model=options.get("model", None), method=options.get("method", None))[0] for key in options: if api.is_data_option(key, known_options): # Just provide a placeholder options[key] = np.zeros((1, 1, 1)) return options def _update_params(self): from fabber import FabberException try: api = FabberProcess.api() options = self._fix_data_params(api) self._fabber_params = api.get_model_params(options) self.warn_box.setVisible(False) except FabberException as exc: self._fabber_params = [] self.warn_box.text.setText("Invalid model options:\n\n%s" % str(exc)) self.warn_box.setVisible(True) def _show_model_options(self): model = self._fabber_options["model"] dlg = OptionsDialog(self, ivm=self.ivm, rundata=self._fabber_options, desc_first=True) opts, desc = FabberProcess.api().get_options(model=model) self.debug("Model options: %s", opts) dlg.set_title("Forward Model: %s" % model, desc) dlg.set_options(opts) dlg.exec_() self._update_params() def _show_method_options(self): method = self._fabber_options["method"] dlg = OptionsDialog(self, ivm=self.ivm, rundata=self._fabber_options, desc_first=True) opts, desc = FabberProcess.api().get_options(method=method) # Ignore prior options which have their own dialog opts = [o for o in opts if "PSP_byname" not in o["name"] and o["name"] != "param-spatial-priors"] dlg.set_title("Inference method: %s" % method, desc) self.debug("Method options: %s", opts) dlg.set_options(opts) dlg.fit_width() dlg.exec_() def _show_general_options(self): dlg = OptionsDialog(self, ivm=self.ivm, rundata=self._fabber_options, desc_first=True) dlg.ignore("model", "method", "output", "data", "mask", "data<n>", "overwrite", "help", "listmodels", "listmethods", "link-to-latest", "data-order", "dump-param-names", "loadmodels") opts, _ = FabberProcess.api().get_options() dlg.set_options(opts) dlg.fit_width() dlg.exec_() def _show_prior_options(self): dlg = PriorsDialog(self, ivm=self.ivm, rundata=self._fabber_options) try: api = FabberProcess.api() options = self._fix_data_params(api) params = api.get_model_params(options) except Exception as exc: raise QpException("Unable to get list of model parameters\n\n%s\n\nModel options must be set before parameters can be listed" % str(exc)) dlg.set_params(params) dlg.fit_width() dlg.exec_() def get_options(self): """ Return a copy of current Fabber options """ return dict(self._fabber_options) def get_process(self): return FabberProcess(self.ivm) def batch_options(self): return "Fabber", self.get_options()
class SimData(FabberWidget): """ Widget which uses Fabber models to generate simulated data """ def __init__(self, **kwargs): super(SimData, self).__init__(name="Simulated Fabber Data", icon="fabber", desc="Generate test data sets from Fabber models", group="Simulation", **kwargs) self._param_test_values = {} def init_ui(self): FabberWidget.init_ui(self) self.param_values_box = OptionBox("Parameter values") self.param_values_box.sig_changed.connect(self._param_values_changed) self.vbox.addWidget(self.param_values_box) run_btn = QtGui.QPushButton('Generate test data', self) run_btn.clicked.connect(self._run) self.vbox.addWidget(run_btn) self.vbox.addStretch(1) model_opts_btn = QtGui.QPushButton('Model Options') model_opts_btn.clicked.connect(self._show_model_options) self.options.add("Model group", ChoiceOption(), key="model-group") self.options.add("Model", ChoiceOption(), model_opts_btn, key="model") self.options.add("Number of volumes (time points)", NumericOption(intonly=True, minval=1, maxval=100, default=10), key="num-vols") self.options.add("Voxels per patch (approx)", NumericOption(intonly=True, minval=1, maxval=10000, default=1000), key="num-voxels") self.options.add("Noise (Gaussian std.dev)", NumericOption(intonly=True, minval=0, maxval=1000, default=0), key="noise") self.options.add("Output data name", OutputNameOption(initial="fabber_test_data"), key="output-name") self.options.add("Output noise-free data", BoolOption(), key="save-clean") self.options.add("Output parameter ROIs", BoolOption(), key="save-rois") self.options.option("model-group").sig_changed.connect(self._model_group_changed) model_groups = ["ALL"] for group in FabberProcess.api().get_model_groups(): model_groups.append(group.upper()) self.options.option("model-group").setChoices(model_groups) self.options.option("model-group").value = "ALL" self._model_group_changed() self.options.option("model").value = "poly" self._options_changed() # Start with something sensible for the polynomial model self._param_test_values = {"c0" : [-100, 0, 100], "c1" : [-10, 0, 10], "c2" : [-1, 0, 1]} self._update_params() def _update_params(self): FabberWidget._update_params(self) self.param_values_box.clear() for param in self._fabber_params: current_values = self._param_test_values.get(param, [1.0]) self.param_values_box.add(param, NumberListOption(initial=current_values)) self._param_test_values[param] = current_values # Remove references to parameters which no longer exist for param in list(self._param_test_values.keys()): if param not in self._fabber_params: del self._param_test_values[param] def _param_values_changed(self): self._param_test_values = self.param_values_box.values() num_variable = len([1 for v in self._param_test_values.values() if len(v) > 1]) if num_variable > 3: self.warn("Cannot have more than 3 varying parameters") def get_options(self): """ Return a copy of current Fabber options and parameter test values """ options = dict(self._fabber_options) options["param-test-values"] = self._param_test_values return options def _run(self): process = self.get_process() options = self.get_options() process.run(options) def get_process(self): return FabberTestDataProcess(self.ivm) def batch_options(self): return "FabberTestData", self.get_options()
class PcaWidget(QpWidget): """ PCA widget """ def __init__(self, **kwargs): super(PcaWidget, self).__init__(name="PCA", icon="pca", desc="PCA reduction", group="Processing", **kwargs) def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) title = TitleWidget( self, title="PCA reduction", subtitle="Principal Component Analysis for 4D data") vbox.addWidget(title) self._options = OptionBox("Options") self._options.add("Data", DataOption(self.ivm, include_3d=False), key="data") self._options.add("ROI", DataOption(self.ivm, data=False, rois=True), key="roi") self._options.add("Number of components", NumericOption(minval=1, intonly=True, default=4), key="n-components") self._options.add("Output name", OutputNameOption( src_data=self._options.option("data"), suffix="_pca"), key="output-name") self._options.option("data").sig_changed.connect(self._data_changed) vbox.addWidget(self._options) self._run = RunWidget(self) self._run.sig_postrun.connect(self._postrun) vbox.addWidget(self._run) self.plot = Plot(qpo=None, parent=self, title="PCA modes") self.variance_model = QtGui.QStandardItemModel() variance_table = QtGui.QTableView() variance_table.verticalHeader().hide() variance_table.setModel(self.variance_model) tabs = QtGui.QTabWidget() tabs.addTab(self.plot, "PCA modes") tabs.addTab(variance_table, "Explained variance") tabs.setCurrentWidget(self.plot) vbox.addWidget(tabs) vbox.addStretch(1) self._data_changed() def processes(self): return {"PCA": self._options.values()} def _data_changed(self): self._run.setEnabled( self._options.option("data").value in self.ivm.data) def _postrun(self): self._update_plot() self._update_table() def _update_plot(self): self.plot.clear() extra = self.ivm.extras.get( self._options.option("output-name").value + "_modes", None) if extra is not None: arr = np.array(extra.arr) for idx in range(arr.shape[1] - 1): self.plot.add_line(arr[:, idx], name="Mode %i" % idx) self.plot.add_line(arr[:, -1], name="Mean", line_col=(255, 0, 0), line_width=3.0) def _update_table(self): self.variance_model.clear() extra = self.ivm.extras.get( self._options.option("output-name").value + "_variance", None) if extra is not None: self.debug(str(extra)) for idx, header in enumerate(extra.col_headers): self.variance_model.setHorizontalHeaderItem( idx, QtGui.QStandardItem(header)) for idx, variance in enumerate(extra.arr): self.variance_model.setItem( idx, 0, QtGui.QStandardItem(str(variance[0]))) self.variance_model.setItem( idx, 1, QtGui.QStandardItem(sf(variance[1]))) self.variance_model.setItem( idx, 2, QtGui.QStandardItem(sf(variance[2])))
class OrientDataWidget(QpWidget): """ Widget that lets you tweak the orientation of data """ def __init__(self, **kwargs): super(OrientDataWidget, self).__init__(name="Orient Data", icon="inspect.png", desc="Manipulate data orientation", group="Utilities", **kwargs) self._transform_cache = {} self.ivm.sig_all_data.connect(self._all_data_changed) def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) title = TitleWidget(self) vbox.addWidget(title) hbox = QtGui.QHBoxLayout() self.options = OptionBox("Re-orient data") data = self.options.add("Data item", DataOption(self.ivm), key="data") data.sig_changed.connect(self._data_changed) self.trans, self.rot = {}, {} self.options.add("Translation") for axis, label in {2: "axial", 0: "sagittal", 1: "coronal"}.items(): trans = self.options.add(" %s (mm)" % label.title(), NumericOption(minval=-100, maxval=100, default=0), key="trans-%s" % label) trans.sig_changed.connect(self._translate(axis, label)) self.trans[axis] = trans self.options.add("Rotation") for axis, label in {2: "axial", 0: "sagittal", 1: "coronal"}.items(): rot = self.options.add(" %s (degrees)" % label.title(), NumericOption(minval=-180, maxval=180, default=0), key="rot-%s" % label) rot.sig_changed.connect(self._rotate(axis, label)) self.rot[axis] = rot hbox.addWidget(self.options) vbox.addLayout(hbox) self.gridview = GridView(self.ivm, self.ivl) vbox.addWidget(self.gridview) hbox = QtGui.QHBoxLayout() reset_btn = QtGui.QPushButton("Reset to original") reset_btn.clicked.connect(self._reset) hbox.addWidget(reset_btn) hbox.addStretch(1) vbox.addLayout(hbox) vbox.addStretch(1) def activate(self): self._data_changed() def _all_data_changed(self, data): for name in list(self._transform_cache.keys()): if name not in data: del self._transform_cache[name] def _data_changed(self): name = self.options.values()["data"] qpdata = self.ivm.data.get(name, self.ivm.rois.get(name, None)) self.gridview.set_data(qpdata) if qpdata is not None: if name not in self._transform_cache: self._transform_cache[name] = ([0, 0, 0], [0, 0, 0]) translation, rotations = self._transform_cache[name] for axis in range(3): self.trans[axis].value = translation[axis] self.rot[axis].value = rotations[axis] self._set() def _translate(self, axis, label): def _trans(): name = self.gridview.data.name trans = self.options.values()["trans-%s" % label] self._transform_cache[name][0][axis] = trans self._set() return _trans def _rotate(self, axis, label): def _rot(): name = self.gridview.data.name angle = self.options.values()["rot-%s" % label] if axis == 1: angle = -angle self._transform_cache[name][1][axis] = angle self._set() return _rot def _reset(self): name = self.gridview.data.name del self._transform_cache[name] self._data_changed() def _set(self): name = self.gridview.data.name affine = self.gridview.data.grid.affine_orig grid_centre = [float(dim) / 2 for dim in self.gridview.data.grid.shape] world_centre = np.dot(affine[:3, :3], grid_centre) self.debug("Initial affine\n%s", affine) translation, rotations = self._transform_cache[name] R = np.identity(3) for axis in range(3): angle = rotations[axis] rot3d = self._rotmtx_3d(axis, angle) affine[:3, :3] = np.dot(rot3d, affine[:3, :3]) R = np.dot(rot3d, R) origin_offset = world_centre - np.dot(R, world_centre) origin_offset += translation self.debug("Origin offset\n%s", origin_offset) affine[:3, 3] += origin_offset self.debug("Final affine\n%s", affine) self.gridview.data.grid.affine = affine self.gridview.update() if self.gridview.data == self.ivm.main: self.ivm.sig_main_data.emit(self.ivm.main) if self.gridview.data.view.visible == Visibility.SHOW or self.gridview.data == self.ivm.main: self.ivl.redraw() def _rotmtx_3d(self, axis, angle): # FIXME this is not quite right when rotating in a plane where # the basis vectors have different lengths c, s = math.cos(math.radians(angle)), math.sin(math.radians(angle)) rot2d = np.array([[c, -s], [s, c]]) rot3d = np.identity(3) if axis == 0: rot3d[1:, 1:] = rot2d elif axis == 1: rot3d[0, 0] = rot2d[0, 0] rot3d[0, 2] = rot2d[0, 1] rot3d[2, 0] = rot2d[1, 0] rot3d[2, 2] = rot2d[1, 1] elif axis == 2: rot3d[:2, :2] = rot2d self.debug("3d rotation matrix: %i %f", axis, angle) self.debug("\n%s", rot3d) return rot3d
class RegWidget(QpWidget): """ Generic registration / motion correction widget """ def __init__(self, **kwargs): super(RegWidget, self).__init__(name="Registration", icon="reg", desc="Registration and Motion Correction", group="Registration", **kwargs) self.reg_methods = [] for method in get_plugins("reg-methods"): try: self.reg_methods.append(method(self.ivm)) except: traceback.print_exc() self.warn("Failed to create registration method: %s", method) def init_ui(self): layout = QtGui.QVBoxLayout() self.setLayout(layout) title = TitleWidget(self, title="Registration and Motion Correction", help="reg") layout.addWidget(title) if not self.reg_methods: layout.addWidget(QtGui.QLabel("No registration methods found")) layout.addStretch(1) return self.options = OptionBox("General Options") self.options.add("Mode", ChoiceOption(["Registration", "Motion Correction"], ["reg", "moco"]), key="mode") self.options.add( "Method", ChoiceOption([method.display_name for method in self.reg_methods], self.reg_methods), key="method") self.options.add("Registration data", DataOption(self.ivm), key="reg") self.options.add("Reference data", DataOption(self.ivm), key="ref") self.options.add( "Reference volume", ChoiceOption(["Middle volume", "Mean volume", "Specified volume"], ["median", "mean", "idx"]), key="ref-vol") self.options.add("Reference volume index", NumericOption(intonly=True), key="ref-idx") self.options.add( "Output space", ChoiceOption(["Reference", "Registration", "Transformed"], ["ref", "reg", "trans"]), key="output-space") self.options.add("Output name", OutputNameOption(src_data=self.options.option("reg"), suffix="_reg"), key="output-name", checked=True) self.options.add("Also apply transform to", DataOption(self.ivm, multi=True), key="add-reg") self.options.add("Save transformation", TextOption(), key="save-transform", checked=True, default=False) self.options.option("mode").sig_changed.connect( self._update_option_visibility) self.options.option("method").sig_changed.connect(self._method_changed) self.options.option("ref").sig_changed.connect( self._update_option_visibility) self.options.option("ref-vol").sig_changed.connect( self._update_option_visibility) self.options.option("reg").sig_changed.connect( self._update_option_visibility) layout.addWidget(self.options) # Create the options boxes for reg methods - only one visible at a time! self.opt_boxes = {} for method in self.reg_methods: hbox = QtGui.QHBoxLayout() opt_box = QtGui.QGroupBox() opt_box.setTitle(method.display_name) vbox = QtGui.QVBoxLayout() opt_box.setLayout(vbox) vbox.addWidget(method.interface()) hbox.addWidget(opt_box) opt_box.setVisible(False) layout.addLayout(hbox) self.opt_boxes[method.name] = opt_box layout.addWidget(RunWidget(self)) layout.addStretch(1) self._method_changed() def _method_changed(self): method = self.options.option("method").value for name, box in self.opt_boxes.items(): box.setVisible(name == method.name) self.options.option("save-transform").value = "%s_trans" % method.name self._update_option_visibility() def _update_option_visibility(self): mode = self.options.option("mode").value regdata = self.ivm.data.get(self.options.option("reg").value, None) refdata = self.ivm.data.get(self.options.option("ref").value, None) refvol = self.options.option("ref-vol").value nvols_reg, nvols_ref = 1, 1 if regdata is not None: nvols_reg = regdata.nvols if mode == "moco" and regdata is not None: nvols_ref = regdata.nvols elif mode == "reg" and refdata is not None: nvols_ref = refdata.nvols self.options.set_visible("ref", mode == "reg") self.options.set_visible("ref-vol", nvols_ref > 1) self.options.set_visible("ref-idx", nvols_ref > 1 and refvol == "idx") self.options.set_visible("add-reg", nvols_reg == 1 and mode == "reg") self.options.set_visible("output-space", mode == "reg") if nvols_ref > 1: self.options.option("ref-idx").setLimits(0, nvols_ref - 1) self.options.option("ref-idx").value = int(nvols_ref / 2) def processes(self): options = self.options.values() if options.get("ref-vol", None) == "idx": options["ref-vol"] = options.pop("ref-idx") method = options.pop("method") options["method"] = method.name options.update(method.options()) return { "Reg": options, }
class DceDataModelView: def __init__(self, ivm): self.model = DceDataModel(ivm) self.gui = OptionBox() self.gui.add( "Model", ChoiceOption([ "Standard Tofts model", "Extended Tofts model (ETM)", "2 Compartment exchange model", "Compartmental Tissue Update (CTU) model", "Adiabatic Approximation to Tissue Homogeneity (AATH) Model" ], ["dce_tofts", "dce_ETM", "dce_2CXM", "dce_CTU", "dce_AATH"]), key="model") self.gui.add("Contrast agent R1 relaxivity (l/mmol s)", NumericOption(minval=0, maxval=10, default=3.7), key="r1") self.gui.add("Flip angle (\N{DEGREE SIGN})", NumericOption(minval=0, maxval=90, default=12), key="fa") self.gui.add("TR (ms)", NumericOption(minval=0, maxval=10, default=4.108), key="tr") self.gui.add("Time between volumes (s)", NumericOption(minval=0, maxval=30, default=12), key="delt") self.gui.add("AIF", ChoiceOption([ "Population (Orton 2008)", "Population (Parker)", "Measured DCE signal", "Measured concentration curve" ], ["orton", "parker", "signal", "conc"]), key="aif") self.gui.add("Number of volumes", NumericOption(minval=0, maxval=100, default=20, intonly=True), key="nt") self.gui.add("Bolus injection time (s)", NumericOption(minval=0, maxval=60, default=30), key="tinj") self.gui.add("AIF data values", NumberListOption([ 0, ]), key="aif-data") self.gui.add("Arterial transit time (s)", NumericOption(minval=0, maxval=1.0, default=0), key="delay") self.gui.option("model").sig_changed.connect(self._model_changed) self.gui.option("aif").sig_changed.connect(self._aif_changed) self._aif_changed() self._model_changed() self.gui.sig_changed.connect(self._update_options) self._update_options() def _aif_changed(self): aif_source = self.gui.option("aif").value self.gui.set_visible("tinj", aif_source not in ("signal", "conc")) self.gui.set_visible("aif-data", aif_source in ("signal", "conc")) self.gui.set_visible("nt", aif_source not in ("signal", "conc")) def _model_changed(self): pass def _update_options(self): self.model.options.update(self.gui.values())
class AtlasDescription(QtGui.QWidget): """ Displays atlas description """ sig_selected = QtCore.Signal(object) def __init__(self, parent, registry): super(AtlasDescription, self).__init__(parent) self._registry = registry self.ivm = parent.ivm self._desc = None grid = QtGui.QGridLayout() self.setLayout(grid) grid.addWidget(QtGui.QLabel("Name"), 0, 0) self._name = QtGui.QLabel() grid.addWidget(self._name, 0, 1) grid.addWidget(QtGui.QLabel("Type"), 1, 0) self._type = QtGui.QLabel() grid.addWidget(self._type, 1, 1) grid.addWidget(QtGui.QLabel("Resolutions"), 2, 0) self._imgs = QtGui.QComboBox() grid.addWidget(self._imgs, 2, 1) self._label_table = QtGui.QTableView() self._label_model = QtGui.QStandardItemModel() self._label_table.setModel(self._label_model) self._label_table.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows) self._label_table.setSelectionMode( QtGui.QAbstractItemView.SingleSelection) self._label_table.setEditTriggers( QtGui.QAbstractItemView.NoEditTriggers) self._label_table.selectionModel().selectionChanged.connect( self._region_changed) self._label_table.setStyleSheet( "font-size: 10px; alternate-background-color: #6c6c6c;") self._label_table.setShowGrid(False) self._label_table.setTextElideMode(QtCore.Qt.ElideLeft) self._label_table.setAlternatingRowColors(True) self._label_table.ensurePolished() fm = QtGui.QFontMetrics(self._label_table.font()) self._label_table.verticalHeader().setVisible(False) self._label_table.verticalHeader().setSectionResizeMode( QtGui.QHeaderView.Fixed) self._label_table.verticalHeader().setDefaultSectionSize(fm.height() + 2) grid.addWidget(self._label_table, 3, 0, 1, 2) grid.setRowStretch(3, 1) self._load_options = OptionBox() self._load_options.add("Regions", ChoiceOption(["Selected region", "All regions"], ["sel", "all"]), key="regions") self._load_options.add( "Load as", ChoiceOption(["New dataset", "Add to existing dataset"], ["new", "add"]), key="add") self._load_options.add("Dataset name", TextOption("atlas"), key="name") self._load_options.add("Existing dataset", DataOption(self.ivm), key="data") self._load_options.option("regions").sig_changed.connect( self._load_regions_changed) self._load_options.option("add").sig_changed.connect(self._add_changed) grid.addWidget(self._load_options, 4, 0, 1, 2) hbox = QtGui.QHBoxLayout() btn = QtGui.QPushButton("Load") btn.clicked.connect(self._load) hbox.addWidget(btn) hbox.addStretch(1) grid.addLayout(hbox, 5, 0, 1, 2) self._add_changed() def _name_to_dataset_name(self, name): return name.replace(" ", "_").replace("-", "_").replace(",", "").replace( "(", "").replace(")", "").lower() def set_atlas(self, atlas_desc): self._desc = atlas_desc self._name.setText(atlas_desc.name) self._type.setText(atlas_desc.atlasType) self._load_options.option("name").value = self._name_to_dataset_name( atlas_desc.name) self._imgs.clear() for pixdim in atlas_desc.pixdims: pixdim_str = "%.2g mm x %.2g mm x %.2g mm" % pixdim self._imgs.addItem(pixdim_str, pixdim[0]) self._label_model.clear() self._label_model.setColumnCount(2) self._label_model.setHorizontalHeaderLabels(["Index", "Name"]) for label in atlas_desc.labels: index_item = QtGui.QStandardItem("%i" % label.index) name_item = QtGui.QStandardItem(label.name) self._label_model.appendRow([index_item, name_item]) self._label_table.horizontalHeader().setResizeMode( 0, QtGui.QHeaderView.ResizeToContents) self._label_table.horizontalHeader().setResizeMode( 1, QtGui.QHeaderView.Stretch) self._load_options.option("regions").value = "all" def _load_regions_changed(self): if self._load_options.values()["regions"] == "sel": self._region_changed() else: self._load_options.option( "name").value = self._name_to_dataset_name(self._desc.name) def _region_changed(self): if self._load_options.values()["regions"] == "sel": indexes = self._label_table.selectionModel().selectedRows() if indexes: region_name = self._label_model.item(indexes[0].row(), 1).text() if region_name: self._load_options.option( "name").value = self._name_to_dataset_name(region_name) def _add_changed(self): add = self._load_options.values()["add"] == "add" self._load_options.set_visible("name", not add) self._load_options.set_visible("data", add) def _load(self): if self._desc is not None: res = self._imgs.itemData(self._imgs.currentIndex()) atlas = self._registry.loadAtlas(self._desc.atlasID, loadSummary=False, resolution=res) is_roi = self._desc.atlasType == "label" new_name = self._load_options.option("name").value add_name = self._load_options.option("data").value add = self._load_options.option("add").value == "add" load_all = self._load_options.option("regions").value == "all" vol = None if not load_all: indexes = self._label_table.selectionModel().selectedRows() vol = int(self._label_model.item(indexes[0].row(), 0).text()) new_data = fslimage_to_qpdata(atlas, vol=vol, name=new_name, roi=is_roi) if add and add_name in self.ivm.data: # User wants to add the region to an existing data set if load_all: raise QpException( "Cannot add data to existing data set when loading all regions" ) orig_data = self.ivm.data[add_name] if not orig_data.grid.matches(new_data.grid): raise QpException( "Can't add data to existing data set - grids do not match" ) if is_roi and not orig_data.roi: raise QpException( "Can't add data to existing data set - it is not an ROI" ) new_data = NumpyData(orig_data.raw() + new_data.raw(), grid=new_data.grid, name=add_name, roi=is_roi) self.ivm.add(new_data, make_current=True)
class DscOptionsWidget(QtGui.QWidget): """ Widget allowing choice of DSC options """ def __init__(self, ivm): QtGui.QWidget.__init__(self) self.ivm = ivm vbox = QtGui.QVBoxLayout() self.setLayout(vbox) self.optbox = OptionBox() self.optbox.add("DSC Data", DataOption(self.ivm), key="data") self.optbox.add("ROI", DataOption(self.ivm, rois=True, data=False), key="mask") self.optbox.add( "Model choice", ChoiceOption(["Standard", "Control point interpolation"], ["dsc", "dsc_cpi"]), key="model") self.optbox.add("TE (s)", NumericOption(minval=0, maxval=0.1, default=0.065), key="te") self.optbox.add("Time interval between volumes (s)", NumericOption(minval=0, maxval=10, default=1.5), key="delt") self.optbox.add("Apply dispersion to AIF", BoolOption(), key="disp") self.optbox.add("Infer delay parameter", BoolOption(default=True), key="inferdelay") self.optbox.add("Infer arterial component", BoolOption(), key="inferart") self.optbox.add("Log transform on rCBF", BoolOption(), key="log-cbf") self.optbox.add("Output residue function", BoolOption(), key="save-model-extras") self.optbox.add("Spatial regularization", ChoiceOption(("None", "Standard", "Full"), default="Standard"), key="spatial") self.optbox.add("Output data suffix", TextOption(), checked=True, key="output-suffix") self.optbox.option("model").sig_changed.connect(self._model_changed) vbox.addWidget(self.optbox) hbox = QtGui.QHBoxLayout() self.classic_options = OptionBox("Standard model") self.classic_options.add("Infer MTT", BoolOption(default=True), key="infermtt") self.classic_options.add("Infer lambda", BoolOption(default=True), key="inferlambda") hbox.addWidget(self.classic_options) hbox.addStretch(1) vbox.addLayout(hbox) hbox = QtGui.QHBoxLayout() self.cpi_options = OptionBox("CPI model") self.cpi_options.setVisible(False) self.cpi_options.add("Number of control points", NumericOption(minval=3, maxval=20, default=5, intonly=True), key="num-cps") self.cpi_options.add("Infer control point time position", BoolOption(), key="infer-cpt") hbox.addWidget(self.cpi_options) hbox.addStretch(1) vbox.addLayout(hbox) vbox.addStretch() def options(self): """ :return: Dictionary of options selected for the DSC analysis""" opts = self.optbox.values() if opts["model"] == "dsc": opts.update(self.classic_options.values()) elif opts["model"] == "dsc_cpi": opts.update(self.cpi_options.values()) spatial = opts.pop("spatial", "None") if spatial == "Standard": opts["method"] = "spatialvb" opts["param-spatial-priors"] = "MN+" elif spatial == "Full": opts["method"] = "spatialvb" opts["param-spatial-priors"] = "M+" if opts.pop("log-cbf", False): opts["PSP_byname1"] = "cbf" opts["PSP_byname1_mean"] = 0.1 opts["PSP_byname1_prec"] = 1e-4 opts["PSP_byname1_transform"] = "L" return opts def _model_changed(self): classic = self.optbox.option("model").value == "dsc" self.classic_options.setVisible(classic) self.cpi_options.setVisible(not classic)
class AcquisitionOptions(OptionsWidget): N_REGRESSORS = 3 def __init__(self, ivm, parent): OptionsWidget.__init__(self, ivm, parent) vbox = QtWidgets.QVBoxLayout() self.setLayout(vbox) self._optbox = OptionBox() self._optbox.add("<b>Data</b>") self._optbox.add("BOLD timeseries data", DataOption(self.ivm), key="data") self._optbox.add("ROI", DataOption(self.ivm, rois=True, data=False), key="roi") #self._optbox.add("Physiological data (CO<sub>2</sub>/O<sub>2</sub>)", FileOption(plot_btn=True), key="phys-data") #self._optbox.add("Sampling frequency (Hz)", NumericOption(minval=0, maxval=1000, default=100, intonly=True), key="samp-rate") self._optbox.add("TR for MRI timeseries (s)", NumericOption(minval=0, maxval=5, default=1.0), key="tr") self._optbox.add("Baseline period (s)", NumericOption(minval=0, maxval=200, default=60, intonly=True), key="baseline") self._optbox.add("MRI timeseries alignment", ChoiceOption(["Automatic", "Manual"]), key="mri-align") self._optbox.option("mri-align").sig_changed.connect( self._align_changed) self._optbox.add("MRI timeseries start time (s)", NumericOption(minval=0, maxval=1000, default=0), key="data-start-time") vbox.addWidget(self._optbox) self._optbox_reg = OptionBox() self._optbox_reg.add("<b>Regressors</b>") for idx in range(self.N_REGRESSORS): self._optbox_reg.add("Regressor %i" % (idx + 1), ChoiceOption([ "Unprocessed CO2", "Preprocessed pETCO2", "Ramp (linear drift)", "Custom" ], ["co2", "petco2", "ramp", "custom"]), checked=True, default=True, key="type_%i" % (idx + 1)) self._optbox_reg.option("type_%i" % (idx + 1)).sig_changed.connect( self._regressor_changed) self._optbox_reg.add("Data (CO<sub>2</sub>/O<sub>2</sub>)", FileOption(plot_btn=True), key="data_%i" % (idx + 1)) self._optbox_reg.add("Time resolution (s)", NumericOption(minval=0, maxval=10, default=1), key="tr_%i" % (idx + 1)) vbox.addWidget(self._optbox_reg) vbox.addStretch(1) self._regressor_changed() self._align_changed() def _regressor_changed(self): for idx in range(self.N_REGRESSORS): opts = self._optbox_reg.values() extras_visible = "type_%i" % ( idx + 1) in opts and opts["type_%i" % (idx + 1)] != "ramp" self._optbox_reg.set_visible("data_%i" % (idx + 1), extras_visible) self._optbox_reg.set_visible("tr_%i" % (idx + 1), extras_visible) def _add_regressor_options(self, opts): regressors = [] regressor_types = [] regressor_trs = [] reg_opts = self._optbox_reg.values() for idx in range(self.N_REGRESSORS): regressor_type = reg_opts.get("type_%i" % (idx + 1), None) if regressor_type is not None: if regressor_type != "ramp": regressor_types.append(regressor_type) regressors.append(reg_opts["data_%i" % (idx + 1)]) regressor_trs.append(reg_opts["tr_%i" % (idx + 1)]) else: # FIXME can't mix file regressors with Numpy array, need to write to tmp file regressor_types.append("custom") regressor_trs.append(opts["tr"]) regressors.append( np.linspace(0, 1, self.ivm.data[opts["data"]].nvols)) opts["regressors"] = ",".join(regressors) opts["regressor_trs"] = ",".join(["%.3f" % v for v in regressor_trs]) opts["regressor_types"] = ",".join(regressor_types) def _align_changed(self): self._optbox.set_visible( "data-start-time", self._optbox.option("mri-align").value == "Manual") def options(self): opts = self._optbox.values() opts.pop("mri-align", None) self._add_regressor_options(opts) return opts
class AnalysisOptions(QtGui.QWidget): """ Widget allowing model and output options to be changed """ def __init__(self, ivm=None): QtGui.QWidget.__init__(self) self._ivm = ivm self._poolvals_edited = False vbox = QtGui.QVBoxLayout() self.setLayout(vbox) self.optbox = OptionBox() vbox.addWidget(self.optbox) self.optbox.add("<b>Output options</b>") self.optbox.add("CEST R*", BoolOption(default=True), key="save-model-extras") self.optbox.add("Parameter maps", BoolOption(default=False), key="save-mean") #self.optbox.add("Parameter variance", BoolOption(default=False), key="var") self.optbox.add("Model fit", BoolOption(default=False), key="save-model-fit") self.optbox.add("Prefix for output", TextOption(), checked=True, key="output-prefix") self.optbox.add(" ") self.optbox.add("<b>Analysis options</b>") self.optbox.add("Spatial Regularization", BoolOption(), key="spatial") self.optbox.add("Allow uncertainty in T1/T2 values", BoolOption(), key="t12prior") self.optbox.add("Prior T1 map", DataOption(self._ivm), key="t1img", checked=True) self.optbox.add("Prior T2 map", DataOption(self._ivm), key="t2img", checked=True) self.optbox.add("Tissue PV map (GM+WM)", DataOption(self._ivm), key="pvimg", checked=True) self.optbox.option("t12prior").sig_changed.connect(self._update_ui) self.optbox.add("Use steady state solution for MT bias reduction", BoolOption(default=False), key="new-ss") self.optbox.option("new-ss").sig_changed.connect(self._update_ui) self.optbox.add("TR (s)", NumericOption(default=3.0, minval=0, maxval=5, digits=3, step=0.1), key="tr") self.optbox.add("Excitation flip angle (\N{DEGREE SIGN})", NumericOption(default=12.0, minval=0, maxval=25, digits=3, step=1.0), key="fa") self.optbox.add( "MT pool Line shape", ChoiceOption( ["None", "Gaussian", "Lorentzian", "Super Lorentzian"], ["none", "gaussian", "lorentzian", "superlorentzian"]), key="lineshape") self.alexmt_cite = Citation(ALEXMT_CITE_TITLE, ALEXMT_CITE_AUTHOR, ALEXMT_CITE_JOURNAL) vbox.addWidget(self.alexmt_cite) vbox.addStretch(1) self._update_ui() def _update_ui(self): t12prior = self.optbox.option("t12prior").value self.optbox.set_visible("t1img", t12prior) self.optbox.set_visible("t2img", t12prior) newss = self.optbox.values().get("new-ss", False) self.optbox.set_visible("tr", newss) self.optbox.set_visible("fa", newss) self.optbox.set_visible("lineshape", newss) self.alexmt_cite.setVisible(newss) def set_pools(self, pools): self.optbox.set_visible("new-ss", "MT" in [p.name for p in pools if p.enabled]) self._update_ui() def options(self): options = self.optbox.values() if options.pop("spatial", False): options["method"] = "spatialvb" options["param-spatial-priors"] = "MN+" else: options["method"] = "vb" options.pop("param-spatial-priors", None) # The new MT model is automatically triggered when the TR and FA options are given options.pop("new-ss", None) prior_num = 1 for idx in (1, 2): if "t%iimg" % idx in options: options["PSP_byname%i" % prior_num] = "T%ia" % idx options["PSP_byname%i_type" % prior_num] = "I" options["PSP_byname%i_image" % prior_num] = options.pop( "t%iimg" % idx) prior_num += 1 return options
class FlirtRegMethod(RegMethod): """ FLIRT/MCFLIRT registration method """ def __init__(self, ivm): RegMethod.__init__(self, "flirt", ivm, "FLIRT/MCFLIRT") self.options_widget = None self.cost_models = [ "Mutual information", "Woods", "Correlation ratio", "Normalized correlation", "Normalized mutual information", "Least squares" ] self.cost_model_options = [ "mutualinfo", "woods", "corratio", "normcorr", "normmi", "leastsq" ] @classmethod def apply_transform(cls, reg_data, transform, options, queue): """ Apply a previously calculated transformation to a data set We are not actually using FSL applyxfm for this although it would be an alternative option for the reference space output option. Instead we perform a non-lossy affine transformation and then resample onto the reference or registration spaces as required. """ log = "Performing non-lossy affine transformation\n" order = options.pop("interp-order", 1) affine = transform.voxel_to_world(reg_data.grid) grid = DataGrid(reg_data.grid.shape, affine) qpdata = NumpyData(reg_data.raw(), grid=grid, name=reg_data.name) output_space = options.pop("output-space", "ref") if output_space == "ref": qpdata = qpdata.resample(transform.ref_grid, suffix="", order=order) log += "Resampling onto reference grid\n" elif output_space == "reg": qpdata = qpdata.resample(transform.reg_grid, suffix="", order=order) log += "Resampling onto input grid\n" return qpdata, log @classmethod def reg_3d(cls, reg_data, ref_data, options, queue): """ Static function for performing 3D registration """ from fsl import wrappers as fsl reg = qpdata_to_fslimage(reg_data) ref = qpdata_to_fslimage(ref_data) set_environ(options) output_space = options.pop("output-space", "ref") interp = _interp(options.pop("interp-order", 1)) twod = reg_data.grid.shape[2] == 1 logstream = six.StringIO() flirt_output = fsl.flirt(reg, ref, interp=interp, out=fsl.LOAD, omat=fsl.LOAD, twod=twod, log={ "cmd": logstream, "stdout": logstream, "stderr": logstream }, **options) transform = FlirtTransform(ref_data.grid, flirt_output["omat"], name="flirt_xfm") if output_space == "ref": qpdata = fslimage_to_qpdata(flirt_output["out"], reg_data.name) elif output_space == "reg": qpdata = fslimage_to_qpdata(flirt_output["out"], reg_data.name).resample(reg_data.grid, suffix="") qpdata.name = reg_data.name elif output_space == "trans": trans_affine = transform.voxel_to_world(reg_data.grid) trans_grid = DataGrid(reg_data.grid.shape, trans_affine) qpdata = NumpyData(reg_data.raw(), grid=trans_grid, name=reg_data.name) return qpdata, transform, logstream.getvalue() @classmethod def moco(cls, moco_data, ref, options, queue): """ Motion correction We use MCFLIRT to implement this :param moco_data: A single 4D QpData instance containing data to motion correct. :param ref: Either 3D QpData containing reference data, or integer giving the volume index of ``moco_data`` to use :param options: Method options as dictionary :param queue: Queue object which method may put progress information on to. Progress should be given as a number between 0 and 1. :return Tuple of three items. First, motion corrected data as 4D QpData in the same space as ``moco_data`` Second, if options contains ``output-transform : True``, sequence of transformations found, one for each volume in ``reg_data``. Each is either an affine matrix transformation or a sequence of 3 warp images, the same shape as ``regdata`` If ``output-transform`` is not given, returns None instead. Third, log information from the registration as a string. """ from fsl import wrappers as fsl if moco_data.ndim != 4: raise QpException("Cannot motion correct 3D data") set_environ(options) reg = qpdata_to_fslimage(moco_data) if isinstance(ref, int): options["refvol"] = ref ref_grid = moco_data.grid elif isinstance(ref, QpData): options["reffile"] = qpdata_to_fslimage(ref) ref_grid = ref.grid else: raise QpException("invalid reference object type: %s" % type(ref)) interp = _interp(options.pop("interp-order", 1)) # FIXME ignored twod = moco_data.grid.shape[2] == 1 logstream = six.StringIO() result = fsl.mcflirt(reg, out=fsl.LOAD, mats=fsl.LOAD, twod=twod, log={ "cmd": logstream, "stdout": logstream, "stderr": logstream }, **options) qpdata = fslimage_to_qpdata(result["out"], moco_data.name) transforms = [ FlirtTransform(ref_grid, result[os.path.join("out.mat", "MAT_%04i" % vol)]) for vol in range(moco_data.nvols) ] return qpdata, transforms, logstream.getvalue() def interface(self, generic_options=None): """ :return: QWidget containing registration options """ if generic_options is None: generic_options = {} if self.options_widget is None: self.options_widget = QtGui.QWidget() vbox = QtGui.QVBoxLayout() self.options_widget.setLayout(vbox) cite = Citation(CITE_TITLE, CITE_AUTHOR, CITE_JOURNAL) vbox.addWidget(cite) self.optbox = OptionBox() self.optbox.add("Cost Model", ChoiceOption(self.cost_models, self.cost_model_options, default="normcorr"), key="cost") #self.optbox.add("Number of search stages", ChoiceOption([1, 2, 3, 4]), key="nstages") #self.optbox.option("stages").value = 2 #self.optbox.add("Final stage interpolation", ChoiceOption(["None", "Sinc", "Spline", "Nearest neighbour"], ["", "sinc_final", "spline_final", "nn_final"]), key="final") #self.optbox.add("Field of view (mm)", NumericOption(minval1, maxval=100, default=20), key="fov") self.optbox.add("Number of bins", NumericOption(intonly=True, minval=1, maxval=1000, default=256), key="bins") self.optbox.add("Degrees of freedom", ChoiceOption([6, 9, 12]), key="dof") #self.optbox.add("Scaling", NumericOption(minval=0.1, maxval=10, default=6), key="scaling") #self.optbox.add("Smoothing in cost function", NumericOption(minval=0.1, maxval=10, default=1), key="smoothing") #self.optbox.add("Scaling factor for rotation\noptimization tolerances", NumericOption(minval=0.1, maxval=10, default=1), key="rotscale") #self.optbox.add("Search on gradient images", BoolOption, key="grad") vbox.addWidget(self.optbox) return self.options_widget def options(self): """ :return: Dictionary of registration options selected """ self.interface() opts = self.optbox.values() for env_copy in ["FSLOUTPUTTYPE", "FSLDIR", "FSLDEVDIR"]: if env_copy in os.environ: opts[env_copy] = os.environ[env_copy] else: self.debug("%s is not in environment" % env_copy) for key, value in opts.items(): self.debug("%s: %s", key, value) return opts
class HistogramWidget(QpWidget): """ Widget which displays data histograms """ def __init__(self, **kwargs): super(HistogramWidget, self).__init__(name="Histogram", icon="hist", desc="Display histograms from data", group="Visualisation", **kwargs) self._updating = False def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) title = TitleWidget(self) vbox.addWidget(title) self.options = OptionBox("Options") self.options.add("Data", DataOption(self.ivm, multi=True), key="data") self.options.add("Within ROI", DataOption(self.ivm, data=False, rois=True, none_option=True), key="roi") self.options.add("All volumes", BoolOption(default=False), key="allvols") self.options.add("Y-axis scale", ChoiceOption(["Count", "Probability"]), key="yscale") self.options.add("Number of bins", NumericOption(minval=5, maxval=500, default=100, intonly=True), key="bins") self.options.add("Min value", NumericOption(minval=0, maxval=100, default=0), key="min") self.options.add("Max value", NumericOption(minval=0, maxval=500, default=100), key="max") self.options.option("yscale").sig_changed.connect(self._yscale_changed) self.options.option("min").sig_changed.connect(self._min_changed) self.options.option("min").sig_changed.connect(self._max_changed) vbox.addWidget(self.options) self.plot = Plot(qpo=None, parent=self, title="Data histogram", display_mode=False) self.plot.set_xlabel("Data value") self.plot.set_ylabel("Count") vbox.addWidget(self.plot) vbox.addStretch(1) def activate(self): self.ivm.sig_all_data.connect(self._data_changed) self.options.option("data").sig_changed.connect(self._data_changed) self.options.sig_changed.connect(self._update) self._data_changed() def deactivate(self): self.ivm.sig_all_data.disconnect(self._data_changed) self.options.option("data").sig_changed.disconnect(self._data_changed) self.options.sig_changed.disconnect(self._update) def processes(self): opts = self.options.values() if not opts.pop("allvols", False): opts["vol"] = self.ivl.focus()[3] return { "Histogram" : opts } def _yscale_changed(self): self.plot.set_ylabel(self.options.option("yscale").value) def _min_changed(self): minval = self.options.option("min").value self.options.option("max").setLimits(minval=minval) def _max_changed(self): maxval = self.options.option("max").value self.options.option("min").setLimits(maxval=maxval) def _data_changed(self): if self._updating: return self._updating = True try: data_names = self.options.option("data").value vol = None if self.options.option("allvols").value: vol = self.ivl.focus()[3] dmin, dmax, multivol = None, None, False for data_name in data_names: qpdata = self.ivm.data[data_name] multivol = multivol or qpdata.nvols > 1 _dmin, _dmax = qpdata.range(vol=vol) if dmin is None or dmin > _dmin: dmin = _dmin if dmax is None or dmax > dmax: dmax = _dmax if dmin is not None and dmax is not None: self.options.option("min").value = dmin self.options.option("min").setLimits(dmin, dmax) self.options.option("max").value = dmax self.options.option("max").setLimits(dmin, dmax) self.options.set_visible("allvols", multivol) self._update() finally: self._updating = False def _update(self): opts = self.processes()["Histogram"] if opts["data"]: HistogramProcess(self.ivm).run(opts) self.plot.clear() histogram = self.ivm.extras.get("histogram", None) if histogram is not None: for idx, name in enumerate(histogram.col_headers[3:]): xvalues = [row[2] for row in histogram.arr] yvalues = [row[idx+3] for row in histogram.arr] self.plot.add_line(yvalues, name=name, xvalues=xvalues)
class FabberDceWidget(QpWidget): """ DCE modelling, using the Fabber process """ def __init__(self, **kwargs): QpWidget.__init__(self, name="Bayesian DCE", icon="dce", group="DCE-MRI", desc="DCE model fitting using Bayesian inference", **kwargs) def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) try: self.FabberProcess = get_plugins("processes", "FabberProcess")[0] except IndexError: self.FabberProcess = None if self.FabberProcess is None: vbox.addWidget( QtGui.QLabel( "Fabber core library not found.\n\n You must install Fabber to use this widget" )) return title = TitleWidget( self, help="fabber-dsc", subtitle="DSC modelling using the Fabber process %s" % __version__) vbox.addWidget(title) cite = Citation(FAB_CITE_TITLE, FAB_CITE_AUTHOR, FAB_CITE_JOURNAL) vbox.addWidget(cite) self.input = OptionBox("Input data") self.input.add("DCE data", DataOption(self.ivm, include_3d=False, include_4d=True), key="data") self.input.add("ROI", DataOption(self.ivm, data=False, rois=True), key="roi", checked=True) self.input.add("T1 map", DataOption(self.ivm, include_3d=True, include_4d=False), key="t1", checked=True) self.input.option("t1").sig_changed.connect(self._t1_map_changed) vbox.addWidget(self.input) self.acquisition = OptionBox("Acquisition") self.acquisition.add("Contrast agent R1 relaxivity (l/mmol s)", NumericOption(minval=0, maxval=10, default=3.7), key="r1") self.acquisition.add("Flip angle (\N{DEGREE SIGN})", NumericOption(minval=0, maxval=90, default=12), key="fa") self.acquisition.add("TR (ms)", NumericOption(minval=0, maxval=10, default=4.108), key="tr") self.acquisition.add("Time between volumes (s)", NumericOption(minval=0, maxval=30, default=12), key="delt") vbox.addWidget(self.acquisition) self.model = OptionBox("Model options") self.model.add( "Model", ChoiceOption([ "Standard Tofts model", "Extended Tofts model (ETM)", "2 Compartment exchange model", "Compartmental Tissue Update (CTU) model", "Adiabatic Approximation to Tissue Homogeneity (AATH) Model" ], ["dce_tofts", "dce_ETM", "dce_2CXM", "dce_CTU", "dce_AATH"]), key="model") self.model.add( "AIF", ChoiceOption([ "Population (Orton 2008)", "Population (Parker)", "Measured DCE signal", "Measured concentration curve" ], ["orton", "parker", "signal", "conc"]), key="aif") self.model.add("Bolus injection time (s)", NumericOption(minval=0, maxval=60, default=30), key="tinj") self.model.add("AIF data values", NumberListOption([ 0, ]), key="aif-data") self.model.add("T1 (s)", NumericOption(minval=0.0, maxval=5.0, default=1.0), key="t10") self.model.add("Allow T1 to vary", BoolOption(default=False), key="infer-t10") self.model.add("Bolus arrival time (s)", NumericOption(minval=0, maxval=2.0, default=0), key="delay") self.model.add("Allow bolus arrival time to vary", BoolOption(default=False), key="infer-delay") self.model.add("Infer kep rather than ve", BoolOption(default=False), key="infer-kep") self.model.add("Infer flow", BoolOption(default=True), key="infer-fp") self.model.add("Infer permeability-surface area", BoolOption(default=False), key="infer-ps") self.model.add("Spatial regularization", BoolOption(default=False), key="spatial") self.model.option("model").sig_changed.connect(self._model_changed) self.model.option("aif").sig_changed.connect(self._aif_changed) vbox.addWidget(self.model) # Run button and progress vbox.addWidget(RunWidget(self, title="Run modelling")) vbox.addStretch(1) self._aif_changed() self._model_changed() def _t1_map_changed(self): self.model.set_visible("t10", "t1" not in self.input.values()) def _aif_changed(self): aif_source = self.model.option("aif").value self.model.set_visible("tinj", aif_source not in ("signal", "conc")) self.model.set_visible("aif-data", aif_source in ("signal", "conc")) def _model_changed(self): self.model.set_visible( "infer-kep", self.model.option("model").value in ("dce_tofts", "dce_ETM")) self.model.set_visible("infer-fp", self.model.option("model").value == "dce_AATH") self.model.set_visible("infer-ps", self.model.option("model").value == "dce_AATH") def processes(self): options = { "model-group": "dce", "method": "vb", "noise": "white", "save-mean": True, "save-model-fit": True, "convergence": "trialmode", "max-trials": 20, "max-iterations": 50, "infer-sig0": True, } options.update(self.input.values()) options.update(self.acquisition.values()) options.update(self.model.values()) # Extended Tofts model is the same model name but with inference of Vp if options["model"] == "dce_ETM": options["model"] = "dce_tofts" options["infer-vp"] = True # T1 map is an image prior if "t1" in options: options.update({ "PSP_byname1": "t10", "PSP_byname1_type": "I", "PSP_byname1_image": options.pop("t1") }) if not options["infer-t10"]: # To treat the image prior as ground truth need to put T10 # into the model but give the image prior a high precision so # the parameter doesn't actually have any freedom to vary options["infer-t10"] = True options["PSP_byname1_prec"] = 1e6 # Delay time to include injection time for population AIF if "tinj" in options: options["delay"] = options["delay"] + options.pop("tinj") # Times in minutes and TR in s options["delt"] = options["delt"] / 60 options["delay"] = options["delay"] / 60 options["tr"] = options["tr"] / 1000 # Spatial mode if options.pop("spatial", False): options["method"] = "spatialvb" options["param-spatial-priors"] = "M+" return {"Fabber": options}
class FnirtRegMethod(RegMethod): """ FNIRT registration method """ def __init__(self, ivm): RegMethod.__init__(self, "fnirt", ivm, display_name="FNIRT") self.options_widget = None @classmethod def apply_transform(cls, reg_data, transform, options, queue): """ Apply a previously calculated transformation to a data set """ output_space = options.pop("output-space", "ref") if output_space not in ("ref", "reg"): raise QpException( "FNIRT does not support output in transformed space") from fsl import wrappers as fsl reg = qpdata_to_fslimage(reg_data) trans = qpdata_to_fslimage(transform) # Applywarp generates an output for each volume of reference image # for some reason. So use just the first volume of the transform # as the reference space ref = qpdata_to_fslimage(transform.volume(0, qpdata=True)) log = six.StringIO() order = options.pop("interp-order", 1) interp = _interp(order) apply_output = fsl.applywarp(reg, ref, interp=interp, paddingsize=1, super=True, superlevel="a", out=fsl.LOAD, log={ "cmd": log, "stdout": log, "stderr": log }, warp=trans, rel=True) qpdata = fslimage_to_qpdata(apply_output["out"], name=reg_data.name) if output_space == "ref": # Default is to output in reference space pass else: qpdata = qpdata.resample(reg_data.grid, suffix="", order=order) log += "Resampling onto input grid\n" return qpdata, log.getvalue() @classmethod def reg_3d(cls, reg_data, ref_data, options, queue): """ Static function for performing 3D registration FIXME return jacobian as part of xform? """ output_space = options.pop("output-space", "ref") if output_space not in ("ref", "reg"): raise QpException( "FNIRT does not support output in transformed space") from fsl import wrappers as fsl reg = qpdata_to_fslimage(reg_data) ref = qpdata_to_fslimage(ref_data) log = six.StringIO() fnirt_output = fsl.fnirt(reg, ref=ref, iout=fsl.LOAD, fout=fsl.LOAD, log={ "cmd": log, "stdout": log, "stderr": log }, **options) transform = fslimage_to_qpdata(fnirt_output["fout"], name="fnirt_warp") transform.metadata["QpReg"] = "FNIRT" if output_space == "ref": qpdata = fslimage_to_qpdata(fnirt_output["iout"], name=reg_data.name) else: qpdata = fslimage_to_qpdata(fnirt_output["iout"], name=reg_data.name).resample( reg_data.grid, suffix="") return qpdata, transform, log.getvalue() def interface(self, generic_options=None): if generic_options is None: generic_options = {} if self.options_widget is None: self.options_widget = QtGui.QWidget() vbox = QtGui.QVBoxLayout() self.options_widget.setLayout(vbox) cite = Citation(CITE_TITLE, CITE_AUTHOR, CITE_JOURNAL) vbox.addWidget(cite) self.optbox = OptionBox() self.optbox.add("Mask for registration data", DataOption(self.ivm, rois=True, data=False), key="inmask", checked=True) self.optbox.add("Mask for reference data", DataOption(self.ivm, rois=True, data=False), key="refmask", checked=True) self.optbox.add("Spline order", ChoiceOption([2, 3]), key="splineorder", checked=True) self.optbox.add("Use pre-defined configuration", ChoiceOption( ["T1_2_MNI152_2mm", "FA_2_FMRIB58_1mm"]), key="config", checked=True) vbox.addWidget(self.optbox) return self.options_widget def options(self): self.interface() return self.optbox.values()
class DceWidget(QpWidget): """ Widget for DCE Pharmacokinetic modelling """ def __init__(self, **kwargs): super(DceWidget, self).__init__(name="DCE Modelling", desc="DCE kinetic modelling", icon="dce", group="DCE-MRI", **kwargs) def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) title = TitleWidget(self, help="pk", batch_btn=True, opts_btn=False) vbox.addWidget(title) self.input = OptionBox("Input data") self.input.add("DCE data", DataOption(self.ivm, include_3d=False, include_4d=True), key="data") self.input.add("ROI", DataOption(self.ivm, data=False, rois=True), key="roi") self.input.add("T1 map", DataOption(self.ivm, include_3d=True, include_4d=False), key="t1") vbox.addWidget(self.input) self.options = OptionBox("Options") self.options.add("Contrast agent R1 relaxivity (l/mmol s)", NumericOption(minval=0, maxval=10, default=3.7), key="r1") self.options.add("Contrast agent R2 relaxivity (l/mmol s)", NumericOption(minval=0, maxval=10, default=4.8), key="r2") self.options.add("Flip angle (\N{DEGREE SIGN})", NumericOption(minval=0, maxval=90, default=12), key="fa") self.options.add("TR (ms)", NumericOption(minval=0, maxval=10, default=4.108), key="tr") self.options.add("TE (ms)", NumericOption(minval=0, maxval=10, default=1.832), key="te") self.options.add("Time between volumes (s)", NumericOption(minval=0, maxval=30, default=12), key="dt") self.options.add("Estimated injection time (s)", NumericOption(minval=0, maxval=60, default=30), key="tinj") self.options.add("Ktrans/kep percentile threshold", NumericOption(minval=0, maxval=100, default=100), key="ve-thresh") self.options.add("Dose (mM/kg) - preclinical only", NumericOption(minval=0, maxval=5, default=0.6), key="dose", visible=False) models = [ "Clinical: Toft / OrtonAIF (3rd) with offset", "Clinical: Toft / OrtonAIF (3rd) no offset", "Preclinical: Toft / BiexpAIF (Heilmann)", "Preclinical: Ext Toft / BiexpAIF (Heilmann)", ] self.options.add("Pharmacokinetic model choice", ChoiceOption(models, [1, 2, 3, 4]), key="model") self.options.option("model").sig_changed.connect(self._aif_changed) vbox.addWidget(self.options) # Run button and progress vbox.addWidget(RunWidget(self, title="Run modelling")) vbox.addStretch(1) self._aif_changed() def _aif_changed(self): self.options.set_visible("dose", self.options.option("model").value in (2, 3)) def processes(self): options = self.input.values() options.update(self.options.values()) return {"PkModelling": options}
class ResampleDataWidget(QpWidget): """ Widget that lets you resample data onto a different grid """ def __init__(self, **kwargs): super(ResampleDataWidget, self).__init__(name="Resample Data", icon="resample.png", desc="Resample data onto a different grid", group="Utilities", **kwargs) def init_ui(self): vbox = QtGui.QVBoxLayout() self.setLayout(vbox) vbox.addWidget(TitleWidget(self)) self.optbox = OptionBox("Resampling options") self.data = self.optbox.add("Data to resample", DataOption(self.ivm), key="data") self.resample_type = self.optbox.add( "Resampling method", ChoiceOption( ["On to grid from another data set", "Upsample", "Downsample"], ["data", "up", "down"]), key="type") self.grid_data = self.optbox.add("Use grid from", DataOption(self.ivm), key="grid") self.factor = self.optbox.add("Factor", NumericOption(default=2, minval=2, maxval=10, intonly=True), key="factor") self.slicewise = self.optbox.add("2D only", BoolOption(), key="2d") self.order = self.optbox.add( "Interpolation", ChoiceOption(["Nearest neighbour", "Linear", "Quadratic", "Cubic"], [0, 1, 2, 3], default=1), key="order") self.output_name = self.optbox.add("Output name", OutputNameOption(src_data=self.data, suffix="_res"), key="output-name") vbox.addWidget(self.optbox) self.resample_type.sig_changed.connect(self._resample_type_changed) self.run = RunButton("Resample", self._run) vbox.addWidget(self.run) vbox.addStretch(1) self._resample_type_changed() def _resample_type_changed(self): resample_type = self.resample_type.value self.optbox.set_visible("grid", resample_type == "data") self.optbox.set_visible("factor", resample_type != "data") self.optbox.set_visible("order", resample_type != "down") self.optbox.set_visible("2d", resample_type != "data") def batch_options(self): options = self.optbox.values() return "Resample", options def _run(self): _, options = self.batch_options() ResampleProcess(self.ivm).run(options)
class FabberVbOptions(OptionsWidget): def __init__(self, ivm, parent, acq_options): OptionsWidget.__init__(self, ivm, parent) self.acq_options = acq_options vbox = QtWidgets.QVBoxLayout() self.setLayout(vbox) cite = Citation(FAB_CITE_TITLE, FAB_CITE_AUTHOR, FAB_CITE_JOURNAL) vbox.addWidget(cite) self._optbox = OptionBox() self._optbox.add("<b>Model options</b>") self._optbox.add("Infer constant signal offset", BoolOption(default=True), key="infer-sig0") self._optbox.add("Infer delay", BoolOption(default=True), key="infer-delay") #self._optbox.add("<b>Model fitting options</b>") #self._optbox.add("Spatial regularization", BoolOption(default=True), key="spatial") self._optbox.add("<b>Output options</b>") self._optbox.add("Output data name suffix", TextOption(), checked=True, key="output-suffix") vbox.addWidget(self._optbox) vbox.addWidget(RunWidget(self, save_option=True)) vbox.addStretch(1) def processes(self): opts = { "model-group": "cvr", "model": "cvr_petco2", "save-mean": True, "save-model-fit": True, "noise": "white", "max-iterations": 10, } opts.update(self.acq_options.options()) opts.update(self._optbox.values()) # Fabber model requires the physiological data to be preprocessed from vaby.data import DataModel data_model = DataModel(opts["data"].raw(), mask=opts["mask"].raw()) from vaby_models_cvr.petco2 import CvrPetCo2Model opts["phys_data"] = opts["phys-data"] # FIXME hack model = CvrPetCo2Model(data_model, **opts) opts["phys-data"] = model.co2_mmHg opts.pop("phys_data") # Deal with the output suffix if specified suffix = opts.pop("output-suffix", "") if suffix and suffix[0] != "_": suffix = "_" + suffix opts["output-rename"] = { "mean_cvr": "cvr%s" % suffix, "mean_sig0": "sig0%s" % suffix, "mean_delay": "delay%s" % suffix, "modelfit": "modelfit%s" % suffix, } # In spatial mode use sig0 as regularization parameter if opts.pop("spatial", False): opts["method"] = "spatialvb" opts["param-spatial-priors"] = "M+" self.debug("Fabber CVR options: %s", opts) processes = [ { "Fabber": opts }, ] return processes