def init_ui(self):
layout = QtGui.QVBoxLayout()
self.setLayout(layout)
title = TitleWidget(self, help="simple_maths")
layout.addWidget(title)
info = QtGui.QLabel(MATHS_INFO)
info.setWordWrap(True)
layout.addWidget(info)
self.optbox = OptionBox()
self.optbox.add("Data space from", DataOption(self.ivm), key="grid")
self.optbox.add("Command", TextOption(), key="cmd")
self.optbox.add("Output name",
OutputNameOption(src_data=self.optbox.option("grid")),
key="output-name")
self.optbox.add("Output is an ROI", BoolOption(), key="output-is-roi")
layout.addWidget(self.optbox)
hbox = QtGui.QHBoxLayout()
self.go_btn = RunButton(self)
hbox.addWidget(self.go_btn)
hbox.addStretch(1)
layout.addLayout(hbox)
layout.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("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):
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("Number of bins",
NumericOption(minval=5,
maxval=250,
default=50,
intonly=True),
key="bins")
vbox.addWidget(self.options)
self.plot = Plot(qpo=None,
parent=self,
title="Radial profile",
display_mode=False)
self.plot.set_xlabel("Distance (mm)")
self.plot.set_ylabel("Mean data value")
vbox.addWidget(self.plot)
vbox.addStretch(1)
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_ui(self):
vbox = QtWidgets.QVBoxLayout()
self.setLayout(vbox)
title = TitleWidget(
self,
help="cvr",
subtitle="Cerebrovascular reactivity using BOLD-MRI and PETCO2 v%s"
% __version__)
vbox.addWidget(title)
self.tabs = QtWidgets.QTabWidget()
self.tabs.currentChanged.connect(self._tab_changed)
vbox.addWidget(self.tabs)
self.acquisition_opts = AcquisitionOptions(self.ivm, parent=self)
self.tabs.addTab(self.acquisition_opts, "Acquisition Options")
#self.fabber_opts = FabberVbOptions(self.ivm, self, self.acquisition_opts)
#self.tabs.addTab(self.fabber_opts, "Bayesian modelling")
self.vb_opts = VbOptions(self.ivm, self, self.acquisition_opts)
self.tabs.addTab(self.vb_opts, "Bayesian modelling")
self.glm_opts = GlmOptions(self.ivm, self, self.acquisition_opts)
self.tabs.addTab(self.glm_opts, "GLM modelling")
vbox.addStretch(1)
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 init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
try:
proc = get_plugins("processes", "FabberProcess")[0]
except:
proc = None
if proc 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="Bayesian modelling for DSC-MRI %s" %
__version__)
vbox.addWidget(title)
cite = Citation(FAB_CITE_TITLE, FAB_CITE_AUTHOR, FAB_CITE_JOURNAL)
vbox.addWidget(cite)
tabs = QtGui.QTabWidget()
vbox.addWidget(tabs)
self.dsc_widget = DscOptionsWidget(self.ivm)
tabs.addTab(self.dsc_widget, "DSC Options")
self.aif_widget = AifWidget(self.ivm)
tabs.addTab(self.aif_widget, "AIF")
vbox.addWidget(tabs)
vbox.addWidget(RunWidget(self, save_option=True))
vbox.addStretch(1)
def init_ui(self):
self.process = CalcVolumesProcess(self.ivm)
layout = QtGui.QVBoxLayout()
self.setLayout(layout)
title = TitleWidget(self, help="roi_analysis")
layout.addWidget(title)
info = QtGui.QLabel("<i><br>Calculate size and volume of an ROI<br></i>")
info.setWordWrap(True)
layout.addWidget(info)
hbox = QtGui.QHBoxLayout()
hbox.addWidget(QtGui.QLabel('ROI: '))
self.combo = RoiCombo(self.ivm)
self.combo.currentIndexChanged.connect(self.update)
hbox.addWidget(self.combo)
hbox.addStretch(1)
layout.addLayout(hbox)
self.table = QtGui.QTableView()
self.table.resizeColumnsToContents()
self.table.setModel(self.process.model)
layout.addWidget(self.table)
hbox = QtGui.QHBoxLayout()
self.copy_btn = QtGui.QPushButton("Copy")
self.copy_btn.clicked.connect(self.copy_stats)
hbox.addWidget(self.copy_btn)
hbox.addStretch(1)
layout.addLayout(hbox)
layout.addStretch(1)
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):
main_vbox = QtGui.QVBoxLayout()
self.setLayout(main_vbox)
title = TitleWidget(self,
title="Voxel analysis",
help="modelfit",
batch_btn=False)
main_vbox.addWidget(title)
self.plot = Plot(twoaxis=True)
main_vbox.addWidget(self.plot)
tabs = QtGui.QTabWidget()
main_vbox.addWidget(tabs)
# Table showing RMS deviation
self.rms_table = QtGui.QStandardItemModel()
self.rms_table.itemChanged.connect(self._data_table_changed)
tview = QtGui.QTableView()
tview.setModel(self.rms_table)
tview.horizontalHeader().setResizeMode(
QtGui.QHeaderView.ResizeToContents)
tabs.addTab(tview, "Timeseries data")
# Table showing value of model parameters
self.values_table = QtGui.QStandardItemModel()
tview = QtGui.QTableView()
tview.setModel(self.values_table)
tview.horizontalHeader().setResizeMode(
QtGui.QHeaderView.ResizeToContents)
tabs.addTab(tview, 'Non-timeseries data')
def init_ui(self):
layout = QtGui.QVBoxLayout()
title = TitleWidget(self, help="roibuilder", batch_btn=False)
layout.addWidget(title)
self.options = OptionBox("Options")
btn = QtGui.QPushButton("New")
btn.clicked.connect(self._new_roi)
self.options.add("ROI", DataOption(self.ivm, rois=True, data=False), btn, key="roi")
self.options.add("Current label", NumericOption(minval=1, slider=False, intonly=True), key="label")
self.options.add("Label description", TextOption(), key="label_text")
self.options.option("roi").sig_changed.connect(self._roi_changed)
self.options.option("label").sig_changed.connect(self._label_changed)
self.options.option("label_text").sig_changed.connect(self._label_text_changed)
layout.addWidget(self.options)
# Add toolbox buttons in a grid
hbox = QtGui.QHBoxLayout()
self._toolbox = QtGui.QGroupBox()
self._toolbox.setTitle("Toolbox")
self.tools_grid = QtGui.QGridLayout()
self._toolbox.setLayout(self.tools_grid)
x, y, cols = 0, 0, 4
for tool in TOOLS:
self._add_tool(tool, y, x)
x += 1
if x == cols:
y += 1
x = 0
self._undo_btn = QtGui.QPushButton()
self._undo_btn.clicked.connect(self.undo)
self._undo_btn.setEnabled(False)
undo_icon = QtGui.QIcon(get_icon("undo"))
self._undo_btn.setIcon(undo_icon)
self._undo_btn.setToolTip("Undo last action")
self._undo_btn.setFixedSize(32, 32)
self.tools_grid.addWidget(self._undo_btn, y, x)
hbox.addWidget(self._toolbox)
self._toolbox.setEnabled(False)
hbox.addStretch(1)
layout.addLayout(hbox)
# Tool options box - initially invisible
hbox = QtGui.QHBoxLayout()
self._tool_options = QtGui.QGroupBox()
self._tool_options.setVisible(False)
hbox.addWidget(self._tool_options)
hbox.addStretch(1)
layout.addLayout(hbox)
layout.addStretch(1)
self.setLayout(layout)
def init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
try:
self.fabber_process = get_plugins("processes", "FabberProcess")[0]
except:
self.fabber_process = None
if self.fabber_process 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="cest",
subtitle=
"Bayesian Modelling for Chemical Exchange Saturation Transfer MRI %s"
% __version__)
vbox.addWidget(title)
cite = Citation(CEST_CITE_TITLE, CEST_CITE_AUTHOR, CEST_CITE_JOURNAL)
vbox.addWidget(cite)
self.tabs = QtGui.QTabWidget()
self.seqtab = SequenceOptions(self.ivm)
self.tabs.addTab(self.seqtab, "Sequence")
self.pooltab = PoolOptions(self.ivm)
self.tabs.addTab(self.pooltab, "Pools")
self.analysistab = AnalysisOptions(self.ivm)
self.tabs.addTab(self.analysistab, "Analysis")
self.pooltab.sig_pools_changed.connect(self.analysistab.set_pools)
self.seqtab.sig_b0_changed.connect(self.pooltab.set_b0)
vbox.addWidget(self.tabs)
run_tabs = QtGui.QTabWidget()
run_box = RunBox(self._get_process_model,
self._options,
title="Run model-based analysis",
save_option=True)
run_tabs.addTab(run_box, "Model based analysis")
run_box = RunBox(self._get_process_lda,
self._options_lda,
title="Run Lorentzian Difference analysis",
save_option=True)
run_tabs.addTab(run_box, "Lorentzian Difference analysis")
vbox.addWidget(run_tabs)
vbox.addStretch(1)
self.analysistab.set_pools(self.pooltab.pools)
def init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
title = TitleWidget(
self,
help="asl",
subtitle="Data processing for Arterial Spin Labelling MRI")
vbox.addWidget(title)
cite = Citation(FAB_CITE_TITLE, FAB_CITE_AUTHOR, FAB_CITE_JOURNAL)
vbox.addWidget(cite)
self.tabs = QtGui.QTabWidget()
vbox.addWidget(self.tabs)
self.asldata = AslImageWidget(self.ivm, parent=self)
self.asldata.sig_changed.connect(self._data_changed)
self.tabs.addTab(self.asldata, "ASL data")
self.preproc = PreprocOptions(self.ivm)
self.preproc.sig_enable_tab.connect(self._enable_tab)
self.tabs.addTab(self.preproc, "Corrections")
# Only add these if appropriate
self._optional_tabs = {
"veasl": VeaslOptions(self.ivm, self.asldata),
"enable": EnableOptions(self.ivm),
"deblur": DeblurOptions(),
}
self.structural = StructuralData(self.ivm)
self.tabs.addTab(self.structural, "Structural data")
self.calibration = CalibrationOptions(self.ivm)
self.tabs.addTab(self.calibration, "Calibration")
self.analysis = AnalysisOptions(self.ivm)
self.analysis.optbox.option("wp").sig_changed.connect(self._wp_changed)
self.tabs.addTab(self.analysis, "Analysis")
self.output = OutputOptions()
self.tabs.addTab(self.output, "Output")
runbox = RunWidget(self, title="Run processing", save_option=True)
runbox.sig_postrun.connect(self._postrun)
vbox.addWidget(runbox)
vbox.addStretch(1)
fsldir_qwidgets = get_plugins("qwidgets", "FslDirWidget")
if len(fsldir_qwidgets) > 0:
fsldir = fsldir_qwidgets[0]()
vbox.addWidget(fsldir)
def __init__(self, **kwargs):
super(MeanValuesWidget, self).__init__(
name="Mean in ROI",
icon="meanvals",
desc="Replace data with its mean value within each ROI region",
group="ROIs",
**kwargs)
layout = QtGui.QVBoxLayout()
title = TitleWidget(self,
"Generate Mean Values Data",
help="mean_values")
layout.addWidget(title)
desc = QtGui.QLabel(
"This widget will convert the current data set into a "
"new data set in which each ROI region contains the mean "
"value for that region.\n\nThis is generally only useful for "
"multi-level ROIs such as clusters or supervoxels")
desc.setWordWrap(True)
layout.addWidget(desc)
hbox = QtGui.QHBoxLayout()
gbox = QtGui.QGroupBox()
gbox.setTitle("Options")
grid = QtGui.QGridLayout()
gbox.setLayout(grid)
grid.addWidget(QtGui.QLabel("Data"), 0, 0)
self.ovl = OverlayCombo(self.ivm)
self.ovl.currentIndexChanged.connect(self._data_changed)
grid.addWidget(self.ovl, 0, 1)
grid.addWidget(QtGui.QLabel("ROI regions"), 1, 0)
self.roi = RoiCombo(self.ivm)
grid.addWidget(self.roi, 1, 1)
grid.addWidget(QtGui.QLabel("Output name"), 2, 0)
self.output_name = QtGui.QLineEdit()
grid.addWidget(self.output_name, 2, 1)
btn = QtGui.QPushButton('Generate', self)
btn.clicked.connect(self._generate)
grid.addWidget(btn, 2, 0)
hbox.addWidget(gbox)
hbox.addStretch(1)
layout.addLayout(hbox)
layout.addStretch(1)
self.setLayout(layout)
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):
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 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_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 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 init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
title = TitleWidget(self,
title="Data Smoothing",
subtitle="Smooth data using a Gaussian kernel",
help="smoothing")
vbox.addWidget(title)
hbox = QtGui.QHBoxLayout()
gbox = QtGui.QGroupBox()
gbox.setTitle("Options")
grid = QtGui.QGridLayout()
gbox.setLayout(grid)
grid.addWidget(QtGui.QLabel("Data to smooth"), 0, 0)
self.data_combo = OverlayCombo(self.ivm)
self.data_combo.currentIndexChanged.connect(self.data_changed)
grid.addWidget(self.data_combo, 0, 1)
self.sigma = NumericOption("Sigma (mm)",
grid,
xpos=0,
ypos=1,
minval=0,
step=0.1,
default=1.0)
grid.addWidget(QtGui.QLabel("Output name"), 2, 0)
self.output_name = QtGui.QLineEdit()
grid.addWidget(self.output_name, 2, 1)
hbox.addWidget(gbox)
hbox.addStretch(1)
vbox.addLayout(hbox)
hbox = QtGui.QHBoxLayout()
self.run_btn = QtGui.QPushButton("Run")
self.run_btn.clicked.connect(self.run)
hbox.addWidget(self.run_btn)
hbox.addStretch(1)
vbox.addLayout(hbox)
vbox.addStretch(1)
self.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 init_ui(self):
main_vbox = QtGui.QVBoxLayout()
self.setLayout(main_vbox)
title = TitleWidget(
self,
help="generic/datasim",
subtitle=
"Simulates data for various imaging sequences, from known parameter inputs %s"
% __version__)
main_vbox.addWidget(title)
self.tabs = QtGui.QTabWidget()
main_vbox.addWidget(self.tabs)
self.struc_model = ModelOptions(self.ivm,
parent=self,
model_type="Structural",
abbrev="struc",
model_classes=get_struc_models())
self.struc_model.sig_changed.connect(self._update_params)
self.data_model = ModelOptions(self.ivm,
parent=self,
model_type="Data",
abbrev="data",
model_classes=get_data_models())
self.data_model.sig_changed.connect(self._update_params)
self.params = ParamsOptions(self.ivm, parent=self)
self.noise = NoiseOptions(self.ivm, parent=self)
self.motion = MotionOptions(self.ivm, parent=self)
self.output = OutputOptions(self.ivm, parent=self)
self.tabs.addTab(self.struc_model, "Structure model")
self.tabs.addTab(self.data_model, "Data model")
self.tabs.addTab(self.params, "Parameter values")
self.tabs.addTab(self.noise, "Noise")
self.tabs.addTab(self.motion, "Motion")
self.tabs.addTab(self.output, "Output")
main_vbox.addStretch(1)
main_vbox.addWidget(RunWidget(self))
self._update_params()
def init_ui(self):
layout = QtGui.QVBoxLayout()
self.setLayout(layout)
title = TitleWidget(self, "Supervoxel Generation", help="sv")
layout.addWidget(title)
cite = Citation(CITE_TITLE, CITE_AUTHOR, CITE_JOURNAL)
layout.addWidget(cite)
hbox = QtGui.QHBoxLayout()
optbox = QtGui.QGroupBox()
optbox.setTitle("Options")
grid = QtGui.QGridLayout()
optbox.setLayout(grid)
grid.addWidget(QtGui.QLabel("Data"), 0, 0)
self.ovl = OverlayCombo(self.ivm)
self.ovl.currentIndexChanged.connect(self._data_changed)
grid.addWidget(self.ovl, 0, 1)
grid.addWidget(QtGui.QLabel("ROI"), 1, 0)
self.roi = RoiCombo(self.ivm)
grid.addWidget(self.roi, 1, 1)
self.n_comp = NumericOption("Number of components", grid, 2, minval=1, maxval=3, default=3, intonly=True)
self.compactness = NumericOption("Compactness", grid, 3, minval=0.01, maxval=1, step=0.05, default=0.1, intonly=False)
self.sigma = NumericOption("Smoothing", grid, 4, minval=0, maxval=5, step=0.1, default=1, intonly=False)
self.n_supervoxels = NumericOption("Number of supervoxels", grid, 5, minval=2, maxval=1000, default=20, intonly=True)
grid.addWidget(QtGui.QLabel("Output name"), 6, 0)
self.output_name = QtGui.QLineEdit("supervoxels")
grid.addWidget(self.output_name, 6, 1)
self.gen_btn = QtGui.QPushButton('Generate', self)
self.gen_btn.clicked.connect(self._generate)
grid.addWidget(self.gen_btn, 7, 0)
hbox.addWidget(optbox)
hbox.addStretch(1)
layout.addLayout(hbox)
layout.addStretch(1)
def init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
title = TitleWidget(self,
title="Batch Builder",
subtitle=self.description,
batch_btn=False)
vbox.addWidget(title)
self.proc_edit = QtGui.QPlainTextEdit()
self.proc_edit.textChanged.connect(self._validate)
vbox.addWidget(self.proc_edit, stretch=2)
hbox = QtGui.QHBoxLayout()
#self.new_case_btn = QtGui.QPushButton("New Case")
#hbox.addWidget(self.new_case_btn)
#hbox.setAlignment(self.new_case_btn, QtCore.Qt.AlignTop)
self.reset_btn = QtGui.QPushButton("Reset")
self.reset_btn.clicked.connect(self._reset)
hbox.addWidget(self.reset_btn)
hbox.addStretch(1)
self.save_btn = QtGui.QPushButton("Save")
self.save_btn.clicked.connect(self._save)
hbox.addWidget(self.save_btn)
vbox.addLayout(hbox)
self.run_box = RunBox(self._get_process, self._get_options)
vbox.addWidget(self.run_box)
self.proc_warn = QtGui.QLabel("")
self.proc_warn.setStyleSheet("QLabel { color : red; }")
vbox.addWidget(self.proc_warn)
self.default_dir = os.getcwd()
self.changed = False
self._reset()
def init_ui(self):
vbox = QtGui.QVBoxLayout()
vbox.setSpacing(1)
self.setLayout(vbox)
vbox.addWidget(TitleWidget(self))
vbox.addWidget(Citation(*CITATIONS["fsl"]))
self.atlas_list = AtlasListWidget(self, self._registry)
vbox.addWidget(self.atlas_list)
self.atlas_desc = AtlasDescription(self, self._registry)
vbox.addWidget(self.atlas_desc)
self.atlas_list.sig_selected.connect(self.atlas_desc.set_atlas)
fsldir = FslDirWidget()
vbox.addWidget(fsldir)
# This needs to be done after creating the FslDirWidget because otherwise we may not
# have picked up a previously saved FSLDIR setting and the atlas list will be empty
self._registry.rescanAtlases()
self.atlas_list.init_list()
def init_ui(self):
vbox = QtGui.QVBoxLayout()
self.setLayout(vbox)
vbox.addWidget(TitleWidget(self))
vbox.addWidget(Citation(*CITATIONS["fsl"]))
self.data_list = FslDataListWidget(self)
vbox.addWidget(self.data_list)
self.data_list.sig_selected.connect(self._data_selected)
hbox = QtGui.QHBoxLayout()
self._load_btn = QtGui.QPushButton("Load")
self._load_btn.clicked.connect(self._load)
hbox.addWidget(self._load_btn)
hbox.addWidget(QtGui.QLabel("Dataset name: "))
self._load_name = QtGui.QLineEdit()
hbox.addWidget(self._load_name)
vbox.addLayout(hbox)
fsldir = FslDirWidget()
vbox.addWidget(fsldir)
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):
main_vbox = QtGui.QVBoxLayout()
self.setLayout(main_vbox)
title = TitleWidget(self, title="Voxel analysis", help="modelfit", batch_btn=False)
main_vbox.addWidget(title)
self.plot = Plot(twoaxis=True)
main_vbox.addWidget(self.plot)
hbox = QtGui.QHBoxLayout()
# Table showing RMS deviation
rms_box = QtGui.QGroupBox()
rms_box.setTitle('Timeseries data')
vbox = QtGui.QVBoxLayout()
self.rms_table = QtGui.QStandardItemModel()
self.rms_table.itemChanged.connect(self._data_table_changed)
tview = QtGui.QTableView()
tview.resizeColumnsToContents()
tview.setModel(self.rms_table)
vbox.addWidget(tview)
rms_box.setLayout(vbox)
hbox.addWidget(rms_box)
# Table showing value of model parameters
params_box = QtGui.QGroupBox()
params_box.setTitle('Non-timeseries data')
vbox2 = QtGui.QVBoxLayout()
self.values_table = QtGui.QStandardItemModel()
tview = QtGui.QTableView()
tview.resizeColumnsToContents()
tview.setModel(self.values_table)
vbox2.addWidget(tview)
params_box.setLayout(vbox2)
hbox.addWidget(params_box)
main_vbox.addLayout(hbox)
def init_ui(self):
layout = QtGui.QVBoxLayout()
self.setLayout(layout)
title = TitleWidget(self)
layout.addWidget(title)
box = QtGui.QGroupBox("Measurements")
vbox = QtGui.QVBoxLayout()
box.setLayout(vbox)
self._dist_btn = QtGui.QPushButton("Measure distance")
self._dist_btn.clicked.connect(self._measure_dist)
vbox.addWidget(self._dist_btn)
self._angle_btn = QtGui.QPushButton("Measure angle")
self._angle_btn.clicked.connect(self._measure_angle)
vbox.addWidget(self._angle_btn)
self._label = QtGui.QLabel()
vbox.addWidget(self._label)
layout.addWidget(box)
layout.addStretch(1)