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 __init__(self, parent, ivm, existing_strucs):
super(AddEmbeddingDialog, self).__init__(parent)
self.ivm = ivm
self.sel_text = None
self.sel_data = None
self.existing_names = [struc.name for struc in existing_strucs]
self.setWindowTitle("Add embedding")
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
self._opts = OptionBox()
pvmap = self._opts.add("PV map / mask", DataOption(ivm, data=True, rois=True), key="pvmap")
pvmap.sig_changed.connect(self._pvmap_changed)
self._opts.add("ROI region", ChoiceOption([]), key="region")
name = self._opts.add("Name of embedded structure", TextOption(), key="name")
name.textChanged.connect(self._name_changed)
self._opts.add("Structure type", ChoiceOption(["Embedding", "Activation mask", "Additional PVE"], return_values=["embed", "act", "add"]), key="type")
self._opts.add("Parent structure", ChoiceOption([s.display_name for s in existing_strucs], [s.name for s in existing_strucs]), key="parent")
self._opts.add("Edge smoothing sigma (mm)", NumericOption(minval=0, maxval=10, default=1, decimals=2), checked=True, enabled=False, key="sigma")
vbox.addWidget(self._opts)
self._warning = QtWidgets.QLabel(parent=self)
self._warning.setStyleSheet("color: red;")
vbox.addWidget(self._warning)
self.button_box = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel)
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.reject)
self.button_box.button(QtGui.QDialogButtonBox.Ok).setEnabled(False)
vbox.addWidget(self.button_box)
self._pvmap_changed()
def _init_ui(self):
self.optbox.add("Motion correction",
BoolOption(default=True),
key="mc")
#opt = self.optbox.add("Deblurring", BoolOption(), key="deblur")
#opt.sig_changed.connect(self._deblur_changed)
opt = self.optbox.add("ENABLE volume selection",
BoolOption(),
key="use_enable")
opt.sig_changed.connect(self._enable_changed)
self.optbox.add(
"Distortion correction",
ChoiceOption(["Fieldmap", "Phase encoding reversed calibration"],
["fmap", "cblip"]),
key="distcorr",
checked=True)
self.optbox.option("distcorr").sig_changed.connect(
self._distcorr_changed)
self.optbox.add("Phase encode direction",
ChoiceOption(["x", "y", "z", "-x", "-y", "-z"]),
key="pedir")
self.optbox.add("Echo spacing (ms)",
NumericOption(minval=0,
maxval=1,
step=0.01,
decimals=3),
key="echospacing")
self.fmap_opts = OptionBox("Fieldmap distortion correction")
self.fmap_opts.add("Fieldmap image (rads)",
DataOption(self.ivm,
include_4d=False,
explicit=True),
key="fmap")
self.fmap_opts.add("Fieldmap magnitude image (rads)",
DataOption(self.ivm,
include_4d=False,
explicit=True),
key="fmapmag")
self.fmap_opts.add("Fieldmap magnitude brain image (rads)",
DataOption(self.ivm,
include_4d=False,
explicit=True),
key="fmapmagbrain")
self.vbox.addWidget(self.fmap_opts)
self.cblip_opts = OptionBox(
"Phase-encoding reversed distortion correction")
self.cblip_opts.add("Phase-encode reversed image",
DataOption(self.ivm,
include_4d=False,
explicit=True),
key="cblip")
self.vbox.addWidget(self.cblip_opts)
self._distcorr_changed()
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 __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 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 _init_ui(self):
self.optbox.add("Distortion correction type",
ChoiceOption(["None", "Fieldmap", "CBLIP"],
[None, "fmap", "cblip"]),
key="distcorr_type")
self.optbox.option("distcorr_type").sig_changed.connect(
self._distcorr_type_changed)
def _refresh_gui(self):
options = dict(self.model.options)
self.gui.clear()
for struc in self.model.default_strucs:
data_opt = self.gui.add("%s map" % struc.name.upper(), DataOption(self.model._ivm, explicit=True), checked=True, enabled=struc.name in options["pvmaps"], key=struc.name)
data_opt.value = options["pvmaps"].get(struc.name, None)
for struc in options["additional"].values():
del_btn = self._struc_delete_btn(struc)
display_type = {"add" : "map", "embed" : "embedding", "act" : "mask"}.get(struc["struc_type"], "map")
data_opt = self.gui.add("%s %s" % (struc["name"], display_type), DataOption(self.model._ivm, explicit=True, rois=True), del_btn, key=struc["name"])
data_opt.value = struc.get("pvmap", None)
res_opts = options.get("resampling", {})
self.gui.add("Resampling", ChoiceOption(["Downsample", "From another data set", "Specified resolution"], ["down", "data", "res"],
default=res_opts.get("type", "res")), checked=True, enabled="type" in res_opts, key="type")
self.gui.add("Output space from", DataOption(self.ivm), key="grid")
self.gui.add("Output resample factor", NumericOption(intonly=True, minval=1, maxval=10, default=2), key="factor")
self.gui.add("Voxel sizes (mm)", NumberListOption(load_btn=False), key="voxel-sizes")
for opt in ("grid", "factor", "voxel-sizes"):
if opt in res_opts:
self.gui.option(opt).value = res_opts[opt]
self.gui.add(None, RunButton("Add user-defined structure", callback=self._add_embedding), key="add_embedding")
self._update_resamp_visibility()
def init_ui(self):
FslWidget.init_ui(self)
self.options.add("Input structural data",
DataOption(self.ivm),
key="data")
self.options.add("Image type",
ChoiceOption(
["T1 weighted", "T2 weighted", "Proton Density"],
return_values=["T1", "T2", "PD"]),
key="img_type")
self.options.add("Strong bias field", BoolOption(), key="strongbias")
self.options.add("Re-orientation to standard space",
BoolOption(invert=True),
key="noreorient")
self.options.add("Automatic cropping",
BoolOption(invert=True),
key="nocrop")
self.options.add("Bias field correction",
BoolOption(invert=True),
key="nobias")
#self.options.add("Registration to standard space", BoolOption(invert=True), key="noreg")
#self.options.add("Non-linear registration", BoolOption(invert=True), key="nononlinreg")
self.options.add("Segmentation", BoolOption(invert=True), key="noseg")
self.options.add("Sub-cortical segmentation",
BoolOption(invert=True),
key="nosubcortseg")
self.options.add("BET Intensity threshold",
NumericOption(minval=0, maxval=1, default=0.5),
key="betfparam")
self.options.add("Bias field smoothing extent (mm)",
NumericOption(minval=0, maxval=100, default=20),
key="bias_smoothing")
def init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
title = TitleWidget(self)
vbox.addWidget(title)
self._options = OptionBox("Options")
self._options.add("Signal data", DataOption(self.ivm), key="data")
self._clear_btn = QtGui.QPushButton("Clear points")
self._options.add("Method", ChoiceOption(["Pick points", "Use existing ROI"], ["points", "roi"]), self._clear_btn, key="method")
self._options.add("ROI", DataOption(self.ivm, data=False, rois=True), key="roi")
self._view_btn = QtGui.QPushButton("View")
self._view_btn.setEnabled(False)
self._save_btn = QtGui.QPushButton("Save")
self._save_btn.setEnabled(False)
self._options.add("AIF name", TextOption("aif"), self._view_btn, self._save_btn, key="output-name")
self._options.option("method").sig_changed.connect(self._method_changed)
self._options.option("data").sig_changed.connect(self._recalc_aif)
self._options.option("roi").sig_changed.connect(self._recalc_aif)
self._clear_btn.clicked.connect(self._clear_btn_clicked)
self._save_btn.clicked.connect(self._save_btn_clicked)
self._view_btn.clicked.connect(self._view_btn_clicked)
vbox.addWidget(self._options)
self._plot = Plot(qpo=None, parent=self, title="AIF", display_mode=False)
self._plot.set_xlabel("Volume")
self._plot.set_ylabel("Signal")
vbox.addWidget(self._plot)
vbox.addStretch(1)
def init_ui(self):
self.setStatusTip("Click points on the 4D volume to see data curve")
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
title = TitleWidget(self, "Multi-Voxel Visualisation", help="curve_compare", batch_btn=False)
vbox.addWidget(title)
self.plot = Plot(clear_btn=True)
self.plot.clear_btn.clicked.connect(self._clear)
self.plot.options.sig_options_changed.connect(self._options_changed)
vbox.addWidget(self.plot)
self.options = OptionBox("Options")
self.options.add("Data set", DataOption(self.ivm, include_3d=False), key="data")
col_names = [text for text in self.colors]
cols = [col for text, col in self.colors.items()]
self.options.add("Plot colour", ChoiceOption(col_names, cols, default="red"), key="col")
self.options.add("Show individual curves", BoolOption(default=True), key="indiv")
self.options.add("Show mean curve", BoolOption(), key="mean")
self.options.option("data").sig_changed.connect(self._data_changed)
self.options.option("indiv").sig_changed.connect(self._indiv_changed)
self.options.option("mean").sig_changed.connect(self._mean_changed)
self.options.option("col").sig_changed.connect(self._col_changed)
hbox = QtGui.QHBoxLayout()
hbox.addWidget(self.options)
hbox.addStretch()
vbox.addLayout(hbox)
vbox.addStretch(1)
self._options_changed()
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 __init__(self, ivm, parent, model_type, abbrev, model_classes):
OptionsWidget.__init__(self, ivm, parent)
self._views = {}
self.model = None
self.view = None
self._option_name = "%s-model" % abbrev
for name, cls in model_classes.items():
self._views[name] = get_view_class(cls)(ivm)
main_vbox = QtGui.QVBoxLayout()
self.setLayout(main_vbox)
self.options = OptionBox()
self.options.add(
"%s model" % model_type,
ChoiceOption([v.model.display_name for v in self._views.values()],
self._views.keys()),
key=self._option_name)
self.options.option(self._option_name).sig_changed.connect(
self._model_changed)
main_vbox.addWidget(self.options)
self._create_guis(main_vbox)
main_vbox.addStretch(1)
self._model_changed()
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 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 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 __init__(self, ivl, rois=True, data=True):
OptionBox.__init__(self, border=True)
self.ivl = ivl
self.ivm = ivl.ivm
self._qpdata = None
self._no_update = False
self.grid.setVerticalSpacing(2)
self._view_btn = QtGui.QPushButton()
self._view_btn.setIcon(QtGui.QIcon(get_icon("visible.png")))
self._view_btn.setFixedSize(16, 16)
self._view_btn.setToolTip("Visibility")
self._view_btn.clicked.connect(self._view_btn_clicked)
self._data = self.add("Data" if data else "ROI",
DataOption(self.ivm,
data=data,
rois=rois,
follow_current=True),
self._view_btn,
key="data")
self._view_roi = self.add("View ROI",
DataOption(self.ivm, data=False, rois=True),
checked=True,
key="view_roi")
self._levels_btn = QtGui.QPushButton()
self._levels_btn.setIcon(QtGui.QIcon(get_icon("levels.png")))
self._levels_btn.setFixedSize(16, 16)
self._levels_btn.setToolTip("Adjust colour map levels")
self._levels_btn.clicked.connect(self._levels_clicked)
self._cmap = self.add("Colour map",
ChoiceOption([
"jet", "hot", "gist_heat", "flame",
"bipolar", "spectrum", "custom"
]),
self._levels_btn,
key="cmap")
self._alpha = self.add("Alpha",
NumericOption(minval=0,
maxval=255,
default=255,
edit=False,
intonly=True),
key="alpha")
self._value_label = QtGui.QLabel()
self.add("Value", self._value_label)
self.add("", stretch=2)
self._data.sig_changed.connect(self._data_changed)
self._view_roi.sig_changed.connect(self._view_roi_changed)
self._cmap.sig_changed.connect(self._cmap_changed)
self._alpha.sig_changed.connect(self._alpha_changed)
self.ivl.sig_focus_changed.connect(self._focus_changed)
self.qpdata = None
def init_ui(self):
FslWidget.init_ui(self)
self.options.add("Structural image (brain extracted)",
DataOption(self.ivm, include_4d=False),
key="data")
self.options.add("Image type",
ChoiceOption(
["T1 weighted", "T2 weighted", "Proton Density"],
return_values=[1, 2, 3]),
key="type")
self.options.add("Number of tissue type classes",
NumericOption(intonly=True,
minval=2,
maxval=10,
default=3),
key="class")
self.options.add("Output estimated bias field",
BoolOption(),
key="biasfield")
self.options.add("Output bias-corrected image",
BoolOption(),
key="biascorr")
self.options.add("Remove bias field",
BoolOption(default=True),
key="nobias")
self.options.add("Bias field smoothing extent (mm)",
NumericOption(minval=0, maxval=100, default=20),
key="lowpass")
self.options.add(
"Number of main-loop iterations during bias-field removal",
NumericOption(intonly=True, minval=1, maxval=10, default=4),
key="iter")
self.options.add(
"Number of main-loop iterations after bias-field removal",
NumericOption(intonly=True, minval=1, maxval=10, default=4),
key="fixed")
self.options.add("Number of segmentation iterations",
NumericOption(intonly=True,
minval=1,
maxval=100,
default=15),
key="init")
self.options.add("Initial segmentation spatial smoothness",
NumericOption(minval=0, maxval=1, default=0.02),
key="fHard")
self.options.add("Spatial smoothness for mixeltype",
NumericOption(minval=0, maxval=5, default=0.3),
key="mixel")
self.options.add("Segmentation spatial smoothness",
NumericOption(minval=0, maxval=5, default=0.1),
key="Hyper")
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 __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 init_ui(self):
FabberWidget.init_ui(self)
self.run_box = RunBox(self.get_process, self.get_options, title="Run Fabber", save_option=True)
self.vbox.addWidget(self.run_box)
self.vbox.addStretch(1)
model_opts_btn = QtGui.QPushButton('Model Options')
method_opts_btn = QtGui.QPushButton('Method Options')
edit_priors_btn = QtGui.QPushButton('Edit Priors')
options_btn = QtGui.QPushButton('Edit')
self.options.add("Main input data", DataOption(self.ivm), key="data")
self.options.add("Model group", ChoiceOption(), key="model-group")
self.options.add("Model", ChoiceOption(), model_opts_btn, key="model")
self.options.add("Parameter priors", edit_priors_btn)
self.options.add("Inference method", ChoiceOption(), method_opts_btn, key="method")
self.options.add("General options", options_btn)
self.options.option("model-group").sig_changed.connect(self._model_group_changed)
method_opts_btn.clicked.connect(self._show_method_options)
model_opts_btn.clicked.connect(self._show_model_options)
edit_priors_btn.clicked.connect(self._show_prior_options)
options_btn.clicked.connect(self._show_general_options)
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.option("method").setChoices(FabberProcess.api().get_methods())
self.options.option("method").value = "vb"
self._options_changed()
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("Random translation standard deviation (mm)",
NumericOption(minval=0,
maxval=5,
default=1,
decimals=2),
key="std")
self.option_box.add(
"Random rotation standard deviation (\N{DEGREE SIGN})",
NumericOption(minval=0, maxval=10, default=1, decimals=2),
key="std_rot")
self.option_box.add("Padding (mm)",
NumericOption(minval=0,
maxval=10,
default=5,
decimals=1),
key="padding",
checked=True)
self.option_box.add(
"Interpolation",
ChoiceOption(["Nearest neighbour", "Linear", "Quadratic", "Cubic"],
return_values=range(4),
default=3),
key="order")
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 __init__(self, ivm, parent):
OptionsWidget.__init__(self, ivm, parent)
main_vbox = QtGui.QVBoxLayout()
self.setLayout(main_vbox)
self.options = OptionBox()
self.options.add("Simulate motion",
BoolOption(default=False),
key="motion")
self.options.option("motion").sig_changed.connect(
self._update_widget_visibility)
self.options.add("Random translation standard deviation (mm)",
NumericOption(minval=0,
maxval=5,
default=1,
decimals=2),
key="std")
self.options.add(
"Random rotation standard deviation (\N{DEGREE SIGN})",
NumericOption(minval=0, maxval=10, default=1, decimals=2),
key="std_rot")
self.options.add("Padding (mm)",
NumericOption(minval=0,
maxval=10,
default=5,
decimals=1),
key="padding",
checked=True)
self.options.add(
"Interpolation",
ChoiceOption(["Nearest neighbour", "Linear", "Quadratic", "Cubic"],
return_values=range(4),
default=3),
key="order")
main_vbox.addWidget(self.options)
main_vbox.addStretch(1)
self._update_widget_visibility()
def init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
vbox.addWidget(TitleWidget(self))
optbox = OptionBox("Resampling options")
self.data = optbox.add("Data to resample", DataOption(self.ivm))
self.grid_data = optbox.add("Resample onto grid from",
DataOption(self.ivm))
self.order = optbox.add(
"Interpolation",
ChoiceOption(["Nearest neighbour", "Linear", "Quadratic", "Cubic"],
[0, 1, 2, 3]))
self.output_name = optbox.add(
"Output name", OutputNameOption(src_data=self.data, suffix="_res"))
vbox.addWidget(optbox)
self.run = RunButton("Resample", self._run)
vbox.addWidget(self.run)
vbox.addStretch(1)
def _init_ui(self):
self.optbox.add(
"Structural data from",
ChoiceOption(
["No structural data", "Structural image", "FSL_ANAT output"],
[None, "img", "fsl_anat"]),
key="struc_src")
self.optbox.option("struc_src").sig_changed.connect(
self._data_from_changed)
self.optbox.add("Structural image",
DataOption(self.ivm, include_4d=False, explicit=True),
key="struc")
self.optbox.add("FSL_ANAT directory",
FileOption(dirs=True),
key="fslanat")
self.optbox.set_visible("fslanat", False)
self.optbox.add("")
self.optbox.add("<b>Override automatic segmentation</b>",
key="override_label")
self.optbox.add("Brain image",
DataOption(self.ivm, include_4d=False, explicit=True),
key="struc_bet",
checked=True)
self.optbox.add("White matter",
DataOption(self.ivm, include_4d=False, explicit=True),
key="wmseg",
checked=True)
self.optbox.add("Grey matter",
DataOption(self.ivm, include_4d=False, explicit=True),
key="gmseg",
checked=True)
self.optbox.add("CSF",
DataOption(self.ivm, include_4d=False, explicit=True),
key="csfseg",
checked=True)
self._data_from_changed()
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 __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 __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 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 __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()
