def create(self):
super(WandEffectOptions,self).create()
self.toleranceFrame = qt.QFrame(self.frame)
self.toleranceFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.toleranceFrame)
self.widgets.append(self.toleranceFrame)
self.toleranceLabel = qt.QLabel("Tolerance:", self.toleranceFrame)
self.toleranceLabel.setToolTip("Set the tolerance of the wand in terms of background pixel values")
self.toleranceFrame.layout().addWidget(self.toleranceLabel)
self.widgets.append(self.toleranceLabel)
self.toleranceSpinBox = qt.QDoubleSpinBox(self.toleranceFrame)
self.toleranceSpinBox.setToolTip("Set the tolerance of the wand in terms of background pixel values")
self.toleranceSpinBox.minimum = 0
self.toleranceSpinBox.maximum = 1000
self.toleranceSpinBox.suffix = ""
self.toleranceFrame.layout().addWidget(self.toleranceSpinBox)
self.widgets.append(self.toleranceSpinBox)
self.maxPixelsFrame = qt.QFrame(self.frame)
self.maxPixelsFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.maxPixelsFrame)
self.widgets.append(self.maxPixelsFrame)
self.maxPixelsLabel = qt.QLabel("Max Pixels per click:", self.maxPixelsFrame)
self.maxPixelsLabel.setToolTip("Set the maxPixels for each click")
self.maxPixelsFrame.layout().addWidget(self.maxPixelsLabel)
self.widgets.append(self.maxPixelsLabel)
self.maxPixelsSpinBox = qt.QDoubleSpinBox(self.maxPixelsFrame)
self.maxPixelsSpinBox.setToolTip("Set the maxPixels for each click")
self.maxPixelsSpinBox.minimum = 1
self.maxPixelsSpinBox.maximum = 100000
self.maxPixelsSpinBox.suffix = ""
self.maxPixelsFrame.layout().addWidget(self.maxPixelsSpinBox)
self.widgets.append(self.maxPixelsSpinBox)
HelpButton(self.frame, "Use this tool to label all voxels that are within a tolerance of where you click")
# don't connect the signals and slots directly - instead, add these
# to the list of connections so that gui callbacks can be cleanly
# disabled while the gui is being updated. This allows several gui
# elements to be interlinked with signal/slots but still get updated
# as a unit to the new value of the mrml node.
self.connections.append(
(self.toleranceSpinBox, 'valueChanged(double)', self.onToleranceSpinBoxChanged) )
self.connections.append(
(self.maxPixelsSpinBox, 'valueChanged(double)', self.onMaxPixelsSpinBoxChanged) )
# Add vertical spacer
self.frame.layout().addStretch(1)
def setup(self):
frame = qt.QFrame()
layout = qt.QFormLayout()
frame.setLayout(layout)
self.parent.layout().addWidget(frame)
# Dose Volume selector
self.referenceDoseVolumeSelectorLabel = qt.QLabel()
self.referenceDoseVolumeSelectorLabel.setText(
"Reference Dose Volume : ")
self.referenceDoseVolumeSelector = slicer.qMRMLNodeComboBox()
self.referenceDoseVolumeSelector.nodeTypes = (
"vtkMRMLScalarVolumeNode", "")
self.referenceDoseVolumeSelector.noneEnabled = False
self.referenceDoseVolumeSelector.addEnabled = False
self.referenceDoseVolumeSelector.removeEnabled = False
self.referenceDoseVolumeSelector.selectNodeUponCreation = True
self.referenceDoseVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.referenceDoseVolumeSelector.setToolTip(
"Set the reference dose volume")
layout.addRow(self.referenceDoseVolumeSelectorLabel,
self.referenceDoseVolumeSelector)
# Dose Volume selector
self.secondaryDoseVolumeSelectorLabel = qt.QLabel()
self.secondaryDoseVolumeSelectorLabel.setText(
"Secondary Dose Volume: ")
self.secondaryDoseVolumeSelector = slicer.qMRMLNodeComboBox()
self.secondaryDoseVolumeSelector.nodeTypes = (
"vtkMRMLScalarVolumeNode", "")
self.secondaryDoseVolumeSelector.noneEnabled = False
self.secondaryDoseVolumeSelector.addEnabled = False
self.secondaryDoseVolumeSelector.removeEnabled = False
self.secondaryDoseVolumeSelector.selectNodeUponCreation = True
self.secondaryDoseVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.secondaryDoseVolumeSelector.setToolTip(
"Set the secondary dose volume")
layout.addRow(self.secondaryDoseVolumeSelectorLabel,
self.secondaryDoseVolumeSelector)
# kernel SD value editor
self.volumeSimilarityValueLabel = qt.QLabel('Similarity value:')
self.volumeSimilarityValueEdit = qt.QDoubleSpinBox()
self.volumeSimilarityValueEdit.value = 0
layout.addRow(self.volumeSimilarityValueLabel,
self.volumeSimilarityValueEdit)
# Apply button
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Compare Dose"
layout.addWidget(self.applyButton)
self.UpdateApplyButtonState()
# connections
self.applyButton.connect('clicked()', self.onApply)
self.referenceDoseVolumeSelector.connect(
'currentNodeChanged(vtkMRMLNode*)', self.onDoseVolumeSelect)
self.secondaryDoseVolumeSelector.connect(
'currentNodeChanged(vtkMRMLNode*)', self.onDoseVolumeSelect)
def setup(self):
# Instantiate and connect widgets ...
#PARCHEE"
w = qt.QWidget()
layout = qt.QGridLayout()
w.setLayout(layout)
self.layout.addWidget(w)
w.show()
self.layout = layout
# INPUT MENU
self.inputFrame = ctk.ctkCollapsibleButton()
self.inputFrame.text = "Input"
self.inputFrame.collapsed = 0
inputFrameLayout = qt.QFormLayout(self.inputFrame)
self.layout.addWidget(self.inputFrame)
#Descubriendo que seria esto#
self.__mvNode = None
#Entrada multivolume
label = qt.QLabel('Input multivolume')
self.mvSelector = slicer.qMRMLNodeComboBox()
self.mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.mvSelector.setMRMLScene(slicer.mrmlScene)
self.mvSelector.addEnabled = 0
self.mvSelector.noneEnabled = 1
inputFrameLayout.addRow(label, self.mvSelector)
#Entrada frame a mostrar
label = qt.QLabel('Frame a mostrar')
self.__veInitial = qt.QDoubleSpinBox()
self.__veInitial.value = 0
inputFrameLayout.addRow(label, self.__veInitial)
###PARTE HELLO WORLD## BUTTON DE ACTIVACION
# Collapsible button
sampleCollapsibleButton = ctk.ctkCollapsibleButton()
sampleCollapsibleButton.text = "A collapsible button"
self.layout.addWidget(sampleCollapsibleButton)
# Layout within the sample collapsible button
sampleFormLayout = qt.QFormLayout(sampleCollapsibleButton)
helloWorldButton = qt.QPushButton("Hello World")
helloWorldButton.toolTip = "Print 'Hello World' in standard output."
sampleFormLayout.addWidget(helloWorldButton)
helloWorldButton.connect('clicked(bool)',
self.onHelloWorldButtonClicked)
# Set local var as instance attribute
self.helloWorldButton = helloWorldButton
def setup(self):
# Point Distance
controlCollapseButton = ctk.ctkCollapsibleButton()
controlCollapseButton.text = "Control"
self.layout.addWidget(controlCollapseButton)
controlLayout = qt.QFormLayout(controlCollapseButton)
self.nodeSelector = slicer.qMRMLNodeComboBox()
self.nodeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.nodeSelector.selectNodeUponCreation = False
self.nodeSelector.noneEnabled = False
self.nodeSelector.addEnabled = False
self.nodeSelector.showHidden = False
self.nodeSelector.setMRMLScene(slicer.mrmlScene)
self.nodeSelector.setToolTip("Pick Continuous Label Map")
controlLayout.addRow("LabelMap Node:", self.nodeSelector)
self.newNodeSelector = slicer.qMRMLNodeComboBox()
self.newNodeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.newNodeSelector.selectNodeUponCreation = True
self.newNodeSelector.noneEnabled = False
self.newNodeSelector.addEnabled = True
self.newNodeSelector.showHidden = False
self.newNodeSelector.setMRMLScene(slicer.mrmlScene)
self.newNodeSelector.setToolTip("Pick Node for Binned Label Map")
controlLayout.addRow("New Node:", self.newNodeSelector)
self.lowLabelSpinBox = qt.QSpinBox()
self.lowLabelSpinBox.setSingleStep(1)
self.lowLabelSpinBox.setValue(1)
controlLayout.addRow("Label under threshold value:",
self.lowLabelSpinBox)
self.thresholdSpinBox = qt.QDoubleSpinBox()
self.thresholdSpinBox.setMaximum(1.0)
self.thresholdSpinBox.setMinimum(-1.0)
self.thresholdSpinBox.setDecimals(5)
self.thresholdSpinBox.setSingleStep(0.0001)
self.thresholdSpinBox.setValue(0.7)
controlLayout.addRow("Threshold value:", self.thresholdSpinBox)
self.highLabelSpinBox = qt.QSpinBox()
self.highLabelSpinBox.setSingleStep(1)
self.highLabelSpinBox.setValue(0)
controlLayout.addRow("Label over threshold value:",
self.highLabelSpinBox)
self.applyButton = qt.QPushButton("Apply")
controlLayout.addRow(self.applyButton)
self.applyButton.connect('clicked(bool)', self.onApply)
def createDoubleWidget(self, name):
w = qt.QDoubleSpinBox()
self.widgets.append(w)
w.setRange(-3.40282e+038, 3.40282e+038)
w.decimals = 5
w.setValue(self._getParameterValue(name))
w.connect("valueChanged(double)",
lambda val, name=name: self.onScalarChanged(name, val))
self.widgetConnections.append((w, "valueChanged(double)"))
return w
def numericInputFrame(parent, label, tooltip, minimum, maximum, step, decimals):
inputFrame = qt.QFrame(parent)
inputFrame.setLayout(qt.QHBoxLayout())
inputLabel = qt.QLabel(label, inputFrame)
inputLabel.setToolTip(tooltip)
inputFrame.layout().addWidget(inputLabel)
inputSpinBox = qt.QDoubleSpinBox(inputFrame)
inputSpinBox.setToolTip(tooltip)
inputSpinBox.minimum = minimum
inputSpinBox.maximum = maximum
inputSpinBox.singleStep = step
inputSpinBox.decimals = decimals
inputFrame.layout().addWidget(inputSpinBox)
return inputFrame, inputSpinBox
def createDoubleWidget(self, name):
exec('default = self.filter.Get{0}()'.format(name)
) in globals(), locals()
w = qt.QDoubleSpinBox()
self.widgets.append(w)
w.setRange(-3.40282e+038, 3.40282e+038)
w.decimals = 5
w.setValue(default)
w.connect("valueChanged(double)",
lambda val, name=name: self.onScalarChanged(name, val))
return w
def create(self):
super(PaintEffectOptions, self).create()
self.radiusFrame = qt.QFrame(self.frame)
self.radiusFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.radiusFrame)
self.widgets.append(self.radiusFrame)
self.radiusLabel = qt.QLabel("Radius:", self.radiusFrame)
self.radiusLabel.setToolTip(
"Set the radius of the paint brush in millimeters")
self.radiusFrame.layout().addWidget(self.radiusLabel)
self.widgets.append(self.radiusLabel)
self.radiusSpinBox = qt.QDoubleSpinBox(self.radiusFrame)
self.radiusSpinBox.setToolTip(
"Set the radius of the paint brush in millimeters")
self.radiusSpinBox.minimum = 0.01
self.radiusSpinBox.maximum = 100
self.radiusSpinBox.suffix = "mm"
self.radiusFrame.layout().addWidget(self.radiusSpinBox)
self.widgets.append(self.radiusSpinBox)
self.radius = ctk.ctkDoubleSlider(self.frame)
self.radius.minimum = 0.01
self.radius.maximum = 100
self.radius.orientation = 1
self.radius.singleStep = 0.01
self.frame.layout().addWidget(self.radius)
self.widgets.append(self.radius)
self.smudge = qt.QCheckBox("Smudge", self.frame)
self.smudge.setToolTip(
"Set the label number automatically by sampling the pixel location where the brush stroke starts."
)
self.frame.layout().addWidget(self.smudge)
self.widgets.append(self.smudge)
HelpButton(
self.frame,
"Use this tool to paint with a round brush of the selected radius")
self.smudge.connect('clicked()', self.updateMRMLFromGUI)
self.radius.connect('valueChanged(double)', self.onRadiusValueChanged)
self.radiusSpinBox.connect('valueChanged(double)',
self.onRadiusSpinBoxChanged)
# Add vertical spacer
self.frame.layout().addStretch(1)
def setup(self):
controlCollapseButton = ctk.ctkCollapsibleButton()
controlCollapseButton.text = "Control"
self.layout.addWidget(controlCollapseButton)
controlLayout = qt.QFormLayout(controlCollapseButton)
self.nodeSelector = slicer.qMRMLNodeComboBox()
self.nodeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.nodeSelector.selectNodeUponCreation = False
self.nodeSelector.noneEnabled = False
self.nodeSelector.addEnabled = False
self.nodeSelector.showHidden = False
self.nodeSelector.setMRMLScene(slicer.mrmlScene)
self.nodeSelector.setToolTip("Pick Volume")
controlLayout.addRow("Volume Node:", self.nodeSelector)
self.marginBox = qt.QDoubleSpinBox()
self.marginBox.setValue(3.5)
controlLayout.addRow("Margin:", self.marginBox)
self.labelmapSelector = slicer.qMRMLNodeComboBox()
self.labelmapSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.labelmapSelector.selectNodeUponCreation = False
self.labelmapSelector.noneEnabled = False
self.labelmapSelector.addEnabled = False
self.labelmapSelector.showHidden = False
self.labelmapSelector.setMRMLScene(slicer.mrmlScene)
self.labelmapSelector.setToolTip("Pick Labelmap")
controlLayout.addRow("Labelmap Node:", self.labelmapSelector)
self.labelmapCheckBox = qt.QCheckBox()
self.labelmapCheckBox.setChecked(True)
controlLayout.addRow("Also mask labelmap? ", self.labelmapCheckBox)
self.applyButton = qt.QPushButton("Apply")
controlLayout.addRow(self.applyButton)
self.applyButton.connect('clicked(bool)', self.onApply)
def setup(self):
# reload button
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload this module."
self.reloadButton.name = "HeterogeneityCAD Reload"
self.layout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
# Tumor Segmentation Collapsible Button
self.TumorSegmentationCollapsibleButton = ctk.ctkCollapsibleButton()
self.TumorSegmentationCollapsibleButton.text = "SegmentCAD Segmentation"
self.layout.addWidget(self.TumorSegmentationCollapsibleButton)
self.TumorSegmentationLayout = qt.QFormLayout(
self.TumorSegmentationCollapsibleButton)
# Select Volumes Collapsible Button
self.selectionsCollapsibleButton = ctk.ctkCollapsibleButton()
self.selectionsCollapsibleButton.text = "Select DCE-MRI Volumes for Segmentation"
self.TumorSegmentationLayout.addWidget(
self.selectionsCollapsibleButton)
# Layout within the collapsible button
self.volumesLayout = qt.QFormLayout(self.selectionsCollapsibleButton)
# Use Multivolume Node as input
self.enableMultiVolume = qt.QCheckBox(self.selectionsCollapsibleButton)
self.enableMultiVolume.setText('Input Multi-Volume Node')
self.enableMultiVolume.checked = True
self.enableMultiVolume.setToolTip(
'Use Multi-Volume Node, with volumes imported in the correct order'
)
self.inputSelectorMultiVolume = slicer.qMRMLNodeComboBox(
self.selectionsCollapsibleButton)
self.inputSelectorMultiVolume.nodeTypes = (("vtkMRMLMultiVolumeNode"),
"")
self.inputSelectorMultiVolume.selectNodeUponCreation = False
self.inputSelectorMultiVolume.renameEnabled = True
self.inputSelectorMultiVolume.removeEnabled = False
self.inputSelectorMultiVolume.noneEnabled = True
self.inputSelectorMultiVolume.addEnabled = False
self.inputSelectorMultiVolume.setMRMLScene(slicer.mrmlScene)
self.inputSelectorMultiVolume.setToolTip(
'Use Multi-Volume Node, with volumes imported in the correct order'
)
self.volumesLayout.addRow(self.enableMultiVolume,
self.inputSelectorMultiVolume)
self.nodeInputFrame = ctk.ctkCollapsibleGroupBox(
self.selectionsCollapsibleButton)
self.nodeInputFrame.title = "Input Scalar Volume Nodes"
self.nodeInputFrame.collapsed = True
self.nodeInputFrame.enabled = False
self.nodeInputFrame.setLayout(qt.QFormLayout())
self.volumesLayout.addRow(self.nodeInputFrame)
# Select Pre Node
self.inputPre = qt.QLabel("Pre-contrast Volume", self.nodeInputFrame)
self.inputPre.setToolTip(
'Select the initial pre-contrast volume node.')
self.inputSelectorPre = slicer.qMRMLNodeComboBox(self.nodeInputFrame)
self.inputSelectorPre.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.inputSelectorPre.selectNodeUponCreation = False
self.inputSelectorPre.addEnabled = False
self.inputSelectorPre.removeEnabled = False
self.inputSelectorPre.noneEnabled = True
self.inputSelectorPre.noneDisplay = 'Please Select Volume'
self.inputSelectorPre.setMRMLScene(slicer.mrmlScene)
self.inputSelectorPre.setToolTip(
'Select the initial pre-contrast volume node.')
#self.volumesLayout.addRow(self.inputPre, self.inputSelectorPre)
self.nodeInputFrame.layout().addRow(self.inputPre,
self.inputSelectorPre)
# Select First Node
self.inputFirst = qt.QLabel("First Post-contrast Volume",
self.nodeInputFrame)
self.inputFirst.setToolTip(
'Select the first post-contrast volume node to calculate intitial enhancement and curve type.'
)
self.inputSelectorFirst = slicer.qMRMLNodeComboBox(self.nodeInputFrame)
self.inputSelectorFirst.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.inputSelectorFirst.selectNodeUponCreation = False
self.inputSelectorFirst.addEnabled = False
self.inputSelectorFirst.removeEnabled = False
self.inputSelectorFirst.noneEnabled = True
self.inputSelectorFirst.noneDisplay = 'Please Select Volume'
self.inputSelectorFirst.setMRMLScene(slicer.mrmlScene)
self.inputSelectorFirst.setToolTip(
'Select the first post-contrast volume node to calculate intitial enhancement and curve type.'
)
#self.volumesLayout.addRow(self.inputFirst, self.inputSelectorFirst)
self.nodeInputFrame.layout().addRow(self.inputFirst,
self.inputSelectorFirst)
# Select Second Node
self.inputSecond = qt.QLabel("Second Post-contrast Volume",
self.nodeInputFrame)
self.inputSecond.setToolTip(
'Select a second post-contrast volume node (not required).')
self.inputSelectorSecond = slicer.qMRMLNodeComboBox(
self.nodeInputFrame)
self.inputSelectorSecond.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.inputSelectorSecond.selectNodeUponCreation = False
self.inputSelectorSecond.addEnabled = False
self.inputSelectorSecond.removeEnabled = False
self.inputSelectorSecond.noneEnabled = True
self.inputSelectorSecond.noneDisplay = 'Please Select Volume'
self.inputSelectorSecond.setMRMLScene(slicer.mrmlScene)
self.inputSelectorSecond.setToolTip(
'Select a second post-contrast volume node (not required).')
#self.volumesLayout.addRow(self.inputSecond, self.inputSelectorSecond)
self.nodeInputFrame.layout().addRow(self.inputSecond,
self.inputSelectorSecond)
# Select Third Node
self.inputThird = qt.QLabel("Third Post-contrast Volume",
self.nodeInputFrame)
self.inputThird.setToolTip(
'Select a third post-contrast volume node (not required).')
self.inputSelectorThird = slicer.qMRMLNodeComboBox(self.nodeInputFrame)
self.inputSelectorThird.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.inputSelectorThird.selectNodeUponCreation = False
self.inputSelectorThird.addEnabled = False
self.inputSelectorThird.removeEnabled = False
self.inputSelectorThird.noneEnabled = True
self.inputSelectorThird.noneDisplay = 'Please Select Volume'
self.inputSelectorThird.setMRMLScene(slicer.mrmlScene)
self.inputSelectorThird.setToolTip(
'Select a third post-contrast volume node (not required).')
#self.volumesLayout.addRow(self.inputThird, self.inputSelectorThird)
self.nodeInputFrame.layout().addRow(self.inputThird,
self.inputSelectorThird)
# Select Fourth Node
self.inputFourth = qt.QLabel("Fourth Post-contrast Volume",
self.nodeInputFrame)
self.inputFourth.setToolTip(
'Select the fourth or final post-contrast volume node to calculate curve type based on the delayed curve slope.'
)
self.inputSelectorFourth = slicer.qMRMLNodeComboBox(
self.nodeInputFrame)
self.inputSelectorFourth.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.inputSelectorFourth.selectNodeUponCreation = False
self.inputSelectorFourth.addEnabled = False
self.inputSelectorFourth.removeEnabled = False
self.inputSelectorFourth.noneEnabled = True
self.inputSelectorFourth.noneDisplay = 'Please Select Volume'
self.inputSelectorFourth.setMRMLScene(slicer.mrmlScene)
self.inputSelectorFourth.setToolTip(
'Select the fourth or final post-contrast volume node to calculate curve type based on the delayed curve slope.'
)
#self.volumesLayout.addRow(self.inputFourth, self.inputSelectorFourth)
self.nodeInputFrame.layout().addRow(self.inputFourth,
self.inputSelectorFourth)
# Enable and Select Input Label Map as ROI
self.enableLabel = qt.QCheckBox(self.selectionsCollapsibleButton)
self.enableLabel.setText('Use Label Map as ROI')
self.enableLabel.checked = True
self.enableLabel.setToolTip(
'Select and identify a custom label map node to define an ROI over the input volumes for faster segmentation.'
)
self.inputSelectorLabel = slicer.qMRMLNodeComboBox(
self.selectionsCollapsibleButton)
self.inputSelectorLabel.nodeTypes = (("vtkMRMLLabelMapVolumeNode"), "")
self.inputSelectorLabel.selectNodeUponCreation = False
self.inputSelectorLabel.renameEnabled = True
self.inputSelectorLabel.removeEnabled = False
self.inputSelectorLabel.noneEnabled = True
self.inputSelectorLabel.addEnabled = False
self.inputSelectorLabel.setMRMLScene(slicer.mrmlScene)
self.inputSelectorLabel.setToolTip(
'Select and identify a custom label map node to define an ROI over the input volumes for faster segmentation.'
)
self.volumesLayout.addRow(self.enableLabel, self.inputSelectorLabel)
# Select output SegmentCAD Label collapsible button
self.outlabelCollapsibleButton = ctk.ctkCollapsibleButton()
self.outlabelCollapsibleButton.text = "Select or Create Output SegmentCAD Label Map"
self.TumorSegmentationLayout.addWidget(self.outlabelCollapsibleButton)
# Layout within the collapsible button
self.outlabelLayout = qt.QFormLayout(self.outlabelCollapsibleButton)
# Select or create output SegmentCAD Label Map
self.outputLabel = qt.QLabel("Output SegmentCAD Label Map",
self.outlabelCollapsibleButton)
self.outputLabel.setToolTip(
'Select or create a label map volume node as the SegmentCAD segmentation output.'
)
self.outputSelectorLabel = slicer.qMRMLNodeComboBox(
self.outlabelCollapsibleButton)
self.outputSelectorLabel.nodeTypes = (("vtkMRMLLabelMapVolumeNode"),
"")
self.outputSelectorLabel.baseName = "SegmentCAD Label Map"
self.outputSelectorLabel.selectNodeUponCreation = True
self.outputSelectorLabel.renameEnabled = True
self.outputSelectorLabel.removeEnabled = True
self.outputSelectorLabel.noneEnabled = False
self.outputSelectorLabel.addEnabled = True
self.outputSelectorLabel.setMRMLScene(slicer.mrmlScene)
self.outputSelectorLabel.setToolTip(
'Select or create a label map volume node as the SegmentCAD segmentation output.'
)
self.outlabelLayout.addRow(self.outputLabel, self.outputSelectorLabel)
# SegmentCAD Label Map Legend
self.outputLegend = qt.QLabel(
"| Type I Persistent: Blue | Type II Plateau: Yellow | Type III Washout: Red |",
self.outlabelCollapsibleButton)
self.outputLegend.setToolTip(
'SegmentCAD Label Map Legend | Blue: Type I Persistent curve | Yellow: Type II Plateau curve | Red: Type III Washout curve |'
)
self.outlabelLayout.addRow(self.outputLegend)
# Enable Volume Rendering of the SegmentCAD label map
self.enableVolumeRendering = qt.QCheckBox(
self.selectionsCollapsibleButton)
self.enableVolumeRendering.setText('Display Volume Rendering')
self.enableVolumeRendering.checked = True
self.enableVolumeRendering.setToolTip(
'Display volume rendering of the SegmentCAD Label Map in the 3D View'
)
self.outlabelLayout.addRow(self.enableVolumeRendering)
# Enable Label Statistics Table and Data
self.enableStats = qt.QCheckBox(self.selectionsCollapsibleButton)
self.enableStats.setText('Calculate SegmentCAD Label statistics')
self.enableStats.checked = False
self.enableStats.setToolTip(
'Use logic from Label Statistics Module to calculate statistics for first post-contrast voxels within the SegmentCAD Label Map.'
)
self.outlabelLayout.addRow(self.enableStats)
# Set Advanced Parameters Collapsible Button
self.parametersCollapsibleButton = ctk.ctkCollapsibleButton()
self.parametersCollapsibleButton.text = "Set Advanced Segmentation Parameters"
self.TumorSegmentationLayout.addWidget(
self.parametersCollapsibleButton)
self.parametersCollapsibleButton.collapsed = True
# Layout within the collapsible button
self.parametersLayout = qt.QFormLayout(
self.parametersCollapsibleButton)
# Set Minimum Threshold of Percentage Increase to First Post-Contrast Image
self.inputMinimumThreshold = qt.QLabel(
"Minimum Threshold of Increase", self.parametersCollapsibleButton)
self.inputMinimumThreshold.setToolTip(
'Minimum Threshold of Percentage Increase (Pre- to First Post-contrast (Range: 10% to 150%)'
)
self.inputSelectorMinimumThreshold = qt.QDoubleSpinBox(
self.parametersCollapsibleButton)
self.inputSelectorMinimumThreshold.setSuffix("%")
self.inputSelectorMinimumThreshold.singleStep = (1)
self.inputSelectorMinimumThreshold.minimum = (10)
self.inputSelectorMinimumThreshold.maximum = (150)
self.inputSelectorMinimumThreshold.value = (75)
self.inputSelectorMinimumThreshold.setToolTip(
'Minimum Threshold of Percentage Increase (Pre- to First Post-contrast (Range: 10% to 150%)'
)
self.parametersLayout.addRow(self.inputMinimumThreshold,
self.inputSelectorMinimumThreshold)
# Curve 1 Type Parameters (Slopes from First to Fourth Post-Contrast Images)
self.inputCurve1 = qt.QLabel("Type 1 (Persistent) Curve Minimum Slope",
self.parametersCollapsibleButton)
self.inputCurve1.setToolTip(
'Minimum Slope of Delayed Curve to classify as Persistent (Range: 0.02 to 0.3)'
)
self.inputSelectorCurve1 = qt.QDoubleSpinBox(
self.parametersCollapsibleButton)
self.inputSelectorCurve1.singleStep = (0.02)
self.inputSelectorCurve1.minimum = (0.02)
self.inputSelectorCurve1.maximum = (0.3)
self.inputSelectorCurve1.value = (0.20)
self.inputSelectorCurve1.setToolTip(
'Minimum Slope of Delayed Curve to classify as Persistent (Range: 0.02 to 0.3)'
)
self.parametersLayout.addRow(self.inputCurve1,
self.inputSelectorCurve1)
# Curve 3 Type Parameters (Slopes from First to Fourth Post-Contrast Images)
self.inputCurve3 = qt.QLabel("Type 3 (Washout) Curve Maximum Slope",
self.parametersCollapsibleButton)
self.inputCurve3.setToolTip(
'Maximum Slope of Delayed Curve to classify as Washout (Range: -0.02 to -0.3)'
)
self.inputSelectorCurve3 = qt.QDoubleSpinBox(
self.parametersCollapsibleButton)
self.inputSelectorCurve3.singleStep = (0.02)
self.inputSelectorCurve3.setPrefix("-")
self.inputSelectorCurve3.minimum = (0.02)
self.inputSelectorCurve3.maximum = (0.30)
self.inputSelectorCurve3.value = (0.20)
self.inputSelectorCurve3.setToolTip(
'Maximum Slope of Delayed Curve to classify as Washout (Range: -0.02 to -0.3)'
)
self.parametersLayout.addRow(self.inputCurve3,
self.inputSelectorCurve3)
# Apply Tumor Adaptive Segmentation button
self.SegmentCADButton = qt.QPushButton("Apply SegmentCAD")
self.SegmentCADButton.toolTip = "Apply SegmentCAD segmentation to selected volumes."
self.TumorSegmentationLayout.addWidget(self.SegmentCADButton)
# LabelStatistics Table Collapsible Button
self.labelstatisticsCollapsibleButton = ctk.ctkCollapsibleButton()
self.labelstatisticsCollapsibleButton.text = "SegmentCAD Label Statistics"
self.layout.addWidget(self.labelstatisticsCollapsibleButton)
self.labelstatisticsCollapsibleButton.collapsed = True
# Layout within the collapsible button
self.labelstatisticsLayout = qt.QFormLayout(
self.labelstatisticsCollapsibleButton)
# Table View to display Label statistics
self.labelStatisticsTableView = qt.QTableView()
self.labelStatisticsTableView.sortingEnabled = True
self.labelstatisticsLayout.addWidget(self.labelStatisticsTableView)
self.labelStatisticsTableView.minimumHeight = 200
# Charting Statistics Button
self.chartOptions = ("Volume", "Curve Type", "Voxel Count",
"Volume mm^3", "Volume cc", "Minimum Intensity",
"Maximum Intensity", "Mean Intensity",
"Standard Deviation")
self.chartFrame = qt.QFrame()
self.chartFrame.setLayout(qt.QHBoxLayout())
self.labelstatisticsLayout.addWidget(self.chartFrame)
self.chartButton = qt.QPushButton(
"Chart Statistics", self.labelstatisticsCollapsibleButton)
self.chartButton.toolTip = "Make a chart from the current statistics."
self.chartFrame.layout().addWidget(self.chartButton)
self.chartOption = qt.QComboBox(self.labelstatisticsCollapsibleButton)
self.chartOption.addItems(self.chartOptions)
self.chartFrame.layout().addWidget(self.chartOption)
self.chartIgnoreZero = qt.QCheckBox(
self.labelstatisticsCollapsibleButton)
self.chartIgnoreZero.setText('Ignore Zero Label')
self.chartIgnoreZero.checked = False
self.chartIgnoreZero.setToolTip(
'Do not include the zero index in the chart to avoid dwarfing other bars'
)
self.chartFrame.layout().addWidget(self.chartIgnoreZero)
self.chartButton.enabled = False
# Interactive Charting Settings Collapsible Button
self.iChartingCollapsibleButton = ctk.ctkCollapsibleButton()
self.iChartingCollapsibleButton.text = "Interactive Charting Settings"
self.iChartingCollapsibleButton.collapsed = True
self.layout.addWidget(self.iChartingCollapsibleButton)
# Layout within the collapsible button
self.iChartingLayout = qt.QFormLayout(self.iChartingCollapsibleButton)
# iCharting toggle button
self.iCharting = qt.QPushButton("Enable Interactive Charting")
self.iCharting.checkable = True
self.iCharting.setChecked(False)
self.iCharting.enabled = False
self.iCharting.toolTip = "Toggle the real-time charting of the %increase from baseline of the selected voxel from each input volume."
self.iChartingLayout.addRow(self.iCharting)
# Initialize slice observers (from DataProbe.py)
# Keep list of pairs: [observee,tag] so they can be removed easily
self.styleObserverTags = []
# Keep a map of interactor styles to sliceWidgets so we can easily get sliceLogic
self.sliceWidgetsPerStyle = {}
self.refreshObservers()
# Connections
self.SegmentCADButton.connect('clicked()',
self.onSegmentCADButtonClicked)
self.enableLabel.connect('stateChanged(int)', self.onEnableLabel)
self.enableMultiVolume.connect('stateChanged(int)',
self.onEnableMultiVolume)
self.chartButton.connect('clicked()', self.onChart)
self.iCharting.connect('toggled(bool)',
self.onInteractiveChartingChanged)
def setup(self):
# Instantiate and connect widgets ...
# #
# # Reload and Test area
# #
# reloadCollapsibleButton = ctk.ctkCollapsibleButton()
# reloadCollapsibleButton.text = "Reload && Test"
# self.layout.addWidget(reloadCollapsibleButton)
# reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton)
# # reload button
# # (use this during development, but remove it when delivering
# # your module to users)
# self.reloadButton = qt.QPushButton("Reload")
# self.reloadButton.toolTip = "Reload this module."
# self.reloadButton.name = "PortPlacement Reload"
# reloadFormLayout.addWidget(self.reloadButton)
# self.reloadButton.connect('clicked()', self.onReload)
# # reload and test button
# # (use this during development, but remove it when delivering
# # your module to users)
# self.reloadAndTestButton = qt.QPushButton("Reload and Test")
# self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests."
# reloadFormLayout.addWidget(self.reloadAndTestButton)
# self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest)
#
# Ports Area
#
portsCollapsibleButton = ctk.ctkCollapsibleButton()
portsCollapsibleButton.text = "Surgical Ports"
self.layout.addWidget(portsCollapsibleButton)
portsFormLayout = qt.QFormLayout(portsCollapsibleButton)
#
# port fiducial list selector
#
self.portListSelector = slicer.qMRMLNodeComboBox()
self.portListSelector.nodeTypes = ["vtkMRMLMarkupsFiducialNode"]
self.portListSelector.addEnabled = False
self.portListSelector.removeEnabled = False
self.portListSelector.noneEnabled = True
self.portListSelector.setMRMLScene(slicer.mrmlScene)
self.portListSelector.setToolTip("Add surgical ports from a markups node.")
portsFormLayout.addRow("Markups node of surgical ports", self.portListSelector)
#
# Add Port List button
#
self.addPortListButton = qt.QPushButton("Set Port Markups Node")
self.addPortListButton.enabled = False
portsFormLayout.addRow(self.addPortListButton)
#
# Port table
#
self.portsTable = qt.QTableView()
self.portsTableModel = qt.QStandardItemModel()
self.portsTable.setModel(self.portsTableModel)
portsFormLayout.addRow(self.portsTable)
#
# Remove Port button
#
self.removePortButton = qt.QPushButton("Remove Selected Port")
self.removePortButton.enabled = False
portsFormLayout.addRow(self.removePortButton)
#
# Target area
#
targetCollapsibleButton = ctk.ctkCollapsibleButton()
targetCollapsibleButton.text = "Surgical Target"
self.layout.addWidget(targetCollapsibleButton)
targetFormLayout = qt.QFormLayout(targetCollapsibleButton)
#
# target selector
#
self.targetSelector = slicer.qMRMLNodeComboBox()
self.targetSelector.nodeTypes = ["vtkMRMLMarkupsFiducialNode"]
self.targetSelector.addEnabled = False
self.targetSelector.removeEnabled = False
self.targetSelector.noneEnabled = True
self.targetSelector.setMRMLScene(slicer.mrmlScene)
self.targetSelector.setToolTip("Pick the surgical target that the tools should face.")
targetFormLayout.addRow("Surgical Target Fiducial", self.targetSelector)
#
# Retarget button
#
self.retargetButton = qt.QPushButton("Aim Tools at Target")
self.retargetButton.toolTip = "Reset tool orientations to face target fiducial"
self.retargetButton.enabled = False
targetFormLayout.addRow(self.retargetButton)
#
# Port Tool Display Options
#
toolsCollapsibleButton = ctk.ctkCollapsibleButton()
toolsCollapsibleButton.text = "Port Tool Display Options"
self.layout.addWidget(toolsCollapsibleButton)
toolsFormLayout = qt.QFormLayout(toolsCollapsibleButton)
#
# Transform sliders
#
self.transformSliders = slicer.qMRMLTransformSliders()
self.transformSliders.TypeOfTransform = slicer.qMRMLTransformSliders.ROTATION
self.transformSliders.CoordinateReference = slicer.qMRMLTransformSliders.LOCAL
self.transformSliders.Title = 'Tool Orientation'
self.transformSliders.minMaxVisible = False
toolsFormLayout.addRow(self.transformSliders)
#
# radius spin box
#
self.radiusSpinBox = qt.QDoubleSpinBox()
self.radiusSpinBox.setMinimum(0.0)
self.radiusSpinBox.setMaximum(10.0)
self.radiusSpinBox.setValue(2.0)
toolsFormLayout.addRow("Tool radius", self.radiusSpinBox)
#
# length spin box
#
self.lengthSpinBox = qt.QDoubleSpinBox()
self.lengthSpinBox.setMinimum(0.0)
self.lengthSpinBox.setMaximum(250.0)
self.lengthSpinBox.setValue(150.0)
toolsFormLayout.addRow("Tool length", self.lengthSpinBox)
# connections
self.portListSelector.connect('currentNodeChanged(bool)', self.onPortListSelectorChanged)
self.targetSelector.connect('currentNodeChanged(bool)', self.onTargetSelectorChanged)
self.addPortListButton.connect('clicked(bool)', self.onAddPortListButton)
self.removePortButton.connect('clicked(bool)', self.onRemovePortButton)
self.retargetButton.connect('clicked(bool)', self.onRetargetButton)
self.radiusSpinBox.connect('valueChanged(double)', self.onToolShapeChanged)
self.lengthSpinBox.connect('valueChanged(double)', self.onToolShapeChanged)
# Add vertical spacer
self.layout.addStretch(1)
# Add observer to scene for removal of fiducial nodes
self.sceneObserverTag = slicer.mrmlScene.AddObserver(slicer.mrmlScene.NodeRemovedEvent,
self.onNodeRemoved)
# instantiate port placement module logic
self.logic = PortPlacementLogic()
self.currentMarkupsNode = None
self.onMarkupAddedTag = None
def createUserInterface(self):
'''
'''
self.__layout = super(EMSegmentEditNodeBasedParametersStep,
self).createUserInterface()
self.__top = qt.QWidget()
self.__topLayout = qt.QHBoxLayout(self.__top)
# the anatomical tree
self.__anatomicalTreeGroupBox = qt.QGroupBox()
self.__anatomicalTreeGroupBox.setTitle('Anatomical Tree')
self.__topLayout.addWidget(self.__anatomicalTreeGroupBox)
self.__anatomicalTreeGroupBoxLayout = qt.QFormLayout(
self.__anatomicalTreeGroupBox)
self.__anatomicalTree = slicer.modulewidget.qSlicerEMSegmentAnatomicalTreeWidget(
)
self.__anatomicalTree.structureNameEditable = False
self.__anatomicalTree.labelColumnVisible = False
self.__anatomicalTree.probabilityMapColumnVisible = False
self.__anatomicalTree.classWeightColumnVisible = False
self.__anatomicalTree.updateClassWeightColumnVisible = False
self.__anatomicalTree.atlasWeightColumnVisible = False
self.__anatomicalTree.alphaColumnVisible = False
self.__anatomicalTree.displayAlphaCheckBoxVisible = False
self.__anatomicalTree.connect('currentTreeNodeChanged(vtkMRMLNode*)',
self.onTreeSelectionChanged)
self.__anatomicalTree.setSizePolicy(qt.QSizePolicy.Expanding,
qt.QSizePolicy.Expanding)
self.__anatomicalTree.toolTip = 'Select an anatomical structure to configure the probablity in relation to other structures on the same level.'
self.__anatomicalTree.setMinimumHeight(200)
self.__anatomicalTreeGroupBoxLayout.addWidget(self.__anatomicalTree)
#
# overview of class weights panel
#
self.__overviewBox = qt.QGroupBox()
self.__overviewBox.title = 'Overview of Class Weights'
self.__overviewBox.toolTip = 'These are your guesses of probability relations between structures. Which structure takes how much percentage of the volume?'
self.__overviewBoxLayout = qt.QVBoxLayout(self.__overviewBox)
self.__topLayout.addWidget(self.__overviewBox)
self.__layout.addWidget(self.__top)
self.__tabWidget = qt.QTabWidget()
self.__layout.addWidget(self.__tabWidget)
#
# basicPage
#
self.__basicPage = qt.QWidget()
self.__basicPageLayout = qt.QHBoxLayout(self.__basicPage)
self.__basicPageLeft = qt.QWidget()
self.__basicPageRight = qt.QWidget()
self.__basicPageLayoutLeft = qt.QFormLayout(self.__basicPageLeft)
self.__basicPageLayoutRight = qt.QFormLayout(self.__basicPageRight)
self.__basicPageLayout.addWidget(self.__basicPageLeft)
self.__basicPageLayout.addWidget(self.__basicPageRight)
self.__classLabel = qt.QLabel("XX")
self.__basicPageLayoutLeft.addRow("Class:", self.__classLabel)
self.__classWeightSpinBox = qt.QDoubleSpinBox()
self.__classWeightSpinBox.minimum = 0
self.__classWeightSpinBox.maximum = 1
self.__classWeightSpinBox.singleStep = 0.01
self.__classWeightSpinBox.toolTip = 'Configure the class weight for the selected structure.'
self.__basicPageLayoutLeft.addRow("Class Weight:",
self.__classWeightSpinBox)
self.__classWeightSpinBox.connect('valueChanged(double)',
self.propagateToMRML)
self.__atlasWeightSpinBox = qt.QDoubleSpinBox()
self.__atlasWeightSpinBox.minimum = 0
self.__atlasWeightSpinBox.maximum = 1
self.__atlasWeightSpinBox.singleStep = 0.01
self.__atlasWeightSpinBox.toolTip = 'Configure the atlas weight for the selected structure.'
self.__basicPageLayoutLeft.addRow("Atlas Weight:",
self.__atlasWeightSpinBox)
self.__atlasWeightSpinBox.connect('valueChanged(double)',
self.propagateToMRML)
self.__mfaWeightSpinBox = qt.QDoubleSpinBox()
self.__mfaWeightSpinBox.minimum = 0
self.__mfaWeightSpinBox.maximum = 1
self.__mfaWeightSpinBox.singleStep = 0.01
self.__mfaWeightSpinBox.toolTip = 'Configure the MFA weight for the selected class.'
self.__basicPageLayoutLeft.addRow("MFA Weight:",
self.__mfaWeightSpinBox)
self.__mfaWeightSpinBox.connect('valueChanged(double)',
self.propagateToMRML)
self.__dummyLabel6 = qt.QLabel(" ")
self.__basicPageLayoutRight.addRow(" ", self.__dummyLabel6)
self.__dummyLabel9 = qt.QLabel(" ")
self.__basicPageLayoutRight.addRow(" ", self.__dummyLabel9)
self.__inputChannelWeightsBox = qt.QGroupBox()
self.__inputChannelWeightsBox.title = 'Dataset Channel Weights'
self.__inputChannelWeightsBox.toolTip = 'Configure different weights for each input dataset.'
self.__inputChannelWeightsBoxLayout = qt.QFormLayout(
self.__inputChannelWeightsBox)
self.__basicPageLayoutRight.addWidget(self.__inputChannelWeightsBox)
#
# stoppingConditionsPage
#
self.__stoppingConditionsPage = qt.QWidget()
self.__stoppingConditionsPageLayout = qt.QHBoxLayout(
self.__stoppingConditionsPage)
self.__stoppingConditionsPageLeft = qt.QWidget()
self.__stoppingConditionsPageRight = qt.QWidget()
self.__stoppingConditionsPageLayoutLeft = qt.QFormLayout(
self.__stoppingConditionsPageLeft)
self.__stoppingConditionsPageLayoutRight = qt.QFormLayout(
self.__stoppingConditionsPageRight)
self.__stoppingConditionsPageLayout.addWidget(
self.__stoppingConditionsPageLeft)
self.__stoppingConditionsPageLayout.addWidget(
self.__stoppingConditionsPageRight)
self.__classLabel2 = qt.QLabel("XX")
self.__stoppingConditionsPageLayoutLeft.addRow("Class:",
self.__classLabel2)
self.__emComboBox = qt.QComboBox()
self.__emComboBox.addItems(Helper.GetStoppingConditionTypes())
self.__emComboBox.toolTip = 'Configure the EM Stopping Condition for the selected class.'
self.__stoppingConditionsPageLayoutLeft.addRow('EM:',
self.__emComboBox)
self.__emComboBox.connect('currentIndexChanged(int)',
self.propagateToMRML)
self.__mfaComboBox = qt.QComboBox()
self.__mfaComboBox.addItems(Helper.GetStoppingConditionTypes())
self.__mfaComboBox.toolTip = 'Configure the MFA Stopping Condition for the selected class.'
self.__stoppingConditionsPageLayoutLeft.addRow('MFA:',
self.__mfaComboBox)
self.__mfaComboBox.connect('currentIndexChanged(int)',
self.propagateToMRML)
self.__dummyLabel = qt.QLabel(" ")
self.__stoppingConditionsPageLayoutRight.addRow(
" ", self.__dummyLabel)
self.__emValueSpinBox = qt.QSpinBox()
self.__emValueSpinBox.minimum = 0
self.__emValueSpinBox.singleStep = 1
self.__emValueSpinBox.toolTip = 'Configure the value for the EM stopping condition.'
self.__stoppingConditionsPageLayoutRight.addRow(
'Iterations:', self.__emValueSpinBox)
self.__emValueSpinBox.connect('valueChanged(int)',
self.propagateToMRML)
self.__mfaValueSpinBox = qt.QSpinBox()
self.__mfaValueSpinBox.minimum = 0
self.__mfaValueSpinBox.singleStep = 1
self.__mfaValueSpinBox.toolTip = 'Configure the MFA stopping condition. More iterations result in more smoothing.'
self.__stoppingConditionsPageLayoutRight.addRow(
'Iterations:', self.__mfaValueSpinBox)
self.__mfaValueSpinBox.connect('valueChanged(int)',
self.propagateToMRML)
self.__biasSpinBox = qt.QSpinBox()
self.__biasSpinBox.minimum = -1
self.__biasSpinBox.singleStep = 1
self.__biasSpinBox.toolTip = 'Enable Bias Correction: -1, turn it off: 0.'
self.__stoppingConditionsPageLayoutRight.addRow(
'Bias Iterations:', self.__biasSpinBox)
self.__biasSpinBox.connect('valueChanged(int)', self.propagateToMRML)
#
# printPage
#
self.__printPage = qt.QWidget()
self.__printPageLayout = qt.QHBoxLayout(self.__printPage)
self.__printPageLeft = qt.QWidget()
self.__printPageRight = qt.QWidget()
self.__printPageLayoutLeft = qt.QFormLayout(self.__printPageLeft)
self.__printPageLayoutRight = qt.QFormLayout(self.__printPageRight)
self.__printPageLayout.addWidget(self.__printPageLeft)
self.__printPageLayout.addWidget(self.__printPageRight)
self.__classLabel3 = qt.QLabel("XX")
self.__printPageLayoutLeft.addRow("Class:", self.__classLabel3)
self.__weightCheckBox = qt.QCheckBox()
self.__printPageLayoutLeft.addRow("Weight:", self.__weightCheckBox)
self.__weightCheckBox.toolTip = 'Toggle to print the weights.'
self.__weightCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__qualityCheckBox = qt.QCheckBox()
self.__printPageLayoutLeft.addRow("Quality:", self.__qualityCheckBox)
self.__qualityCheckBox.toolTip = 'Toggle to print the quality.'
self.__qualityCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__frequencySpinBox = qt.QSpinBox()
self.__frequencySpinBox.minimum = 0
self.__frequencySpinBox.maximum = 20
self.__frequencySpinBox.toolTip = 'Configure the print frequency.'
self.__printPageLayoutLeft.addRow("Frequency:",
self.__frequencySpinBox)
self.__frequencySpinBox.connect('valueChanged(int)',
self.propagateToMRML)
self.__biasCheckBox = qt.QCheckBox()
self.__biasCheckBox.toolTip = 'Toggle to print the bias.'
self.__printPageLayoutLeft.addRow("Bias:", self.__biasCheckBox)
self.__biasCheckBox.connect('stateChanged(int)', self.propagateToMRML)
self.__labelMapCheckBox = qt.QCheckBox()
self.__labelMapCheckBox.toolTip = 'Toggle to print the label map.'
self.__printPageLayoutLeft.addRow("Label Map:",
self.__labelMapCheckBox)
self.__labelMapCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__dummyLabel2 = qt.QLabel(" ")
self.__printPageLayoutRight.addRow(" ", self.__dummyLabel2)
self.__dummyLabel3 = qt.QLabel(" ")
self.__printPageLayoutRight.addRow(" ", self.__dummyLabel3)
self.__convergenceBox = qt.QGroupBox()
self.__convergenceBox.title = 'Convergence'
self.__convergenceBoxLayout = qt.QFormLayout(self.__convergenceBox)
self.__printPageLayoutRight.addWidget(self.__convergenceBox)
self.__convEMLabelMapCheckBox = qt.QCheckBox()
self.__convEMLabelMapCheckBox.toolTip = 'Toggle to print the EM Label Map convergence.'
self.__convergenceBoxLayout.addRow("EM Label Map:",
self.__convEMLabelMapCheckBox)
self.__convEMLabelMapCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__convEMWeightsCheckBox = qt.QCheckBox()
self.__convEMWeightsCheckBox.toolTip = 'Toggle to print the EM Weights convergence.'
self.__convergenceBoxLayout.addRow("EM Weights:",
self.__convEMWeightsCheckBox)
self.__convEMWeightsCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__convMFALabelMapCheckBox = qt.QCheckBox()
self.__convEMWeightsCheckBox.toolTip = 'Toggle to print the MFA Label Map convergence.'
self.__convergenceBoxLayout.addRow("MFA Label Map:",
self.__convMFALabelMapCheckBox)
self.__convMFALabelMapCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__convMFAWeightsCheckBox = qt.QCheckBox()
self.__convMFAWeightsCheckBox.toolTip = 'Toggle to print the MFA Weights convergence.'
self.__convergenceBoxLayout.addRow("MFA Weights:",
self.__convMFAWeightsCheckBox)
self.__convMFAWeightsCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
#
# advancedPage
#
self.__advancedPage = qt.QWidget()
self.__advancedPageLayout = qt.QFormLayout(self.__advancedPage)
self.__dummyLabel14 = qt.QLabel(" ")
self.__advancedPageLayout.addWidget(self.__dummyLabel14)
self.__classLabel4 = qt.QLabel("Class: XX")
self.__advancedPageLayout.addWidget(self.__classLabel4)
# self.__pcaParametersBox = qt.QGroupBox()
# self.__pcaParametersBox.title = 'PCA Parameters'
# self.__pcaParametersBoxLayout = qt.QFormLayout( self.__pcaParametersBox )
# self.__advancedPageLayout.addWidget( self.__pcaParametersBox )
#
# self.__registrationParametersBox = qt.QGroupBox()
# self.__registrationParametersBox.title = 'Registration Parameters'
# self.__registrationParametersBoxLayout = qt.QFormLayout( self.__registrationParametersBox )
# self.__advancedPageLayout.addWidget( self.__registrationParametersBox )
self.__miscParametersBox = qt.QGroupBox()
self.__miscParametersBox.title = 'Miscellaneous Parameters'
self.__miscParametersBoxLayout = qt.QFormLayout(
self.__miscParametersBox)
self.__advancedPageLayout.addWidget(self.__miscParametersBox)
self.__excludeFromEStepCheckBox = qt.QCheckBox()
self.__excludeFromEStepCheckBox.toolTip = 'Toggle to exclude from Incomplete EStep.'
self.__miscParametersBoxLayout.addRow("Exclude From Incomplete EStep:",
self.__excludeFromEStepCheckBox)
self.__excludeFromEStepCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__genBackgroundProbCheckBox = qt.QCheckBox()
self.__genBackgroundProbCheckBox.toolTip = 'Toggle to detect the background value.'
self.__miscParametersBoxLayout.addRow(
"Generate Background Probability:",
self.__genBackgroundProbCheckBox)
self.__genBackgroundProbCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__meanFieldParametersBox = qt.QGroupBox()
self.__meanFieldParametersBox.title = 'Mean Field Parameters'
self.__meanFieldParametersBoxLayout = qt.QFormLayout(
self.__meanFieldParametersBox)
self.__advancedPageLayout.addWidget(self.__meanFieldParametersBox)
self.__twoDNeighborhoodCheckBox = qt.QCheckBox()
self.__twoDNeighborhoodCheckBox.toolTip = 'Toggle to use 2D Neighborhood.'
self.__meanFieldParametersBoxLayout.addRow(
"2D Neighborhood:", self.__twoDNeighborhoodCheckBox)
self.__twoDNeighborhoodCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
# self.__inhomogeneityParametersBox = qt.QGroupBox()
# self.__inhomogeneityParametersBox.title = 'Inhomogeneity Parameters'
# self.__inhomogeneityParametersBoxLayout = qt.QFormLayout( self.__inhomogeneityParametersBox )
# self.__advancedPageLayout.addWidget( self.__inhomogeneityParametersBox )
#
### add all tabs to the tabWidget
#
self.__tabWidget.addTab(self.__basicPage, "Basic")
self.__tabWidget.addTab(self.__stoppingConditionsPage,
"Stopping Conditions")
self.__tabWidget.addTab(self.__printPage, "Print")
self.__tabWidget.addTab(self.__advancedPage, "Advanced")
def loadFromMRML(self, mrmlNode=None):
'''
'''
if not self.__updating:
self.__updating = 1
self.resetPanel()
if mrmlNode:
# adjust the panel to the given mrmlNode
vtkId = self.mrmlManager().MapMRMLNodeIDToVTKNodeID(
mrmlNode.GetID())
globalNode = self.mrmlManager().GetGlobalParametersNode()
if not globalNode:
Helper.Error('No global node!')
return
# check if we have a leaf
isLeaf = self.mrmlManager().GetTreeNodeIsLeaf(vtkId)
# re-enable the widgets
self.resetPanel(True)
self.__classLabel.setText(mrmlNode.GetName())
self.__classLabel2.setText(mrmlNode.GetName())
self.__classLabel3.setText(mrmlNode.GetName())
self.__classLabel4.setText("Class: " + mrmlNode.GetName())
#
# basic panel
#
self.__classWeightSpinBox.value = self.mrmlManager(
).GetTreeNodeClassProbability(vtkId)
self.__atlasWeightSpinBox.value = self.mrmlManager(
).GetTreeNodeSpatialPriorWeight(vtkId)
if not isLeaf:
self.__mfaWeightSpinBox.setEnabled(True)
self.__mfaWeightSpinBox.value = self.mrmlManager(
).GetTreeNodeAlpha(vtkId)
else:
self.__mfaWeightSpinBox.value = 0
self.__mfaWeightSpinBox.setEnabled(False)
## input channel weights
# 1. clear all
for i in self.__inputChannelWeights:
l = self.__inputChannelWeightsBoxLayout.labelForField(i)
self.__inputChannelWeightsBoxLayout.removeWidget(l)
l.deleteLater()
l.setParent(None)
l = None
self.__inputChannelWeightsBoxLayout.removeWidget(i)
i.deleteLater()
i.setParent(None)
i = None
self.__inputChannelWeights = []
# 2. re-create all
numberOfVolumes = self.mrmlManager(
).GetTargetNumberOfSelectedVolumes()
for i in range(numberOfVolumes):
# create new spinbox
currentSpinBox = qt.QDoubleSpinBox()
currentSpinBox.minimum = 0
currentSpinBox.maximum = 1
currentSpinBox.singleStep = 0.01
currentSpinBox.value = self.mrmlManager(
).GetTreeNodeInputChannelWeight(vtkId, i)
self.__inputChannelWeights.append(currentSpinBox)
self.__inputChannelWeights[-1].connect(
'valueChanged(double)', self.propagateToMRML)
self.__inputChannelWeightsBoxLayout.addRow(
globalNode.GetNthTargetInputChannelName(i),
self.__inputChannelWeights[-1])
#
# stopping conditions panel
#
if isLeaf:
self.__tabWidget.setTabEnabled(1, False)
else:
# only show if we did not select a leaf
self.__tabWidget.setTabEnabled(1, True)
self.__emComboBox.setCurrentIndex(
self.mrmlManager().GetTreeNodeStoppingConditionEMType(
vtkId))
if self.__emComboBox.currentIndex == 0:
# iteration selected
self.__stoppingConditionsPageLayoutRight.labelForField(
self.__emValueSpinBox).setText('Iterations:')
self.__emValueSpinBox.value = self.mrmlManager(
).GetTreeNodeStoppingConditionEMIterations(vtkId)
elif self.__emComboBox.currentIndex >= 1:
# labelMap or value selected
self.__stoppingConditionsPageLayoutRight.labelForField(
self.__emValueSpinBox).setText('Value:')
self.__emValueSpinBox.value = self.mrmlManager(
).GetTreeNodeStoppingConditionEMValue(vtkId)
self.__mfaComboBox.setCurrentIndex(
self.mrmlManager().GetTreeNodeStoppingConditionMFAType(
vtkId))
if self.__mfaComboBox.currentIndex == 0:
# iteration selected
self.__stoppingConditionsPageLayoutRight.labelForField(
self.__mfaValueSpinBox).setText('Iterations:')
self.__mfaValueSpinBox.value = self.mrmlManager(
).GetTreeNodeStoppingConditionMFAIterations(vtkId)
elif self.__mfaComboBox.currentIndex >= 1:
# labelMap or value selected
self.__stoppingConditionsPageLayoutRight.labelForField(
self.__mfaValueSpinBox).setText('Value:')
self.__mfaValueSpinBox.value = self.mrmlManager(
).GetTreeNodeStoppingConditionMFAValue(vtkId)
self.__biasSpinBox.value = self.mrmlManager(
).GetTreeNodeBiasCalculationMaxIterations(vtkId)
#
# print panel
#
if isLeaf:
self.__weightCheckBox.show()
self.__printPageLayoutLeft.labelForField(
self.__qualityCheckBox).show()
self.__qualityCheckBox.show()
self.__printPageLayoutLeft.labelForField(
self.__frequencySpinBox).hide()
self.__frequencySpinBox.hide()
self.__printPageLayoutLeft.labelForField(
self.__biasCheckBox).hide()
self.__biasCheckBox.hide()
self.__printPageLayoutLeft.labelForField(
self.__labelMapCheckBox).hide()
self.__labelMapCheckBox.hide()
self.__convergenceBox.hide()
self.__weightCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintWeight(vtkId)
self.__qualityCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintQuality(vtkId)
else:
self.__weightCheckBox.show()
self.__printPageLayoutLeft.labelForField(
self.__qualityCheckBox).hide()
self.__qualityCheckBox.hide()
self.__printPageLayoutLeft.labelForField(
self.__frequencySpinBox).show()
self.__frequencySpinBox.show()
self.__printPageLayoutLeft.labelForField(
self.__biasCheckBox).show()
self.__biasCheckBox.show()
self.__printPageLayoutLeft.labelForField(
self.__labelMapCheckBox).show()
self.__labelMapCheckBox.show()
self.__convergenceBox.show()
self.__weightCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintWeight(vtkId)
self.__frequencySpinBox.value = self.mrmlManager(
).GetTreeNodePrintFrequency(vtkId)
self.__biasCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintBias(vtkId)
self.__labelMapCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintLabelMap(vtkId)
self.__convEMLabelMapCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintEMLabelMapConvergence(vtkId)
self.__convEMWeightsCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintEMWeightsConvergence(vtkId)
self.__convMFALabelMapCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintMFALabelMapConvergence(vtkId)
self.__convMFAWeightsCheckBox.checked = self.mrmlManager(
).GetTreeNodePrintMFAWeightsConvergence(vtkId)
#
# Advanced panel
#
if isLeaf:
self.__tabWidget.setTabEnabled(3, False)
self.__miscParametersBoxLayout.labelForField(
self.__excludeFromEStepCheckBox).hide()
self.__excludeFromEStepCheckBox.hide()
self.__miscParametersBoxLayout.labelForField(
self.__genBackgroundProbCheckBox).hide()
self.__genBackgroundProbCheckBox.hide()
self.__meanFieldParametersBoxLayout.labelForField(
self.__twoDNeighborhoodCheckBox).hide()
self.__twoDNeighborhoodCheckBox.hide()
else:
self.__tabWidget.setTabEnabled(3, True)
self.__miscParametersBoxLayout.labelForField(
self.__excludeFromEStepCheckBox).show()
self.__excludeFromEStepCheckBox.show()
self.__miscParametersBoxLayout.labelForField(
self.__genBackgroundProbCheckBox).show()
self.__genBackgroundProbCheckBox.show()
self.__meanFieldParametersBoxLayout.labelForField(
self.__twoDNeighborhoodCheckBox).show()
self.__twoDNeighborhoodCheckBox.show()
self.__excludeFromEStepCheckBox.checked = self.mrmlManager(
).GetTreeNodeExcludeFromIncompleteEStep(vtkId)
self.__genBackgroundProbCheckBox.checked = self.mrmlManager(
).GetTreeNodeGenerateBackgroundProbability(vtkId)
self.__twoDNeighborhoodCheckBox.checked = self.mrmlManager(
).GetTreeNodeInteractionMatrices2DFlag(vtkId)
#
# overview panel
#
# first, clear it all
for i in self.__classWeights:
self.__overviewBoxLayout.removeWidget(i)
i.deleteLater()
i.setParent(None)
i = None
self.__classWeights = []
self.__classWeightLayouts = []
self.__classWeightLabels = []
self.__classWeightSpinBoxes = []
self.__classWeightCheckBoxes = []
# fill it again
if vtkId != self.mrmlManager().GetTreeRootNodeID():
# other node than root selected
parent = self.mrmlManager().GetTreeNodeParentNodeID(vtkId)
numberOfChildren = self.mrmlManager(
).GetTreeNodeNumberOfChildren(parent)
for i in range(numberOfChildren):
child = self.mrmlManager().GetTreeNodeChildNodeID(
parent, i)
name = self.mrmlManager().GetTreeNodeName(child)
probability = self.mrmlManager(
).GetTreeNodeClassProbability(child)
label = qt.QLabel(name + ":")
spinBox = qt.QDoubleSpinBox()
spinBox.minimum = 0
spinBox.maximum = 1
spinBox.singleStep = 0.01
spinBox.value = probability
checkBox = qt.QCheckBox(" ")
checkBox.toolTip = 'Toggle for auto-update when changing other weights.'
self.__classWeightLabels.append(label)
self.__classWeightSpinBoxes.append(spinBox)
self.__classWeightCheckBoxes.append(checkBox)
self.__classWeightSpinBoxes[-1].connect(
'valueChanged(double)', self.updateClassWeights)
self.__classWeightCheckBoxes[-1].connect(
'stateChanged(int)', self.updateClassWeights)
weightRow = qt.QWidget()
weightRowLayout = qt.QHBoxLayout(weightRow)
weightRowLayout.addWidget(self.__classWeightLabels[-1])
weightRowLayout.addWidget(
self.__classWeightSpinBoxes[-1])
weightRowLayout.addWidget(
self.__classWeightCheckBoxes[-1])
self.__classWeights.append(weightRow)
self.__classWeightLayouts.append(weightRowLayout)
self.__overviewBoxLayout.addWidget(
self.__classWeights[-1], 0, 2)
self.__updating = 0
def create(self):
super(BinaryWatershedEffectOptions, self).create()
if not HAVE_SIMPLEITK:
self.warningLabel = qt.QLabel()
self.warningLabel.text = "BinaryWatershed is not available because\nSimpleITK is not available in this build"
self.widgets.append(self.warningLabel)
self.frame.layout().addWidget(self.warningLabel)
return
self.splitSizeFrame = qt.QFrame(self.frame)
self.splitSizeFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.splitSizeFrame)
self.widgets.append(self.splitSizeFrame)
tip = "Sets the a minimum size for labels which will be split into multiple objects."
self.splitSizeLabel = qt.QLabel("Split Size:", self.frame)
self.splitSizeLabel.setToolTip(tip)
self.splitSizeFrame.layout().addWidget(self.splitSizeLabel)
self.widgets.append(self.splitSizeLabel)
self.minimumSplitSize = 0
self.maximumSplitSize = 100
self.splitSizeSlider = qt.QSlider(qt.Qt.Horizontal, self.frame)
self.splitSizeSlider.setValue(1)
self.splitSizeFrame.layout().addWidget(self.splitSizeSlider)
self.splitSizeFrame.setToolTip(tip)
self.widgets.append(self.splitSizeSlider)
self.splitSizeSpinBox = qt.QDoubleSpinBox(self.frame)
self.splitSizeSpinBox.setToolTip(tip)
self.splitSizeSpinBox.setValue(1)
self.splitSizeSpinBox.suffix = "mm"
self.splitSizeFrame.layout().addWidget(self.splitSizeSpinBox)
self.widgets.append(self.splitSizeSpinBox)
self.splitSizeSpinBox.minimum = self.minimumSplitSize
self.splitSizeSlider.minimum = self.minimumSplitSize
self.splitSizeSpinBox.maximum = self.maximumSplitSize
self.splitSizeSlider.maximum = self.maximumSplitSize
self.apply = qt.QPushButton("Apply", self.frame)
self.apply.setToolTip("Apply the binary watershed operation")
self.frame.layout().addWidget(self.apply)
self.widgets.append(self.apply)
helpDoc = """Split selected label into separate objects based at minimum size the objects."""
HelpButton(self.frame, helpDoc)
self.apply.connect('clicked()', self.onApply)
self.splitSizeSlider.connect('valueChanged(int)',
self.splitSizeSpinBox.setValue)
self.splitSizeSpinBox.connect('valueChanged(double)',
self.splitSizeSlider.setValue)
# if either widget is changed both should change and this should be triggered
self.connections.append((self.splitSizeSpinBox, 'valueChanged(double)',
self.onSplitSizeValueChanged))
# Add vertical spacer
self.frame.layout().addStretch(1)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Instantiate and connect widgets ...
#--------------------------------------------------
# For debugging
#
# Reload and Test area
reloadCollapsibleButton = ctk.ctkCollapsibleButton()
reloadCollapsibleButton.text = "Reload && Test"
self.layout.addWidget(reloadCollapsibleButton)
reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton)
reloadCollapsibleButton.collapsed = True
# reload button
# (use this during development, but remove it when delivering
# your module to users)
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload this module."
self.reloadButton.name = "NeedleGuideTemlpate Reload"
reloadFormLayout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
#
#--------------------------------------------------
#
# Fiducial Node
#
fiducialsCollapsibleButton = ctk.ctkCollapsibleButton()
fiducialsCollapsibleButton.text = "Fiducials"
self.layout.addWidget(fiducialsCollapsibleButton)
# Layout within the dummy collapsible button
fiducialsFormLayout = qt.QFormLayout(fiducialsCollapsibleButton)
#
# Fiducial node selector
#
self.fiducialSelector = slicer.qMRMLNodeComboBox()
self.fiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "")
self.fiducialSelector.selectNodeUponCreation = True
self.fiducialSelector.addEnabled = True
self.fiducialSelector.removeEnabled = True
self.fiducialSelector.noneEnabled = False
self.fiducialSelector.renameEnabled = True
self.fiducialSelector.showHidden = False
self.fiducialSelector.showChildNodeTypes = False
self.fiducialSelector.setMRMLScene(slicer.mrmlScene)
self.fiducialSelector.setToolTip("Pick the input to the algorithm.")
fiducialsFormLayout.addRow("Input Volume: ", self.fiducialSelector)
#
# Reconfigure Button
#
self.radiusEdit = qt.QDoubleSpinBox()
self.radiusEdit.setMinimum(0.0)
self.radiusEdit.setMaximum(500.0)
self.radiusEdit.setSingleStep(0.5)
self.radiusEdit.setValue(50)
self.numFiducialsEdit = qt.QSpinBox()
self.numFiducialsEdit.setMinimum(0)
self.numFiducialsEdit.setMaximum(100)
self.numFiducialsEdit.setSingleStep(1)
self.numFiducialsEdit.setValue(5)
fiducialsFormLayout.addRow("Radius (mm):", self.radiusEdit)
fiducialsFormLayout.addRow("# of fiducials:", self.numFiducialsEdit)
self.reconfigureButton = qt.QPushButton("Reconfigure Fiducials")
self.reconfigureButton.toolTip = "Reconfigure fiducial frame"
self.reconfigureButton.enabled = False
fiducialsFormLayout.addRow(self.reconfigureButton)
#
# Test Area
#
testCollapsibleButton = ctk.ctkCollapsibleButton()
testCollapsibleButton.text = "Test"
self.layout.addWidget(testCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(testCollapsibleButton)
#
# input volume selector
#
self.inputSelector = slicer.qMRMLNodeComboBox()
self.inputSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "")
self.inputSelector.selectNodeUponCreation = True
self.inputSelector.addEnabled = False
self.inputSelector.removeEnabled = False
self.inputSelector.noneEnabled = False
self.inputSelector.showHidden = False
self.inputSelector.showChildNodeTypes = False
self.inputSelector.setMRMLScene(slicer.mrmlScene)
self.inputSelector.setToolTip("Pick the input to the algorithm.")
parametersFormLayout.addRow("Input Fiducial: ", self.inputSelector)
#
# reference volume selector
#
self.referenceSelector = slicer.qMRMLNodeComboBox()
self.referenceSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.referenceSelector.selectNodeUponCreation = False
self.referenceSelector.addEnabled = True
self.referenceSelector.removeEnabled = True
self.referenceSelector.noneEnabled = False
self.referenceSelector.showHidden = False
self.referenceSelector.showChildNodeTypes = False
self.referenceSelector.setMRMLScene(slicer.mrmlScene)
self.referenceSelector.setToolTip(
"Pick the reference to the algorithm.")
parametersFormLayout.addRow("Reference Volume: ",
self.referenceSelector)
logFileLayout = qt.QHBoxLayout()
self.logFileLineEdit = qt.QLineEdit()
self.logFileLineEdit.text = ''
self.logFileLineEdit.readOnly = True
self.logFileLineEdit.frame = True
self.logFileLineEdit.styleSheet = "QLineEdit { background:transparent; }"
self.logFileLineEdit.cursor = qt.QCursor(qt.Qt.IBeamCursor)
logFileLayout.addWidget(self.logFileLineEdit)
self.logFileButton = qt.QPushButton("Choose File...")
self.logFileButton.toolTip = "Choose log file from dialog box"
logFileLayout.addWidget(self.logFileButton)
parametersFormLayout.addRow("Log file:", logFileLayout)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
# connections
self.fiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onFiducialSelect)
self.reconfigureButton.connect('clicked(bool)',
self.onReconfigureButton)
self.logFileButton.connect('clicked(bool)', self.onLogFileButton)
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
self.referenceSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
# Create logic
self.logic = FiducialRegistrationTestLogic(None)
# Enable buttons, if nodes are selected
self.onSelect()
self.onFiducialSelect()
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Instantiate and connect widgets ...
if not NUMPY_AVAILABLE:
label = qt.QLabel(
'The module is not available due to missing Numpy package.')
self.layout.addWidget(label)
label = qt.QLabel(
'You can seek help by contacting 3D Slicer user list: [email protected]'
)
self.layout.addWidget(label)
# Add vertical spacer
self.layout.addStretch(1)
return
# Collapsible button
dummyCollapsibleButton = ctk.ctkCollapsibleButton()
dummyCollapsibleButton.text = "Basic settings"
self.layout.addWidget(dummyCollapsibleButton)
dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)
# add input directory selector
label = qt.QLabel('Input directory:')
self.__fDialog = ctk.ctkDirectoryButton()
self.__fDialog.caption = 'Input directory'
dummyFormLayout.addRow(label, self.__fDialog)
label = qt.QLabel('Output node:')
self.__mvSelector = slicer.qMRMLNodeComboBox()
self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.__mvSelector.setMRMLScene(slicer.mrmlScene)
self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.onMRMLSceneChanged)
self.__mvSelector.addEnabled = 1
dummyFormLayout.addRow(label, self.__mvSelector)
# Collapsible button
dummyCollapsibleButton = ctk.ctkCollapsibleButton()
dummyCollapsibleButton.text = "Advanced settings"
dummyCollapsibleButton.collapsed = 1
self.layout.addWidget(dummyCollapsibleButton)
dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)
self.__advancedFrame = dummyCollapsibleButton
label = qt.QLabel('Frame identifying DICOM tag (if known):')
self.__dicomTag = qt.QLineEdit()
self.__dicomTag.text = 'NA'
dummyFormLayout.addRow(label, self.__dicomTag)
label = qt.QLabel('Frame identifying units:')
self.__veLabel = qt.QLineEdit()
self.__veLabel.text = 'na'
dummyFormLayout.addRow(label, self.__veLabel)
label = qt.QLabel('Initial value:')
self.__veInitial = qt.QDoubleSpinBox()
self.__veInitial.value = 0
dummyFormLayout.addRow(label, self.__veInitial)
label = qt.QLabel('Step:')
self.__veStep = qt.QDoubleSpinBox()
self.__veStep.value = 1
dummyFormLayout.addRow(label, self.__veStep)
label = qt.QLabel('EchoTime:')
self.__te = qt.QDoubleSpinBox()
self.__te.value = 1
dummyFormLayout.addRow(label, self.__te)
label = qt.QLabel('RepetitionTime:')
self.__tr = qt.QDoubleSpinBox()
self.__tr.value = 1
dummyFormLayout.addRow(label, self.__tr)
label = qt.QLabel('FlipAngle:')
self.__fa = qt.QDoubleSpinBox()
self.__fa.value = 1
dummyFormLayout.addRow(label, self.__fa)
importButton = qt.QPushButton("Import")
importButton.toolTip = "Import the contents of the directory as a MultiVolume"
self.layout.addWidget(importButton)
importButton.connect('clicked(bool)', self.onImportButtonClicked)
self.__status = qt.QLabel('Status: Idle')
self.layout.addWidget(self.__status)
# Add vertical spacer
self.layout.addStretch(1)
def loadFromMRML(self, mrmlNode=None):
'''
'''
if not self.__updating:
self.__updating = 1
self.resetPanel()
if mrmlNode:
# adjust the panel to the given mrmlNode
vtkId = self.mrmlManager().MapMRMLNodeIDToVTKNodeID(
mrmlNode.GetID())
# number of volumes
numberOfVolumes = self.mrmlManager(
).GetTargetNumberOfSelectedVolumes()
# re-enable the widgets
self.resetPanel(True)
self.__classLabel2.setText("Class: " + mrmlNode.GetName())
self.setupManualSampleTable(mrmlNode)
for c in range(numberOfVolumes):
value = self.mrmlManager(
).GetTreeNodeDistributionMeanWithCorrection(vtkId, c)
for r in range(numberOfVolumes):
for c in range(numberOfVolumes):
value = self.mrmlManager(
).GetTreeNodeDistributionLogCovarianceWithCorrection(
vtkId, r, c)
#
# overview panel
#
# first, clear it all
for i in self.__classWeights:
self.__overviewBoxLayout.removeWidget(i)
i.deleteLater()
i.setParent(None)
i = None
self.__classWeights = []
self.__classWeightLayouts = []
self.__classWeightLabels = []
self.__classWeightSpinBoxes = []
self.__classWeightCheckBoxes = []
# fill it again
if vtkId != self.mrmlManager().GetTreeRootNodeID():
# other node than root selected
parent = self.mrmlManager().GetTreeNodeParentNodeID(vtkId)
numberOfChildren = self.mrmlManager(
).GetTreeNodeNumberOfChildren(parent)
for i in range(numberOfChildren):
child = self.mrmlManager().GetTreeNodeChildNodeID(
parent, i)
name = self.mrmlManager().GetTreeNodeName(child)
probability = self.mrmlManager(
).GetTreeNodeClassProbability(child)
label = qt.QLabel(name + ":")
spinBox = qt.QDoubleSpinBox()
spinBox.minimum = 0
spinBox.maximum = 1
spinBox.singleStep = 0.01
spinBox.value = probability
checkBox = qt.QCheckBox(" ")
checkBox.toolTip = 'Toggle for auto-update when changing other weights.'
self.__classWeightLabels.append(label)
self.__classWeightSpinBoxes.append(spinBox)
self.__classWeightCheckBoxes.append(checkBox)
self.__classWeightSpinBoxes[-1].connect(
'valueChanged(double)', self.updateClassWeights)
self.__classWeightCheckBoxes[-1].connect(
'stateChanged(int)', self.updateClassWeights)
weightRow = qt.QWidget()
weightRowLayout = qt.QHBoxLayout(weightRow)
weightRowLayout.addWidget(self.__classWeightLabels[-1])
weightRowLayout.addWidget(
self.__classWeightSpinBoxes[-1])
weightRowLayout.addWidget(
self.__classWeightCheckBoxes[-1])
self.__classWeights.append(weightRow)
self.__classWeightLayouts.append(weightRowLayout)
self.__overviewBoxLayout.addWidget(
self.__classWeights[-1], 0, 2)
self.__updating = 0
def create(self):
super(InteractiveConnectedComponentsUsingParzenPDFsOptions,
self).create()
ioCollapsibleButton = ctk.ctkCollapsibleGroupBox()
ioCollapsibleButton.title = "IO"
ioCollapsibleButton.collapsed = 0
self.frame.layout().addWidget(ioCollapsibleButton)
# Layout within the io collapsible button
ioFormLayout = qt.QFormLayout(ioCollapsibleButton)
self.additionalInputNodeSelectors = []
for i in range(0, 2):
self.additionalInputNodeSelectors.append(
self.addInputNodeSelector(i, ioFormLayout))
self.additionalInputNodeSelectors[
0].toolTip = "Select the 1st additional input volume to be segmented"
self.additionalInputNodeSelectors[
1].toolTip = "Select the 2nd additional input volume to be segmented"
# Objects
objectCollapsibleGroupBox = ctk.ctkCollapsibleGroupBox()
objectCollapsibleGroupBox.title = "Objects"
self.frame.layout().addWidget(objectCollapsibleGroupBox)
# Layout within the io collapsible button
objectFormLayout = qt.QFormLayout(objectCollapsibleGroupBox)
foregroundLayout = qt.QHBoxLayout()
foregroundLabel = slicer.qMRMLLabelComboBox()
foregroundLabel.objectName = 'Foreground label'
foregroundLabel.setMRMLScene(slicer.mrmlScene)
foregroundLabel.setMRMLColorNode(self.editUtil.getColorNode())
foregroundLabel.labelValueVisible = True
foregroundLabel.currentColor = 1
self.foregroundLabel = foregroundLabel
self.connections.append(
(self.foregroundLabel, 'currentColorChanged(int)',
self.updateMRMLFromGUI))
foregroundWeightSpinBox = qt.QDoubleSpinBox(foregroundLabel)
self.foregroundWeightSpinBox = foregroundWeightSpinBox
foregroundWeightSpinBox.setRange(0.0, 1.0)
foregroundWeightSpinBox.setSingleStep(0.1)
foregroundWeightSpinBox.value = 1.0
foregroundPopup = ctk.ctkPopupWidget(foregroundWeightSpinBox)
foregroundPopupLayout = qt.QHBoxLayout(foregroundPopup)
foregroundPopupSlider = ctk.ctkDoubleSlider(foregroundPopup)
self.foregroundPopupSlider = foregroundPopupSlider
foregroundPopupSlider.maximum = 1.0
foregroundPopupSlider.minimum = 0.0
foregroundPopupSlider.singleStep = 0.1
foregroundPopupSlider.connect('valueChanged(double)',
self.foregroundWeightSpinBox.setValue)
foregroundWeightSpinBox.connect('valueChanged(double)',
self.foregroundPopupSlider.setValue)
self.connections.append(
(self.foregroundWeightSpinBox, 'valueChanged(double)',
self.updateMRMLFromGUI))
foregroundLayout.addWidget(foregroundLabel)
foregroundLayout.addWidget(foregroundWeightSpinBox)
foregroundPopupLayout.addWidget(foregroundPopupSlider)
objectFormLayout.addRow("Foreground Label:", foregroundLayout)
self.objectLabel = foregroundLabel
# http://qt-project.org/doc/qt-4.7/qt.html
foregroundPopup.alignment = 0x0082 # Qt::AlignVCenter | Qt::AlignRight
foregroundPopup.horizontalDirection = 0 # Qt::LeftToRight
foregroundPopup.verticalDirection = 0 # Qt::TopToBottom
foregroundPopup.animationEffect = 1 # Qt::ScrollEffect
backgroundLayout = qt.QHBoxLayout()
backgroundLabel = slicer.qMRMLLabelComboBox()
backgroundLabel.objectName = 'Background label'
backgroundLabel.setMRMLScene(slicer.mrmlScene)
backgroundLabel.setMRMLColorNode(self.editUtil.getColorNode())
backgroundLabel.labelValueVisible = True
backgroundLabel.currentColor = 2
self.backgroundLabel = backgroundLabel
self.connections.append(
(self.backgroundLabel, 'currentColorChanged(int)',
self.updateMRMLFromGUI))
backgroundWeightSpinBox = qt.QDoubleSpinBox(backgroundLabel)
self.backgroundWeightSpinBox = backgroundWeightSpinBox
backgroundWeightSpinBox.setRange(0.0, 1.0)
backgroundWeightSpinBox.setSingleStep(0.1)
backgroundWeightSpinBox.value = 1.0
backgroundPopup = ctk.ctkPopupWidget(backgroundWeightSpinBox)
backgroundPopupLayout = qt.QHBoxLayout(backgroundPopup)
backgroundPopupSlider = ctk.ctkDoubleSlider(backgroundPopup)
self.backgroundPopupSlider = backgroundPopupSlider
backgroundPopupSlider.maximum = 1.0
backgroundPopupSlider.minimum = 0.0
backgroundPopupSlider.singleStep = 0.1
backgroundPopupSlider.connect('valueChanged(double)',
self.backgroundWeightSpinBox.setValue)
backgroundWeightSpinBox.connect('valueChanged(double)',
self.backgroundPopupSlider.setValue)
self.connections.append(
(self.backgroundWeightSpinBox, 'valueChanged(double)',
self.updateMRMLFromGUI))
backgroundLayout.addWidget(backgroundLabel)
backgroundLayout.addWidget(backgroundWeightSpinBox)
backgroundPopupLayout.addWidget(backgroundPopupSlider)
objectFormLayout.addRow("Background Label:", backgroundLayout)
self.backgroundLabel = backgroundLabel
# http://qt-project.org/doc/qt-4.7/qt.html
backgroundPopup.alignment = 0x0082 # Qt::AlignVCenter | Qt::AlignRight
backgroundPopup.horizontalDirection = 0 # Qt::LeftToRight
backgroundPopup.verticalDirection = 0 # Qt::TopToBottom
backgroundPopup.animationEffect = 1 # Qt::ScrollEffect
# Presets
# Placeholder
presetsCollapsibleGroupBox = ctk.ctkCollapsibleGroupBox()
presetsCollapsibleGroupBox.title = "Preset"
self.frame.layout().addWidget(presetsCollapsibleGroupBox)
presetComboBox = slicer.qSlicerPresetComboBox()
# Advanced Parameters
paramsCollapsibleGroupBox = ctk.ctkCollapsibleGroupBox()
paramsCollapsibleGroupBox.title = "Advanced Parameters"
paramsCollapsibleGroupBox.collapsed = 1
self.frame.layout().addWidget(paramsCollapsibleGroupBox)
# Layout within the io collapsible button
paramsFormLayout = qt.QFormLayout(paramsCollapsibleGroupBox)
erosionSpinBox = qt.QSpinBox()
erosionSpinBox.objectName = 'erosionSpinBox'
erosionSpinBox.toolTip = "Set the erosion radius."
erosionSpinBox.setMinimum(0)
erosionSpinBox.setValue(5) # Default
paramsFormLayout.addRow("Erosion Radius:", erosionSpinBox)
self.erosionSpinBox = erosionSpinBox
self.connections.append(
(self.erosionSpinBox, "valueChanged(int)", self.updateMRMLFromGUI))
holeFillSpinBox = qt.QSpinBox()
holeFillSpinBox.objectName = 'holeFillSpinBox'
holeFillSpinBox.toolTip = "Set the hole fill iterations."
holeFillSpinBox.setMinimum(0)
holeFillSpinBox.setValue(5) #Default
paramsFormLayout.addRow("Hole Fill Iterations:", holeFillSpinBox)
self.holeFillSpinBox = holeFillSpinBox
self.connections.append((self.holeFillSpinBox, "valueChanged(int)",
self.updateMRMLFromGUI))
# probabilitySmoothingStandardDeviation spin box
probabilitySmoothingStdDevSpinBox = qt.QDoubleSpinBox()
probabilitySmoothingStdDevSpinBox.objectName = 'probabilitySmoothingStdDevSpinBox'
probabilitySmoothingStdDevSpinBox.toolTip = "Standard deviation of blur applied to probability images prior to computing maximum likelihood of each class at each pixel."
probabilitySmoothingStdDevSpinBox.setMinimum(0.0)
probabilitySmoothingStdDevSpinBox.setValue(1.0) # Default
probabilitySmoothingStdDevSpinBox.setSingleStep(0.5)
paramsFormLayout.addRow("Probability Smoothing Standard Deviation:",
probabilitySmoothingStdDevSpinBox)
self.probabilitySmoothingStdDevSpinBox = probabilitySmoothingStdDevSpinBox
self.connections.append(
(self.probabilitySmoothingStdDevSpinBox, "valueChanged(double)",
self.updateMRMLFromGUI))
# histogramSmoothingStandardDeviation spin box
histogramSmoothingStdDevSpinBox = qt.QDoubleSpinBox()
histogramSmoothingStdDevSpinBox.objectName = 'histogramSmoothingStdDevSpinBox'
histogramSmoothingStdDevSpinBox.toolTip = "Standard deviation of blur applied to histograms to convert them to probability density function estimates."
histogramSmoothingStdDevSpinBox.setMinimum(0.0)
histogramSmoothingStdDevSpinBox.setValue(5.0) # Default
histogramSmoothingStdDevSpinBox.setSingleStep(0.5)
paramsFormLayout.addRow("Probability Smoothing Standard Deviation:",
histogramSmoothingStdDevSpinBox)
self.histogramSmoothingStdDevSpinBox = histogramSmoothingStdDevSpinBox
self.connections.append(
(self.histogramSmoothingStdDevSpinBox, "valueChanged(double)",
self.updateMRMLFromGUI))
# draft check box
draftCheckBox = qt.QCheckBox()
draftCheckBox.objectName = 'draftCheckBox'
draftCheckBox.toolTip = "Downsamples results by a factor of 4."
paramsFormLayout.addRow("Draft Mode:", draftCheckBox)
self.draftCheckBox = draftCheckBox
self.connections.append(
(self.draftCheckBox, "stateChanged(int)", self.updateMRMLFromGUI))
# force classification check box
forceClassificationCheckBox = qt.QCheckBox()
forceClassificationCheckBox.objectName = 'forceClassificationCheckBox'
forceClassificationCheckBox.toolTip = "Perform the classification of all voxels?"
forceClassificationCheckBox.setChecked(False)
paramsFormLayout.addRow("Classify all voxels: ",
forceClassificationCheckBox)
self.forceClassificationCheckBox = forceClassificationCheckBox
self.connections.append((self.forceClassificationCheckBox,
"stateChanged(int)", self.updateMRMLFromGUI))
# dilate first check box
dilateFirstCheckBox = qt.QCheckBox()
dilateFirstCheckBox.objectName = 'dilateFirstCheckBox'
dilateFirstCheckBox.toolTip = "Dilate and then erode so as to fill-in holes?"
dilateFirstCheckBox.setChecked(False)
paramsFormLayout.addRow("Dilate First: ", dilateFirstCheckBox)
self.dilateFirstCheckBox = dilateFirstCheckBox
self.connections.append((self.dilateFirstCheckBox, "stateChanged(int)",
self.updateMRMLFromGUI))
self.helpLabel = qt.QLabel(
"Run the PDF Segmentation on the current label map.", self.frame)
self.frame.layout().addWidget(self.helpLabel)
self.apply = qt.QPushButton("Apply", self.frame)
self.apply.setToolTip(
"Apply to run segmentation.\nCreates a new label volume using the current volume as input"
)
self.frame.layout().addWidget(self.apply)
self.widgets.append(self.apply)
EditorLib.HelpButton(
self.frame,
"Use this tool to apply segmentation using Parzen windowed PDFs.\n\n Select different label colors and paint on the foreground or background voxels using the paint effect.\nTo run segmentation correctly, you need to supply a minimum or two class labels."
)
self.connections.append((self.apply, 'clicked()', self.onApply))
def setup(self):
# Instantiate and connect widgets ...
#
# Reload and Test area
#
reloadCollapsibleButton = ctk.ctkCollapsibleButton()
reloadCollapsibleButton.text = "Reload && Test"
self.layout.addWidget(reloadCollapsibleButton)
reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton)
# reload buttonino
# (use this during development, but remove it when delivering
# your module to users)
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload this module."
self.reloadButton.name = "PectoralisSegmentation Reload"
reloadFormLayout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
# reload and test button
# (use this during development, but remove it when delivering
# your module to users)
self.reloadAndTestButton = qt.QPushButton("Reload and Test")
self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests."
reloadFormLayout.addWidget(self.reloadAndTestButton)
self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest)
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# input volume selector
#
self.inputSelector = slicer.qMRMLNodeComboBox()
self.inputSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.inputSelector.selectNodeUponCreation = True
self.inputSelector.addEnabled = False
self.inputSelector.removeEnabled = False
self.inputSelector.noneEnabled = False
self.inputSelector.showHidden = False
self.inputSelector.showChildNodeTypes = False
self.inputSelector.setMRMLScene(slicer.mrmlScene)
self.inputSelector.setToolTip("Pick the input to the algorithm.")
parametersFormLayout.addRow("Input Volume: ", self.inputSelector)
#
# output segmentation selector
#
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.outputSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap",
0)
self.outputSelector.selectNodeUponCreation = False
self.outputSelector.addEnabled = True
self.outputSelector.removeEnabled = True
self.outputSelector.noneEnabled = False
self.outputSelector.showHidden = False
self.outputSelector.showChildNodeTypes = False
self.outputSelector.setMRMLScene(slicer.mrmlScene)
self.outputSelector.setToolTip("Pick the output to the algorithm.")
parametersFormLayout.addRow("Output Volume: ", self.outputSelector)
#text file with all the labelmaps
#self.labelMapFileSelector = qt.QFileDialog()
#label_file = self.labelMapFileSelector.getOpenFileNames(
# self.labelMapFileSelector,
# "Select files to open",
# "/home",
# "text (*.txt)");
#text = str(combobox1.currentText())
#parametersFormLayout.addRow("Text file with labelmap names: ", self.labelMapFileSelector)
self.descriptionEdit = qt.QLineEdit(
"/Users/rolaharmouche/Documents/Caselists/INSP_STD_PECS_training_atlas_filename.txt"
)
parametersFormLayout.addRow("Training Labelmaps file name:",
self.descriptionEdit)
#Add parameters:
self.similarityThreshold = qt.QDoubleSpinBox()
self.similarityThreshold.setRange(0, 1)
self.similarityThreshold.setSingleStep(0.1)
self.similarityThreshold.setValue(1)
self.similarityThreshold.setToolTip(
"Maximum NCC similarity value to include.")
parametersFormLayout.addRow(
"Maximum NCC similarity value to include: ",
self.similarityThreshold)
self.numTrainingLabels = qt.QSpinBox()
self.numTrainingLabels.setRange(1, 100)
self.numTrainingLabels.setValue(10)
self.numTrainingLabels.setToolTip(
"Specify the number of training labels used to build the atlas.")
parametersFormLayout.addRow("Number of labels for atlas generation: ",
self.numTrainingLabels)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Segment")
self.applyButton.toolTip = "Run the segmentation algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
self.dbpath = None
self.dbcsvpath = None
self.flirttemplate = '/usr/share/fsl/5.0/data/standard/MNI152_T1_2mm_brain.nii.gz'
#
# Reload and Test area
#
reloadCollapsibleButton = ctk.ctkCollapsibleButton()
reloadCollapsibleButton.text = "Reload && Test"
self.layout.addWidget(reloadCollapsibleButton)
reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton)
self.clearButton = qt.QPushButton("Clear Scene")
self.clearButton.toolTip = "Clear all the volumes and models in 3D views"
self.clearButton.name = "AdniDemonsDatabase Clear"
reloadFormLayout.addWidget(self.clearButton)
self.clearButton.connect('clicked()', self.onClear)
# reload button
# (use this during development, but remove it when delivering
# your module to users)
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload AdniDemonsDatabase"
self.reloadButton.name = "AdniDemonsDatabase Reload"
reloadFormLayout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
# Get the test methods create a button for each of them
testklsdir = dir(AdniDemonsDatabaseTest)
# reload and test button
# (use this during development, but remove it when delivering your module to users)
# reload and run specific tests
# scenarios = ('All', 'Model', 'Volume', 'SceneView_Simple', 'SceneView_Complex')
scenarios = [n for n in testklsdir if n.startswith('test_')]
for scenario in scenarios:
button = qt.QPushButton("Reload and Test %s" % scenario)
button.toolTip = "Reload this module and then run the self test on %s." % scenario
reloadFormLayout.addWidget(button)
button.connect('clicked()', lambda s = scenario: self.onReloadAndTest(scenario = s))
#
# Test All Button
#
self.testallButton = qt.QPushButton("Test All")
self.testallButton.toolTip = "Run all the logic tests"
self.testallButton.name = "Reload & Test All"
reloadFormLayout.addWidget(self.testallButton)
self.testallButton.connect('clicked()', self.onTestAll)
#
# Settings Area
#
settingCollapsibleButton = ctk.ctkCollapsibleButton()
settingCollapsibleButton.text = "ADNI Demons Database Generation"
self.layout.addWidget(settingCollapsibleButton)
settingFormLayout = qt.QGridLayout(settingCollapsibleButton)
#
# DB Directory Selection Button
#
self.dbButton = qt.QPushButton("Set ADNI Database Directory")
self.dbButton.toolTip = "Set ANDI Database Directory"
self.dbButton.enabled = True
settingFormLayout.addWidget(self.dbButton, 0, 0)
self.dblabel = qt.QLabel(self.dbpath if self.dbpath != None else 'Empty')
settingFormLayout.addWidget(self.dblabel, 0, 1)
#
# DB csv file Selection Button
#
csvbtntxt = "Set *.csv File For DB Record"
self.dbcsvpath = '' if self.dbButton.text.find(':') == -1 else join(self.dbpath, 'db.csv')
self.csvButton = qt.QPushButton(csvbtntxt if len(self.dbcsvpath) == 0 else csvbtntxt + ' : ' + self.dbcsvpath)
self.csvButton.toolTip = "Set ANDI Database csv file path, which can be downloaded in the data collection"
self.csvButton.enabled = True
settingFormLayout.addWidget(self.csvButton, 1, 0)
self.csvlabel = qt.QLabel(self.dbcsvpath if self.dbcsvpath != None and self.dbpath != None else 'Empty')
settingFormLayout.addWidget(self.csvlabel, 1, 1)
#
# Flirt Template Selection Button
#
self.betflirt_templatebutton = qt.QPushButton("Select Flirt Template")
self.betflirt_templatebutton.toolTip = "Select Flirt Template"
self.betflirt_templatebutton.enabled = True
settingFormLayout.addWidget(self.betflirt_templatebutton, 2, 0)
self.flirtlabel = qt.QLabel(self.flirttemplate if self.flirttemplate != None else 'Empty')
settingFormLayout.addWidget(self.flirtlabel, 2, 1)
# They should be connected afterwards their initiation
self.dbButton.connect('clicked(bool)', lambda: self.onFileButton('db'))
self.csvButton.connect('clicked(bool)', lambda: self.onFileButton('csv'))
self.betflirt_templatebutton.connect('clicked(bool)', lambda: self.onFileButton('flirt'))
#
# Bet & Flirt Threshold
#
self.betflirtspin = qt.QDoubleSpinBox()
self.betflirtspin.setRange(0.0, 1.0)
self.betflirtspin.setSingleStep(0.05)
self.betflirtspin.setValue(0.2)
settingFormLayout.addWidget(qt.QLabel("Bet Threashold"), 3 ,0)
settingFormLayout.addWidget(self.betflirtspin, 3, 1)
#
# Checkbox for Bet & Flirt
#
self.betflirtcheck = qt.QCheckBox("Run Bet + Flirt")
self.betflirtcheck.setToolTip("Only the image IDs listed in the csv file will be processed. flirted images will be saved in path/to/db/flirted")
self.betflirtcheck.checked = 0
settingFormLayout.addWidget(self.betflirtcheck, 4, 0)
#
# Checkbox for Running Demons Registration
#
self.demonscheck = qt.QCheckBox("Run Demons")
self.demonscheck.setToolTip("Only the image IDs listed in the csv file will be processed. Image sources will only be retrieved from path/to/db/flirted")
self.demonscheck.checked = 0
self.demonscheck.enabled = True
settingFormLayout.addWidget(self.demonscheck, 4, 1)
#
# Interval Selection : 6m | 12m
#
self.intervalCombo = qt.QComboBox()
self.intervalCombo.addItem("6 Month")
self.intervalCombo.addItem("12 Month")
settingFormLayout.addWidget(qt.QLabel("Extract Interval"), 5 ,0)
settingFormLayout.addWidget(self.intervalCombo, 5, 1)
#
# Sequence Label Selection: All, Stable: NL, Stable: MCI, Stable: AD, NL2MCI, MCI2AD
#
self.seqCombo = qt.QComboBox()
self.seqCombo.enabled = False
self.seqCombo.addItems(["All", "Stable: NL", "Stable: MCI", "Stable: AD", "NL2MCI", "MCI2AD"])
settingFormLayout.addWidget(qt.QLabel("Sequence Type"), 6 ,0)
settingFormLayout.addWidget(self.seqCombo, 6, 1)
actionCollapsibleButton = ctk.ctkCollapsibleButton()
actionCollapsibleButton.text = "Database Generation Actions"
self.layout.addWidget(actionCollapsibleButton)
actionFormLayout = qt.QFormLayout(actionCollapsibleButton)
#
# Generate Database csv
#
self.dbgenButton = qt.QPushButton("Generate Database Sequence csv")
self.dbgenButton.toolTip = "Generate A csv with required fields by merging the image collection csv and the dxsum. To make this button functional, pls make sure R language is installed in your system and \'RScript\' is in the $PATH. \'dbgen.csv\' will be generated in the database directory"
self.dbgenButton.enabled = False
actionFormLayout.addRow(self.dbgenButton)
self.dbgenButton.connect('clicked(bool)', self.onDbgenButton)
#
# Validate Database see if all the images exist
#
self.validateDbButton = qt.QPushButton("Validate Database")
self.validateDbButton.toolTip = "Check if all the image ids in the dbgen.csv exist in the data folder"
self.validateDbButton.enabled = False
actionFormLayout.addRow(self.validateDbButton)
self.validateDbButton.connect('clicked(bool)', self.onValidateDbButton)
#
# Validate Bet and Flirt see if all the images were flirted and betted successfully
#
self.validateBetAndFlirtButton = qt.QPushButton("Validate Bet&Flirt")
self.validateBetAndFlirtButton.toolTip = "Check if all the image were successfully betted and flirted"
self.validateBetAndFlirtButton.enabled = True
actionFormLayout.addRow(self.validateBetAndFlirtButton)
self.validateBetAndFlirtButton.connect('clicked(bool)', self.onValidateBetAndFlirtButton)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
actionFormLayout.addRow(self.applyButton)
self.applyButton.connect('clicked(bool)', self.onApplyButton)
#
# Flirt Clear Button
#
self.clearFlirtButton = qt.QPushButton("Clear Flirt")
self.clearFlirtButton.toolTip = "Clear the files created by flirt."
self.clearFlirtButton.enabled = False
actionFormLayout.addRow(self.clearFlirtButton)
self.clearFlirtButton.connect('clicked(bool)', self.onFlirtClear)
#
# Evaluate DB Area
#
evaluateCollapsibleButton = ctk.ctkCollapsibleButton()
evaluateCollapsibleButton.text = "Evaluate DB"
self.layout.addWidget(evaluateCollapsibleButton)
evaluateFormLayout = qt.QGridLayout(evaluateCollapsibleButton)
#
# MAP setting
#
self.kmapspin = qt.QDoubleSpinBox()
self.kmapspin.setRange(0.0, 10.0)
self.kmapspin.setSingleStep(1.0)
self.kmapspin.setValue(5)
evaluateFormLayout.addWidget(qt.QLabel("K value for MAP"), 1 ,0)
evaluateFormLayout.addWidget(self.kmapspin, 1, 1)
#
# DB Evaluate Button
#
self.evaluateDbButton = qt.QPushButton('Evaluate DB')
self.evaluateDbButton.toolTip = "Set ANDI Database Directory. Assume in this folder, you have already generated a database with ADNI Demons DB Creator"
self.evaluateDbButton.enabled = True
evaluateFormLayout.addWidget(self.evaluateDbButton, 2, 0)
self.evaluateDbButton.connect('clicked(bool)', self.onEvaluateDbButton)
#
# Regenerate DB matrix check
#
self.regenMatCheck = qt.QCheckBox('Regenerate Dissimilarity Matrix')
self.regenMatCheck.checked = False
self.regenMatCheck.enabled = True
evaluateFormLayout.addWidget(self.regenMatCheck, 2, 1)
#
# Testing Ariea
#
statusCollapsibleButton = ctk.ctkCollapsibleButton()
statusCollapsibleButton.text = "Console"
self.layout.addWidget(statusCollapsibleButton)
self.statusLayout = qt.QFormLayout(statusCollapsibleButton)
#
# Show a Return Message
#
self.returnMsg = qt.QLabel("Ready")
self.statusLayout.addRow(self.returnMsg)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
w = qt.QWidget()
layout = qt.QGridLayout()
w.setLayout(layout)
self.layout.addWidget(w)
w.show()
self.layout = layout
####################IMPORTAR VOLUMEN 4D#################################################3
### Se crea la sección para cargar el volumen 4D en una pestaña desplegable
importDataCollapsibleButton = ctk.ctkCollapsibleButton()
importDataCollapsibleButton.text = "Import Data"
self.layout.addWidget(importDataCollapsibleButton)
importDataFormLayout = qt.QFormLayout(importDataCollapsibleButton)
#### Crear desplegable para seleccionar dirección del volumen
self.__fDialog = ctk.ctkDirectoryButton()
self.__fDialog.caption = 'Input directory'
importDataFormLayout.addRow('Input directory:', self.__fDialog)
###Selector de volumen donde se guardara el volumen de la direccion
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.outputSelector.addEnabled = True # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
self.outputSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
self.outputSelector.setMRMLScene(slicer.mrmlScene)
importDataFormLayout.addRow("Output node:", self.outputSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.outputSelector, 'setMRMLScene(vtkMRMLScene*)')
### Parametros avanzados
self.__dicomTag = qt.QLineEdit()
self.__dicomTag.text = 'NA'
importDataFormLayout.addRow('Frame identifying DICOM tag:',
self.__dicomTag)
self.__veLabel = qt.QLineEdit()
self.__veLabel.text = 'na'
importDataFormLayout.addRow('Frame identifying units:', self.__veLabel)
self.__veInitial = qt.QDoubleSpinBox()
self.__veInitial.value = 0
importDataFormLayout.addRow('Initial value:', self.__veInitial)
self.__veStep = qt.QDoubleSpinBox()
self.__veStep.value = 1
importDataFormLayout.addRow('Step:', self.__veStep)
self.__te = qt.QDoubleSpinBox()
self.__te.value = 1
importDataFormLayout.addRow('EchoTime:', self.__te)
self.__tr = qt.QDoubleSpinBox()
self.__tr.value = 1
importDataFormLayout.addRow('RepetitionTime:', self.__tr)
self.__fa = qt.QDoubleSpinBox()
self.__fa.value = 1
importDataFormLayout.addRow('FlipAngle:', self.__fa)
# Botón de importar
self.buttonImport = qt.QPushButton("Import")
self.buttonImport.toolTip = "Run the algorithm."
##self.buttonImport.enabled = True
importDataFormLayout.addRow(" ",
self.buttonImport)
self.buttonImport.connect('clicked(bool)', self.importFunction)
##self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
###########################REGISTRO##########################################
## # Se crea una sección de parámetros en una pestaña desplegable
registerCollapsibleButton = ctk.ctkCollapsibleButton()
registerCollapsibleButton.text = "Register"
self.layout.addWidget(registerCollapsibleButton)
registerFormLayout = qt.QFormLayout(registerCollapsibleButton)
#Se crea una ventana desplegable en la cual se ingresa el volumen 4D de
#entrada que se quiere registrar, este volumen debe ser de tipo
#"vtkMRMLMultiVolumeNode", además si se tienen varios multivolumenes cargados
#se puede elegir entre ellos el que se desea registrar
self.inputRegSelector = slicer.qMRMLNodeComboBox()
self.inputRegSelector.nodeTypes = ["vtkMRMLMultiVolumeNode"]
self.inputRegSelector.selectNodeUponCreation = True
self.inputRegSelector.addEnabled = True
self.inputRegSelector.removeEnabled = False
self.inputRegSelector.noneEnabled = True
self.inputRegSelector.showHidden = False
self.inputRegSelector.showChildNodeTypes = False
self.inputRegSelector.setMRMLScene(slicer.mrmlScene)
self.inputRegSelector.setToolTip("Pick the input to the algorithm.")
registerFormLayout.addRow("Volumen 4D: ", self.inputRegSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.inputRegSelector,
'setMRMLScene(vtkMRMLScene*)')
###Selector de volumen donde se guardara el volumen de la direccion
self.outputRegSelector = slicer.qMRMLNodeComboBox()
self.outputRegSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.outputRegSelector.addEnabled = True # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
self.outputRegSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
self.outputRegSelector.setMRMLScene(slicer.mrmlScene)
registerFormLayout.addRow("Output node:", self.outputRegSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.outputRegSelector,
'setMRMLScene(vtkMRMLScene*)')
# Botón de Registro
#Este botón solo se activa si el multivolumen ha sido seleccionado en la
#ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
#realiza el registro de los diferentes volumenes en el volumen 4D
self.applyButton = qt.QPushButton("Registrar")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
registerFormLayout.addRow(self.applyButton)
# Conexiones necesarias para el algoritmo
#entrega al algoritmo el volumen 4D de entrada y conecta la función del botón
#con la ejecución del registro
self.applyButton.connect('clicked(bool)', self.registrarButton)
def create(self):
super(GooCutOptions,self).create()
self.botButton = qt.QPushButton(self.frame)
self.botButton.text = "Start Bot"
self.frame.layout().addWidget(self.botButton)
self.toleranceFrame = qt.QFrame(self.frame)
self.toleranceFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.toleranceFrame)
self.widgets.append(self.toleranceFrame)
self.toleranceLabel = qt.QLabel("Tolerance:", self.toleranceFrame)
self.toleranceLabel.setToolTip("Set the tolerance of the wand in terms of background pixel values")
self.toleranceFrame.layout().addWidget(self.toleranceLabel)
self.widgets.append(self.toleranceLabel)
self.toleranceSpinBox = qt.QDoubleSpinBox(self.toleranceFrame)
self.toleranceSpinBox.setToolTip("Set the tolerance of the wand in terms of background pixel values")
self.toleranceSpinBox.minimum = 0
self.toleranceSpinBox.maximum = 1000
self.toleranceSpinBox.suffix = ""
self.toleranceFrame.layout().addWidget(self.toleranceSpinBox)
self.widgets.append(self.toleranceSpinBox)
self.maxPixelsFrame = qt.QFrame(self.frame)
self.maxPixelsFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.maxPixelsFrame)
self.widgets.append(self.maxPixelsFrame)
self.maxPixelsLabel = qt.QLabel("Max Pixels per click:", self.maxPixelsFrame)
self.maxPixelsLabel.setToolTip("Set the maxPixels for each click")
self.maxPixelsFrame.layout().addWidget(self.maxPixelsLabel)
self.widgets.append(self.maxPixelsLabel)
self.maxPixelsSpinBox = qt.QDoubleSpinBox(self.maxPixelsFrame)
self.maxPixelsSpinBox.setToolTip("Set the maxPixels for each click")
self.maxPixelsSpinBox.minimum = 1
self.maxPixelsSpinBox.maximum = 1000
self.maxPixelsSpinBox.suffix = ""
self.maxPixelsFrame.layout().addWidget(self.maxPixelsSpinBox)
self.widgets.append(self.maxPixelsSpinBox)
HelpButton(self.frame, "Use this tool to label all voxels that are within a tolerance of where you click")
self.botButton.connect('clicked()', self.onStartBot)
self.toleranceSpinBox.connect('valueChanged(double)', self.onToleranceSpinBoxChanged)
self.maxPixelsSpinBox.connect('valueChanged(double)', self.onMaxPixelsSpinBoxChanged)
# Add vertical spacer
self.frame.layout().addStretch(1)
# TODO: the functionality for the steered volume should migrate to
# the edit helper class when functionality is finalized.
backgroundVolume = self.editUtil.getBackgroundVolume()
labelVolume = self.editUtil.getLabelVolume()
steeredName = backgroundVolume.GetName() + '-steered'
steeredVolume = slicer.util.getNode(steeredName)
if not steeredVolume:
volumesLogic = slicer.modules.volumes.logic()
steeredVolume = volumesLogic.CloneVolume(
slicer.mrmlScene, labelVolume, steeredName)
compositeNodes = slicer.util.getNodes('vtkMRMLSliceCompositeNode*')
for compositeNode in compositeNodes.values():
compositeNode.SetForegroundVolumeID(steeredVolume.GetID())
compositeNode.SetForegroundOpacity(0.5)
def setup(self):
# Instantiate and connect widgets ...
# Reload button
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload this module."
self.reloadButton.name = "CMRToolkitRegistrationBRAINSFit Reload"
self.layout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
# Register Volume collapsible button
registerVol = ctk.ctkCollapsibleButton()
registerVol.text = "Register Volume"
self.layout.addWidget(registerVol)
# Layout within the Register Volume collapsible button
formLayout = qt.QFormLayout(registerVol)
# The image volume selectors
self.fixedFrame = qt.QFrame(registerVol)
self.fixedFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.fixedFrame)
self.fixedSelector = qt.QLabel("Image Volume One (Fixed): ",
self.fixedFrame)
self.fixedFrame.layout().addWidget(self.fixedSelector)
self.fixedSelector = slicer.qMRMLNodeComboBox(self.fixedFrame)
self.fixedSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.fixedSelector.addEnabled = False
self.fixedSelector.removeEnabled = False
self.fixedSelector.renameEnabled = True
self.fixedSelector.setMRMLScene(slicer.mrmlScene)
self.fixedFrame.layout().addWidget(self.fixedSelector)
self.movingFrame = qt.QFrame(registerVol)
self.movingFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.movingFrame)
self.movingSelector = qt.QLabel("Image Volume Two (Moving): ",
self.movingFrame)
self.movingFrame.layout().addWidget(self.movingSelector)
self.movingSelector = slicer.qMRMLNodeComboBox(self.movingFrame)
self.movingSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.movingSelector.addEnabled = False
self.movingSelector.removeEnabled = False
self.movingSelector.renameEnabled = True
self.movingSelector.setMRMLScene(slicer.mrmlScene)
self.movingFrame.layout().addWidget(self.movingSelector)
self.outputFrame = qt.QFrame(registerVol)
self.outputFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.outputFrame)
self.outputSelector = qt.QLabel("Output Image Volume: ",
self.outputFrame)
self.outputFrame.layout().addWidget(self.outputSelector)
self.outputSelector = slicer.qMRMLNodeComboBox(self.outputFrame)
self.outputSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.outputSelector.setMRMLScene(slicer.mrmlScene)
self.outputSelector.addEnabled = True
self.outputSelector.renameEnabled = True
self.outputSelector.baseName = "Registered Volume"
self.outputFrame.layout().addWidget(self.outputSelector)
# Imaging Modality selection
self.presetFrame = qt.QFrame(registerVol)
self.presetFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.presetFrame)
self.presetSelector = qt.QLabel("Imaging Modality: ", self.presetFrame)
self.presetFrame.layout().addWidget(self.presetSelector)
self.presetComboBox = qt.QComboBox()
self.presetComboBox.addItem("LGE-MRI to LGE-MRI")
self.presetComboBox.addItem("MRA to LGE-MRI")
self.presetComboBox.addItem("MRA to MRA")
self.presetComboBox.addItem("CT to LGE-MRI")
self.presetComboBox.addItem("Acute Scar to LGE-MRI")
self.presetComboBox.setCurrentIndex(-1)
self.presetFrame.layout().addWidget(self.presetComboBox)
# Connect Imaging Modality widget to parameters widgets
self.presetComboBox.connect('currentIndexChanged(QString)',
self.setParameters)
# Check box
self.cropCheckBox = qt.QCheckBox(
"Images are cropped to area around LA", registerVol)
self.cropCheckBox.toolTip = "For best registration, indicate whether the volumes have been cropped to the Left Atrium ROI"
formLayout.addWidget(self.cropCheckBox)
# Connect check box to registration parameters
self.cropCheckBox.connect('stateChanged(int)',
self.croppedImagesParameters)
# Register Volume button
registerButton = qt.QPushButton("Apply Registration (BRAINSFit)")
registerButton.toolTip = "Register Volume Two (Moving) onto Volume One (Fixed)."
formLayout.addWidget(registerButton)
registerButton.connect('clicked(bool)', self.onRegisterButtonClicked)
# Initialization of Registration collapsible button
#initOfRegn = ctk.ctkCollapsibleButton()
#initOfRegn.text = "Initialization of Registration"
#self.layout.addWidget(initOfRegn)
# Layout within the Initialization of Registration collapsible button
#formLayout2 = qt.QFormLayout(initOfRegn)
# Registration Parameters collapsible button
regnParameters = ctk.ctkCollapsibleButton()
regnParameters.text = "Registration Parameters"
regnParameters.collapsedHeight = 350
regnParameters.collapsed = True
self.layout.addWidget(regnParameters)
# Layout within the Registration Parameters collapsible button
formLayout3 = qt.QFormLayout(regnParameters)
self.initOfRegnFrame = qt.QFrame(regnParameters)
self.initOfRegnFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.initOfRegnFrame)
self.initOfRegnSelector = qt.QLabel(
"Select the Type of Initialization: ", self.initOfRegnFrame)
self.initOfRegnFrame.layout().addWidget(self.initOfRegnSelector)
self.initOfRegnComboBox = qt.QComboBox()
self.initOfRegnComboBox.addItem("useMomentsAlign")
self.initOfRegnComboBox.addItem("useGeometryAlign")
#self.initOfRegnComboBox.addItem("useCenterOfROIAlign")
self.initOfRegnComboBox.toolTip = "GeometryAlign assumes that the center of the voxel lattice of the images represent similar structures. MomentsAlign assumes that the center of mass of the images represent similar structures."
self.initOfRegnComboBox.setCurrentIndex(-1)
self.initOfRegnFrame.layout().addWidget(self.initOfRegnComboBox)
# Registration parameters
self.regnFrame = qt.QFrame(regnParameters)
self.regnFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.regnFrame)
self.regnSelector = qt.QLabel("Select the Type of Registration: ",
self.regnFrame)
self.regnFrame.layout().addWidget(self.regnSelector)
self.regnComboBox = qt.QComboBox()
self.regnComboBox.addItem("Rigid")
self.regnComboBox.addItem("Affine")
self.regnComboBox.addItem("BSpline")
self.regnComboBox.setCurrentIndex(-1)
self.regnFrame.layout().addWidget(self.regnComboBox)
# Maximum number of iterations
self.iterFrame = qt.QFrame(regnParameters)
self.iterFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.iterFrame)
self.iterEditSelector = qt.QLabel(
"Enter the Maximum Number of Iterations: ", self.iterFrame)
self.iterFrame.layout().addWidget(self.iterEditSelector)
self.iterSpinBox = qt.QSpinBox()
self.iterSpinBox.setLayout(qt.QHBoxLayout())
self.iterSpinBox.setMinimum(1)
self.iterSpinBox.setMaximum(2000)
self.iterSpinBox.setValue(0)
self.iterSpinBox.toolTip = "The maximum number of iterations to try before failing to converge."
self.iterFrame.layout().addWidget(self.iterSpinBox)
# Number of samples
self.sampFrame = qt.QFrame(regnParameters)
self.sampFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.sampFrame)
self.sampSelector = qt.QLabel("Enter the Number of Samples: ",
self.sampFrame)
self.sampFrame.layout().addWidget(self.sampSelector)
self.sampSpinBox = qt.QSpinBox()
self.sampSpinBox.setLayout(qt.QHBoxLayout())
self.sampSpinBox.setMinimum(0)
self.sampSpinBox.setMaximum(5000000)
self.sampSpinBox.setValue(0)
self.sampSpinBox.toolTip = "The number of voxels sampled for mutual information computation. Increase this for a slower, more careful fit."
self.sampFrame.layout().addWidget(self.sampSpinBox)
# Minimum Step Length
self.stepFrame = qt.QFrame(regnParameters)
self.stepFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.stepFrame)
self.stepSelector = qt.QLabel("Enter the Minimum Step Length: ",
self.stepFrame)
self.stepFrame.layout().addWidget(self.stepSelector)
self.stepSpinBox = qt.QDoubleSpinBox()
self.stepSpinBox.setLayout(qt.QHBoxLayout())
self.stepSpinBox.setMinimum(0)
self.stepSpinBox.setMaximum(10)
self.stepSpinBox.setDecimals(3)
self.stepSpinBox.setValue(0.005)
self.stepSpinBox.toolTip = "Each step in the optimization takes steps at least this big. When none are possible, registration is complete."
self.stepFrame.layout().addWidget(self.stepSpinBox)
# Transform Scale
self.transFrame = qt.QFrame(regnParameters)
self.transFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.transFrame)
self.transSelector = qt.QLabel("Enter the Transform Scale: ",
self.transFrame)
self.transFrame.layout().addWidget(self.transSelector)
self.transSpinBox = qt.QDoubleSpinBox()
self.transSpinBox.setLayout(qt.QHBoxLayout())
self.transSpinBox.setMinimum(0)
self.transSpinBox.setMaximum(5000)
self.transSpinBox.setValue(1000)
self.transSpinBox.toolTip = "How much to scale up changes in position compared to unit rotational changes in radians. Decrease this to put more rotation in the search pattern."
self.transFrame.layout().addWidget(self.transSpinBox)
# Reproportion Scale
self.repropFrame = qt.QFrame(regnParameters)
self.repropFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.repropFrame)
self.repropSelector = qt.QLabel("Enter the Reproportion Scale: ",
self.repropFrame)
self.repropFrame.layout().addWidget(self.repropSelector)
self.repropSpinBox = qt.QDoubleSpinBox()
self.repropSpinBox.setLayout(qt.QHBoxLayout())
self.repropSpinBox.setMinimum(0)
self.repropSpinBox.setMaximum(100)
self.repropSpinBox.setValue(1.0)
self.repropSpinBox.toolTip = "ScaleVersor3D 'Scale' compensation factor. Increase this to put more rescaling in a ScaleVersor3D or ScaleSkewVersor3D search pattern. 1.0 works well with a Translation Scale of 1000.0"
self.repropFrame.layout().addWidget(self.repropSpinBox)
# Skew Scale
self.skewFrame = qt.QFrame(regnParameters)
self.skewFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.skewFrame)
self.skewSelector = qt.QLabel("Enter the Skew Scale: ",
self.repropFrame)
self.skewFrame.layout().addWidget(self.skewSelector)
self.skewSpinBox = qt.QDoubleSpinBox()
self.skewSpinBox.setLayout(qt.QHBoxLayout())
self.skewSpinBox.setMinimum(0)
self.skewSpinBox.setMaximum(100)
self.skewSpinBox.setValue(1.0)
self.skewSpinBox.toolTip = "ScaleSkewVersor3D Skew compensation factor. Increase this to put more skew in a ScaleSkewVersor3D search pattern. 1.0 works well with a translationScale of 1000.0"
self.skewFrame.layout().addWidget(self.skewSpinBox)
# Interpolation options
self.interpFrame = qt.QFrame(regnParameters)
self.interpFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.interpFrame)
self.interpSelector = qt.QLabel("Select the Type of Interpolation: ",
self.interpFrame)
self.interpFrame.layout().addWidget(self.interpSelector)
self.interpComboBox = qt.QComboBox()
self.interpComboBox.setLayout(qt.QHBoxLayout())
self.interpComboBox.addItem("NearestNeighbor")
self.interpComboBox.addItem("Linear")
self.interpComboBox.addItem("BSpline")
self.interpComboBox.addItem("WindowedSinc")
self.interpComboBox.addItem("RigidInPlace")
self.interpComboBox.setCurrentIndex(-1)
self.interpComboBox.toolTip = "Type of interpolation to be used when applying transform to moving volume."
self.interpFrame.layout().addWidget(self.interpComboBox)
# Metric Options
self.metFrame = qt.QFrame(regnParameters)
self.metFrame.setLayout(qt.QHBoxLayout())
formLayout3.addWidget(self.metFrame)
self.metSelector = qt.QLabel("Select the Type of Metric: ",
self.metFrame)
self.metFrame.layout().addWidget(self.metSelector)
self.metComboBox = qt.QComboBox()
self.metComboBox.setLayout(qt.QHBoxLayout())
self.metComboBox.addItem("MMI")
self.metComboBox.addItem("NC")
self.metComboBox.addItem("MSE")
self.metComboBox.addItem("MC")
self.metComboBox.setCurrentIndex(-1)
self.metComboBox.toolTip = "The cost metric to be used during fitting: MMI (Mattes Mutual Information), MSE (Mean Square Error), NC (Normalized Correlation) or MC (Match Cardinality for binary images)"
self.metFrame.layout().addWidget(self.metComboBox)
def createUserInterface( self ):
'''
'''
self.__layout = self.__parent.createUserInterface()
self.__top = qt.QWidget()
self.__topLayout = qt.QHBoxLayout( self.__top )
# the anatomical tree
self.__anatomicalTreeGroupBox = qt.QGroupBox()
self.__anatomicalTreeGroupBox.setTitle( 'Anatomical Tree' )
self.__topLayout.addWidget( self.__anatomicalTreeGroupBox )
self.__anatomicalTreeGroupBoxLayout = qt.QFormLayout( self.__anatomicalTreeGroupBox )
self.__anatomicalTree = PythonQt.qSlicerEMSegmentModuleWidgets.qSlicerEMSegmentAnatomicalTreeWidget()
self.__anatomicalTree.structureNameEditable = False
self.__anatomicalTree.labelColumnVisible = False
self.__anatomicalTree.probabilityMapColumnVisible = False
self.__anatomicalTree.classWeightColumnVisible = False
self.__anatomicalTree.updateClassWeightColumnVisible = False
self.__anatomicalTree.atlasWeightColumnVisible = False
self.__anatomicalTree.alphaColumnVisible = False
self.__anatomicalTree.displayAlphaCheckBoxVisible = False
self.__anatomicalTree.connect( 'currentTreeNodeChanged(vtkMRMLNode*)', self.onTreeSelectionChanged )
self.__anatomicalTree.setSizePolicy( qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding )
self.__anatomicalTreeGroupBoxLayout.addWidget( self.__anatomicalTree )
#
# overview of class weights panel
#
self.__overviewBox = qt.QGroupBox()
self.__overviewBox.title = 'Overview of Class Weights'
self.__overviewBoxLayout = qt.QVBoxLayout( self.__overviewBox )
self.__topLayout.addWidget( self.__overviewBox )
self.__layout.addWidget( self.__top )
self.__tabWidget = qt.QTabWidget()
self.__layout.addWidget( self.__tabWidget )
#
# basicPage
#
self.__basicPage = qt.QWidget()
self.__basicPageLayout = qt.QHBoxLayout( self.__basicPage )
self.__basicPageLeft = qt.QWidget()
self.__basicPageRight = qt.QWidget()
self.__basicPageLayoutLeft = qt.QFormLayout( self.__basicPageLeft )
self.__basicPageLayoutRight = qt.QFormLayout( self.__basicPageRight )
self.__basicPageLayout.addWidget( self.__basicPageLeft )
self.__basicPageLayout.addWidget( self.__basicPageRight )
self.__classLabel = qt.QLabel( "XX" )
self.__basicPageLayoutLeft.addRow( "Class:", self.__classLabel )
self.__classWeightSpinBox = qt.QDoubleSpinBox()
self.__classWeightSpinBox.minimum = 0
self.__classWeightSpinBox.maximum = 1
self.__classWeightSpinBox.singleStep = 0.01
self.__basicPageLayoutLeft.addRow( "Class Weight:", self.__classWeightSpinBox )
self.__classWeightSpinBox.connect( 'valueChanged(double)', self.propagateToMRML )
self.__atlasWeightSpinBox = qt.QDoubleSpinBox()
self.__atlasWeightSpinBox.minimum = 0
self.__atlasWeightSpinBox.maximum = 1
self.__atlasWeightSpinBox.singleStep = 0.01
self.__basicPageLayoutLeft.addRow( "Atlas Weight:", self.__atlasWeightSpinBox )
self.__atlasWeightSpinBox.connect( 'valueChanged(double)', self.propagateToMRML )
self.__mfaWeightSpinBox = qt.QDoubleSpinBox()
self.__mfaWeightSpinBox.minimum = 0
self.__mfaWeightSpinBox.maximum = 1
self.__mfaWeightSpinBox.singleStep = 0.01
self.__basicPageLayoutLeft.addRow( "MFA Weight:", self.__mfaWeightSpinBox )
self.__mfaWeightSpinBox.connect( 'valueChanged(double)', self.propagateToMRML )
self.__dummyLabel6 = qt.QLabel( " " )
self.__basicPageLayoutRight.addRow( " ", self.__dummyLabel6 )
self.__dummyLabel9 = qt.QLabel( " " )
self.__basicPageLayoutRight.addRow( " ", self.__dummyLabel9 )
self.__inputChannelWeightsBox = qt.QGroupBox()
self.__inputChannelWeightsBox.title = 'Input Channel Weights'
self.__inputChannelWeightsBoxLayout = qt.QFormLayout( self.__inputChannelWeightsBox )
self.__basicPageLayoutRight.addWidget( self.__inputChannelWeightsBox )
#
# stoppingConditionsPage
#
self.__stoppingConditionsPage = qt.QWidget()
self.__stoppingConditionsPageLayout = qt.QHBoxLayout( self.__stoppingConditionsPage )
self.__stoppingConditionsPageLeft = qt.QWidget()
self.__stoppingConditionsPageRight = qt.QWidget()
self.__stoppingConditionsPageLayoutLeft = qt.QFormLayout( self.__stoppingConditionsPageLeft )
self.__stoppingConditionsPageLayoutRight = qt.QFormLayout( self.__stoppingConditionsPageRight )
self.__stoppingConditionsPageLayout.addWidget( self.__stoppingConditionsPageLeft )
self.__stoppingConditionsPageLayout.addWidget( self.__stoppingConditionsPageRight )
self.__classLabel2 = qt.QLabel( "XX" )
self.__stoppingConditionsPageLayoutLeft.addRow( "Class:", self.__classLabel2 )
self.__emComboBox = qt.QComboBox()
self.__emComboBox.addItems( Helper.GetStoppingConditionTypes() )
self.__stoppingConditionsPageLayoutLeft.addRow( 'EM:', self.__emComboBox )
self.__emComboBox.connect( 'currentIndexChanged(int)', self.propagateToMRML )
self.__mfaComboBox = qt.QComboBox()
self.__mfaComboBox.addItems( Helper.GetStoppingConditionTypes() )
self.__stoppingConditionsPageLayoutLeft.addRow( 'MFA:', self.__mfaComboBox )
self.__mfaComboBox.connect( 'currentIndexChanged(int)', self.propagateToMRML )
self.__dummyLabel = qt.QLabel( " " )
self.__stoppingConditionsPageLayoutRight.addRow( " ", self.__dummyLabel )
self.__dummyLabel8 = qt.QLabel( " " )
self.__stoppingConditionsPageLayoutRight.addRow( " ", self.__dummyLabel8 )
self.__emValueSpinBox = qt.QSpinBox()
self.__emValueSpinBox.minimum = 0
self.__emValueSpinBox.singleStep = 1
self.__stoppingConditionsPageLayoutRight.addRow( 'Iterations:', self.__emValueSpinBox )
self.__emValueSpinBox.connect( 'valueChanged(int)', self.propagateToMRML )
self.__mfaValueSpinBox = qt.QSpinBox()
self.__mfaValueSpinBox.minimum = 0
self.__mfaValueSpinBox.singleStep = 1
self.__stoppingConditionsPageLayoutRight.addRow( 'Iterations:', self.__mfaValueSpinBox )
self.__mfaValueSpinBox.connect( 'valueChanged(int)', self.propagateToMRML )
self.__biasSpinBox = qt.QSpinBox()
self.__biasSpinBox.minimum = -1
self.__biasSpinBox.singleStep = 1
self.__stoppingConditionsPageLayoutRight.addRow( 'Bias Iterations:', self.__biasSpinBox )
self.__biasSpinBox.connect( 'valueChanged(int)', self.propagateToMRML )
#
# printPage
#
self.__printPage = qt.QWidget()
self.__printPageLayout = qt.QHBoxLayout( self.__printPage )
self.__printPageLeft = qt.QWidget()
self.__printPageRight = qt.QWidget()
self.__printPageLayoutLeft = qt.QFormLayout( self.__printPageLeft )
self.__printPageLayoutRight = qt.QFormLayout( self.__printPageRight )
self.__printPageLayout.addWidget( self.__printPageLeft )
self.__printPageLayout.addWidget( self.__printPageRight )
self.__classLabel3 = qt.QLabel( "XX" )
self.__printPageLayoutLeft.addRow( "Class:", self.__classLabel3 )
self.__weightCheckBox = qt.QCheckBox()
self.__printPageLayoutLeft.addRow( "Weight:", self.__weightCheckBox )
self.__weightCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__qualityCheckBox = qt.QCheckBox()
self.__printPageLayoutLeft.addRow( "Quality:", self.__qualityCheckBox )
self.__qualityCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__frequencySpinBox = qt.QSpinBox()
self.__frequencySpinBox.minimum = 0
self.__frequencySpinBox.maximum = 20
self.__printPageLayoutLeft.addRow( "Frequency:", self.__frequencySpinBox )
self.__frequencySpinBox.connect( 'valueChanged(int)', self.propagateToMRML )
self.__biasCheckBox = qt.QCheckBox()
self.__printPageLayoutLeft.addRow( "Bias:", self.__biasCheckBox )
self.__biasCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__labelMapCheckBox = qt.QCheckBox()
self.__printPageLayoutLeft.addRow( "Label Map:", self.__labelMapCheckBox )
self.__labelMapCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__dummyLabel2 = qt.QLabel( " " )
self.__printPageLayoutRight.addRow( " ", self.__dummyLabel2 )
self.__dummyLabel3 = qt.QLabel( " " )
self.__printPageLayoutRight.addRow( " ", self.__dummyLabel3 )
self.__convergenceBox = qt.QGroupBox()
self.__convergenceBox.title = 'Convergence'
self.__convergenceBoxLayout = qt.QFormLayout( self.__convergenceBox )
self.__printPageLayoutRight.addWidget( self.__convergenceBox )
self.__convEMLabelMapCheckBox = qt.QCheckBox()
self.__convergenceBoxLayout.addRow( "EM Label Map:", self.__convEMLabelMapCheckBox )
self.__convEMLabelMapCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__convEMWeightsCheckBox = qt.QCheckBox()
self.__convergenceBoxLayout.addRow( "EM Weights:", self.__convEMWeightsCheckBox )
self.__convEMWeightsCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__convMFALabelMapCheckBox = qt.QCheckBox()
self.__convergenceBoxLayout.addRow( "MFA Label Map:", self.__convMFALabelMapCheckBox )
self.__convMFALabelMapCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__convMFAWeightsCheckBox = qt.QCheckBox()
self.__convergenceBoxLayout.addRow( "MFA Weights:", self.__convMFAWeightsCheckBox )
self.__convMFAWeightsCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
#
# advancedPage
#
self.__advancedPage = qt.QWidget()
self.__advancedPageLayout = qt.QFormLayout( self.__advancedPage )
self.__dummyLabel14 = qt.QLabel( " " )
self.__advancedPageLayout.addWidget( self.__dummyLabel14 )
self.__classLabel4 = qt.QLabel( "Class: XX" )
self.__advancedPageLayout.addWidget( self.__classLabel4 )
# self.__pcaParametersBox = qt.QGroupBox()
# self.__pcaParametersBox.title = 'PCA Parameters'
# self.__pcaParametersBoxLayout = qt.QFormLayout( self.__pcaParametersBox )
# self.__advancedPageLayout.addWidget( self.__pcaParametersBox )
#
# self.__registrationParametersBox = qt.QGroupBox()
# self.__registrationParametersBox.title = 'Registration Parameters'
# self.__registrationParametersBoxLayout = qt.QFormLayout( self.__registrationParametersBox )
# self.__advancedPageLayout.addWidget( self.__registrationParametersBox )
self.__miscParametersBox = qt.QGroupBox()
self.__miscParametersBox.title = 'Miscellaneous Parameters'
self.__miscParametersBoxLayout = qt.QFormLayout( self.__miscParametersBox )
self.__advancedPageLayout.addWidget( self.__miscParametersBox )
self.__excludeFromEStepCheckBox = qt.QCheckBox()
self.__miscParametersBoxLayout.addRow( "Exclude From Incomplete EStep:", self.__excludeFromEStepCheckBox )
self.__excludeFromEStepCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__genBackgroundProbCheckBox = qt.QCheckBox()
self.__miscParametersBoxLayout.addRow( "Generate Background Probability:", self.__genBackgroundProbCheckBox )
self.__genBackgroundProbCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
self.__meanFieldParametersBox = qt.QGroupBox()
self.__meanFieldParametersBox.title = 'Mean Field Parameters'
self.__meanFieldParametersBoxLayout = qt.QFormLayout( self.__meanFieldParametersBox )
self.__advancedPageLayout.addWidget( self.__meanFieldParametersBox )
self.__twoDNeighborhoodCheckBox = qt.QCheckBox()
self.__meanFieldParametersBoxLayout.addRow( "2D Neighborhood:", self.__twoDNeighborhoodCheckBox )
self.__twoDNeighborhoodCheckBox.connect( 'stateChanged(int)', self.propagateToMRML )
# self.__inhomogeneityParametersBox = qt.QGroupBox()
# self.__inhomogeneityParametersBox.title = 'Inhomogeneity Parameters'
# self.__inhomogeneityParametersBoxLayout = qt.QFormLayout( self.__inhomogeneityParametersBox )
# self.__advancedPageLayout.addWidget( self.__inhomogeneityParametersBox )
#
### add all tabs to the tabWidget
#
self.__tabWidget.addTab( self.__basicPage, "Basic" )
self.__tabWidget.addTab( self.__stoppingConditionsPage, "Stopping Conditions" )
self.__tabWidget.addTab( self.__printPage, "Print" )
self.__tabWidget.addTab( self.__advancedPage, "Advanced" )
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
self.markupsNodeObservations = []
# Instantiate and connect widgets ...
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# slice role selector
#
self.axialSliceSelector = slicer.qMRMLNodeComboBox()
self.axialSliceSelector.nodeTypes = (("vtkMRMLSliceNode"), "")
self.axialSliceSelector.selectNodeUponCreation = False
self.axialSliceSelector.addEnabled = False
self.axialSliceSelector.removeEnabled = False
self.axialSliceSelector.noneEnabled = True
self.axialSliceSelector.showHidden = False
self.axialSliceSelector.showChildNodeTypes = False
self.axialSliceSelector.setMRMLScene(slicer.mrmlScene)
self.axialSliceSelector.setToolTip(
"Pick the slice that will show the transverse view.")
parametersFormLayout.addRow("Axial view: ", self.axialSliceSelector)
self.axialSliceSelector.setCurrentNode(
slicer.mrmlScene.GetNodeByID('vtkMRMLSliceNodeRed'))
self.orthogonalSlice1Selector = slicer.qMRMLNodeComboBox()
self.orthogonalSlice1Selector.nodeTypes = (("vtkMRMLSliceNode"), "")
self.orthogonalSlice1Selector.selectNodeUponCreation = False
self.orthogonalSlice1Selector.addEnabled = False
self.orthogonalSlice1Selector.removeEnabled = False
self.orthogonalSlice1Selector.noneEnabled = True
self.orthogonalSlice1Selector.showHidden = False
self.orthogonalSlice1Selector.showChildNodeTypes = False
self.orthogonalSlice1Selector.setMRMLScene(slicer.mrmlScene)
self.orthogonalSlice1Selector.setToolTip(
"Pick the slice that will show a plane orthogonal to the axial slice."
)
parametersFormLayout.addRow("Orthogonal view 1: ",
self.orthogonalSlice1Selector)
self.orthogonalSlice1Selector.setCurrentNode(
slicer.mrmlScene.GetNodeByID('vtkMRMLSliceNodeYellow'))
self.orthogonalSlice2Selector = slicer.qMRMLNodeComboBox()
self.orthogonalSlice2Selector.nodeTypes = (("vtkMRMLSliceNode"), "")
self.orthogonalSlice2Selector.selectNodeUponCreation = False
self.orthogonalSlice2Selector.addEnabled = False
self.orthogonalSlice2Selector.removeEnabled = False
self.orthogonalSlice2Selector.noneEnabled = True
self.orthogonalSlice1Selector.showHidden = False
self.orthogonalSlice2Selector.showChildNodeTypes = False
self.orthogonalSlice2Selector.setMRMLScene(slicer.mrmlScene)
self.orthogonalSlice2Selector.setToolTip(
"Pick the slice that will show a plane orthogonal to the two other slices."
)
parametersFormLayout.addRow("Orthogonal view 2: ",
self.orthogonalSlice2Selector)
self.orthogonalSlice2Selector.setCurrentNode(
slicer.mrmlScene.GetNodeByID('vtkMRMLSliceNodeGreen'))
#
# Orthogonal slice rotation
#
self.lastOrthogonalSlicerRotationVale = 0
self.orthogonalSlicerRotationSliderWidget = ctk.ctkSliderWidget()
self.orthogonalSlicerRotationSliderWidget.singleStep = 1
self.orthogonalSlicerRotationSliderWidget.minimum = -360
self.orthogonalSlicerRotationSliderWidget.maximum = 360
self.orthogonalSlicerRotationSliderWidget.value = self.lastOrthogonalSlicerRotationVale
self.orthogonalSlicerRotationSliderWidget.setToolTip(
"Rotation angle of the orthogonal views")
parametersFormLayout.addRow("Rotation angle",
self.orthogonalSlicerRotationSliderWidget)
orthogonalSlicerRotationBox = qt.QHBoxLayout()
self.orthogonalSlicerRotationStepSizeSpinBox = qt.QDoubleSpinBox()
self.orthogonalSlicerRotationStepSizeSpinBox.setToolTip(
"Increment value by that a single button press changes the orthogonal view angle"
)
self.orthogonalSlicerRotationStepSizeSpinBox.value = 20
self.orthogonalSlicerRotationStepSizeSpinBox.minimum = 0.1
self.orthogonalSlicerRotationStepSizeSpinBox.maximum = 90
self.orthogonalSlicerRotationStepSizeSpinBox.singleStep = 5
self.orthogonalSlicerRotationStepSizeSpinBox.decimals = 1
orthogonalSlicerRotationBox.addWidget(
self.orthogonalSlicerRotationStepSizeSpinBox)
self.orthogonalSliceRotationAngleDecButton = qt.QPushButton()
self.orthogonalSliceRotationAngleDecButton.text = "<"
orthogonalSlicerRotationBox.addWidget(
self.orthogonalSliceRotationAngleDecButton)
self.orthogonalSliceRotationAngleIncButton = qt.QPushButton()
self.orthogonalSliceRotationAngleIncButton.text = ">"
orthogonalSlicerRotationBox.addWidget(
self.orthogonalSliceRotationAngleIncButton)
parametersFormLayout.addRow("", orthogonalSlicerRotationBox)
#
# Parameters Area
#
autoRotateCollapsibleButton = ctk.ctkCollapsibleButton()
autoRotateCollapsibleButton.text = "Auto-rotate"
autoRotateFormLayout = qt.QFormLayout(autoRotateCollapsibleButton)
self.layout.addWidget(autoRotateCollapsibleButton)
self.markupsNodeSelector = slicer.qMRMLNodeComboBox()
self.markupsNodeSelector.nodeTypes = ["vtkMRMLMarkupsClosedCurveNode"]
self.markupsNodeSelector.addEnabled = False
self.markupsNodeSelector.removeEnabled = True
self.markupsNodeSelector.noneEnabled = True
self.markupsNodeSelector.setMRMLScene(slicer.mrmlScene)
self.markupsNodeSelector.setToolTip(
"Pick a closed curve node that should make the rotation advance automatically upon point placement."
)
autoRotateFormLayout.addRow("Closed curve node: ",
self.markupsNodeSelector)
# connections
self.orthogonalSliceRotationAngleDecButton.connect(
'clicked(bool)', self.onOrthogonalSlicerRotationAngleDec)
self.orthogonalSliceRotationAngleIncButton.connect(
'clicked(bool)', self.onOrthogonalSlicerRotationAngleInc)
self.orthogonalSlicerRotationSliderWidget.connect(
'valueChanged(double)',
self.onOrthogonalSlicerRotationAngleChanged)
self.markupsNodeSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onMarkupsNodeSelectionChanged)
# Add vertical spacer
self.layout.addStretch(1)
# Refresh Apply button state
self.onSelect()
def create(self):
super(PaintEffectOptions, self).create()
labelVolume = self.editUtil.getLabelVolume()
if labelVolume and labelVolume.GetImageData():
spacing = labelVolume.GetSpacing()
dimensions = labelVolume.GetImageData().GetDimensions()
self.minimumRadius = 0.5 * min(spacing)
bounds = [a * b for a, b in zip(spacing, dimensions)]
self.maximumRadius = 0.5 * max(bounds)
else:
self.minimumRadius = 0.01
self.maximumRadius = 100
self.radiusFrame = qt.QFrame(self.frame)
self.radiusFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.radiusFrame)
self.widgets.append(self.radiusFrame)
self.radiusLabel = qt.QLabel("Radius:", self.radiusFrame)
self.radiusLabel.setToolTip(
"Set the radius of the paint brush in millimeters")
self.radiusFrame.layout().addWidget(self.radiusLabel)
self.widgets.append(self.radiusLabel)
self.radiusSpinBox = qt.QDoubleSpinBox(self.radiusFrame)
self.radiusSpinBox.setToolTip(
"Set the radius of the paint brush in millimeters")
self.radiusSpinBox.minimum = self.minimumRadius
self.radiusSpinBox.maximum = self.maximumRadius
self.radiusSpinBox.suffix = "mm"
from math import log, floor
decimals = floor(log(self.minimumRadius, 10))
if decimals < 0:
self.radiusSpinBox.decimals = -decimals + 2
self.radiusFrame.layout().addWidget(self.radiusSpinBox)
self.widgets.append(self.radiusSpinBox)
self.radiusUnitsToggle = qt.QPushButton("px:")
self.radiusUnitsToggle.setToolTip(
"Toggle radius quick set buttons between mm and label volume pixel size units"
)
self.radiusUnitsToggle.setFixedWidth(35)
self.radiusFrame.layout().addWidget(self.radiusUnitsToggle)
self.radiusUnitsToggle.connect('clicked()', self.onRadiusUnitsToggle)
self.radiusQuickies = {}
quickies = ((2, self.onQuickie2Clicked), (3, self.onQuickie3Clicked),
(4, self.onQuickie4Clicked), (5, self.onQuickie5Clicked),
(10, self.onQuickie10Clicked), (20,
self.onQuickie20Clicked))
for rad, callback in quickies:
self.radiusQuickies[rad] = qt.QPushButton(str(rad))
self.radiusFrame.layout().addWidget(self.radiusQuickies[rad])
self.radiusQuickies[rad].setFixedWidth(25)
self.radiusQuickies[rad].connect('clicked()', callback)
self.radiusQuickies[rad].setToolTip(
"Set radius based on mm or label voxel size units depending on toggle value"
)
self.radius = ctk.ctkDoubleSlider(self.frame)
self.radius.minimum = self.minimumRadius
self.radius.maximum = self.maximumRadius
self.radius.orientation = 1
self.radius.singleStep = self.minimumRadius
self.frame.layout().addWidget(self.radius)
self.widgets.append(self.radius)
self.smudge = qt.QCheckBox("Smudge", self.frame)
self.smudge.setToolTip(
"Set the label number automatically by sampling the pixel location where the brush stroke starts."
)
self.frame.layout().addWidget(self.smudge)
self.widgets.append(self.smudge)
EditorLib.HelpButton(
self.frame,
"Use this tool to paint with a round brush of the selected radius")
self.connections.append(
(self.smudge, 'clicked()', self.updateMRMLFromGUI))
self.connections.append(
(self.radius, 'valueChanged(double)', self.onRadiusValueChanged))
self.connections.append((self.radiusSpinBox, 'valueChanged(double)',
self.onRadiusSpinBoxChanged))
# Add vertical spacer
self.frame.layout().addStretch(1)
# set the node parameters that are dependent on the input data
self.parameterNode.SetParameter("PaintEffect,radius",
str(self.minimumRadius * 10))
def create(self):
super(WatershedFromMarkerEffectOptions,self).create()
if not HAVE_SIMPLEITK:
self.warningLabel = qt.QLabel()
self.warningLabel.text = "WatershedFromMarker is not available because\nSimpleITK is not available in this build"
self.widgets.append(self.warningLabel)
self.frame.layout().addWidget(self.warningLabel)
return
labelVolume = self.editUtil.getLabelVolume()
if labelVolume and labelVolume.GetImageData():
spacing = labelVolume.GetSpacing()
self.minimumSigma = 0.1 * min(spacing)
self.maximumSigma = 100 * self.minimumSigma
else:
self.minimumSigma = 0.1
self.maximumSigma = 10
self.sigmaFrame = qt.QFrame(self.frame)
self.sigmaFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.sigmaFrame)
self.widgets.append(self.sigmaFrame)
tip = "Increasing this value smooths the segmentation and reduces leaks. This is the sigma used for edge detection."
self.sigmaLabel = qt.QLabel("Object Scale: ", self.frame)
self.sigmaLabel.setToolTip(tip)
self.sigmaFrame.layout().addWidget(self.sigmaLabel)
self.widgets.append(self.sigmaLabel)
self.sigmaSlider = qt.QSlider( qt.Qt.Horizontal, self.frame )
self.sigmaFrame.layout().addWidget(self.sigmaSlider)
self.sigmaFrame.setToolTip(tip)
self.widgets.append(self.sigmaSlider)
self.sigmaSpinBox = qt.QDoubleSpinBox(self.frame)
self.sigmaSpinBox.setToolTip(tip)
self.sigmaSpinBox.suffix = "mm"
self.sigmaFrame.layout().addWidget(self.sigmaSpinBox)
self.widgets.append(self.sigmaSpinBox)
self.sigmaSpinBox.minimum = self.minimumSigma
self.sigmaSlider.minimum = self.minimumSigma
self.sigmaSpinBox.maximum = self.maximumSigma
self.sigmaSlider.maximum = self.maximumSigma
decimals = math.floor(math.log(self.minimumSigma,10))
if decimals < 0:
self.sigmaSpinBox.decimals = -decimals + 2
self.apply = qt.QPushButton("Apply", self.frame)
self.apply.setToolTip("Apply the extension operation")
self.frame.layout().addWidget(self.apply)
self.widgets.append(self.apply)
helpDoc = \
"""Use this effect to apply the watershed from markers segmentation from multiple initial labels.
The input to this filter is current labelmap image which is expected to contain multiple labels as initial markss. The marks or labels are grown to fill the image and with edges defining the bondaries between. To segment a single object, mark the object, and then it is suggested to surround the object with a negative label on each axis.
The "Object Scale" parameter is use to adjust the smoothness of the output image and prevent leakage. It is used internally for the sigma of the gradient magnitude.
"""
HelpButton(self.frame, helpDoc)
self.sigmaSlider.connect( 'valueChanged(int)', self.sigmaSpinBox.setValue )
self.sigmaSpinBox.connect( 'valueChanged(double)', self.sigmaSlider.setValue )
# if either widget is changed both should change and this should be triggered
self.connections.append( ( self.sigmaSpinBox, 'valueChanged(double)', self.onSigmaValueChanged ) )
self.connections.append( (self.apply, 'clicked()', self.onApply) )
# Add vertical spacer
self.frame.layout().addStretch(1)
def setup(self):
w = qt.QWidget()
layout = qt.QGridLayout()
w.setLayout(layout)
self.layout.addWidget(w)
w.show()
self.layout = layout
####################IMPORTAR VOLUMEN 4D#################################################3
### Se crea la sección para cargar el volumen 4D en una pestaña desplegable
importDataCollapsibleButton = ctk.ctkCollapsibleButton()
importDataCollapsibleButton.text = "Import Data"
self.layout.addWidget(importDataCollapsibleButton)
importDataFormLayout = qt.QFormLayout(importDataCollapsibleButton)
#### Crear desplegable para seleccionar dirección del volumen
self.__fDialog = ctk.ctkDirectoryButton()
self.__fDialog.caption = 'Input directory'
importDataFormLayout.addRow('Input directory:', self.__fDialog)
###Selector de volumen donde se guardara el volumen de la direccion
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.outputSelector.addEnabled = True # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
self.outputSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
self.outputSelector.setMRMLScene(slicer.mrmlScene)
importDataFormLayout.addRow("Output node:", self.outputSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.outputSelector, 'setMRMLScene(vtkMRMLScene*)')
### Parametros avanzados
self.__dicomTag = qt.QLineEdit()
self.__dicomTag.text = 'NA'
importDataFormLayout.addRow('Frame identifying DICOM tag:',
self.__dicomTag)
self.__veLabel = qt.QLineEdit()
self.__veLabel.text = 'na'
importDataFormLayout.addRow('Frame identifying units:', self.__veLabel)
self.__veInitial = qt.QDoubleSpinBox()
self.__veInitial.value = 0
importDataFormLayout.addRow('Initial value:', self.__veInitial)
self.__veStep = qt.QDoubleSpinBox()
self.__veStep.value = 1
importDataFormLayout.addRow('Step:', self.__veStep)
self.__te = qt.QDoubleSpinBox()
self.__te.value = 1
importDataFormLayout.addRow('EchoTime:', self.__te)
self.__tr = qt.QDoubleSpinBox()
self.__tr.value = 1
importDataFormLayout.addRow('RepetitionTime:', self.__tr)
self.__fa = qt.QDoubleSpinBox()
self.__fa.value = 1
importDataFormLayout.addRow('FlipAngle:', self.__fa)
# Botón de importar
self.buttonImport = qt.QPushButton("Import")
self.buttonImport.toolTip = "Run the algorithm."
##self.buttonImport.enabled = True
importDataFormLayout.addRow(" ",
self.buttonImport)
self.buttonImport.connect('clicked(bool)', self.importFunction)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Instantiate and connect widgets ...
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
# Volume selector
self.inputVolumeSelectorLabel = qt.QLabel()
self.inputVolumeSelectorLabel.setText("Input volume: ")
self.inputVolumeSelector = slicer.qMRMLNodeComboBox()
self.inputVolumeSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "")
self.inputVolumeSelector.noneEnabled = False
self.inputVolumeSelector.addEnabled = False
self.inputVolumeSelector.removeEnabled = False
self.inputVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.inputVolumeSelector.setToolTip("Pick the volume to clip")
parametersFormLayout.addRow(self.inputVolumeSelectorLabel,
self.inputVolumeSelector)
# ROI selector
self.clippingRoiSelectorLabel = qt.QLabel()
self.clippingRoiSelectorLabel.setText("Clipping ROI: ")
self.clippingRoiSelector = slicer.qMRMLNodeComboBox()
self.clippingRoiSelector.nodeTypes = ("vtkMRMLAnnotationROINode", "")
self.clippingRoiSelector.noneEnabled = False
self.clippingRoiSelector.selectNodeUponCreation = True
self.clippingRoiSelector.setMRMLScene(slicer.mrmlScene)
self.clippingRoiSelector.setToolTip(
"Pick the clipping region of interest (ROI)")
parametersFormLayout.addRow(self.clippingRoiSelectorLabel,
self.clippingRoiSelector)
#
# clip inside/outside the surface
#
self.clipOutsideSurfaceCheckBox = qt.QCheckBox()
self.clipOutsideSurfaceCheckBox.checked = False
self.clipOutsideSurfaceCheckBox.setToolTip(
"If checked, voxel values will be filled outside the clipping ROI."
)
parametersFormLayout.addRow("Clip outside: ",
self.clipOutsideSurfaceCheckBox)
# Fill value editor
self.fillValueLabel = qt.QLabel("Fill value:")
self.fillValueEdit = qt.QDoubleSpinBox()
self.fillValueEdit.minimum = -32768
self.fillValueEdit.maximum = 65535
parametersFormLayout.addRow(self.fillValueLabel, self.fillValueEdit)
#
# output volume selector
#
self.outputVolumeSelector = slicer.qMRMLNodeComboBox()
self.outputVolumeSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.outputVolumeSelector.selectNodeUponCreation = True
self.outputVolumeSelector.addEnabled = True
self.outputVolumeSelector.removeEnabled = True
self.outputVolumeSelector.noneEnabled = False
self.outputVolumeSelector.showHidden = False
self.outputVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.outputVolumeSelector.setToolTip(
"Clipped output volume. It may be the same as the input volume for cumulative clipping."
)
parametersFormLayout.addRow("Output Volume: ",
self.outputVolumeSelector)
# Apply button
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Clip volume with ROI"
parametersFormLayout.addWidget(self.applyButton)
self.updateApplyButtonState()
# connections
self.applyButton.connect("clicked()", self.onApply)
self.inputVolumeSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onInputVolumeSelect)
self.clippingRoiSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onClippingRoiSelect)
self.outputVolumeSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onOutputVolumeSelect)
# Define list of widgets for updateGUIFromParameterNode, updateParameterNodeFromGUI, and addGUIObservers
self.valueEditWidgets = {
"ClipOutsideSurface": self.clipOutsideSurfaceCheckBox,
"FillValue": self.fillValueEdit
}
self.nodeSelectorWidgets = {
"InputVolume": self.inputVolumeSelector,
"ClippingRoi": self.clippingRoiSelector,
"OutputVolume": self.outputVolumeSelector
}
# Use singleton parameter node (it is created if does not exist yet)
parameterNode = self.logic.getParameterNode()
# Set parameter node (widget will observe it and also updates GUI)
self.setAndObserveParameterNode(parameterNode)
self.addGUIObservers()
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
w = qt.QWidget();
layout = qt.QGridLayout();
w.setLayout(layout);
self.layout.addWidget(w);
w.show();
self.layout = layout;
####################IMPORTAR VOLUMEN 4D#################################################3
### Se crea la sección para cargar el volumen 4D en una pestaña desplegable
importDataCollapsibleButton = ctk.ctkCollapsibleButton()
importDataCollapsibleButton.text = "Import Data"
self.layout.addWidget(importDataCollapsibleButton)
importDataFormLayout = qt.QFormLayout(importDataCollapsibleButton)
#### Crear desplegable para seleccionar dirección del volumen
self.__fDialog = ctk.ctkDirectoryButton()
self.__fDialog.caption = 'Input directory'
importDataFormLayout.addRow('Input directory:', self.__fDialog)
###Selector de volumen donde se guardara el volumen de la direccion
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.outputSelector.addEnabled = True # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
self.outputSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
self.outputSelector.setMRMLScene(slicer.mrmlScene)
importDataFormLayout.addRow("Output node:", self.outputSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.outputSelector, 'setMRMLScene(vtkMRMLScene*)')
### Parametros avanzados
self.__dicomTag = qt.QLineEdit()
self.__dicomTag.text = 'NA'
importDataFormLayout.addRow('Frame identifying DICOM tag:', self.__dicomTag)
self.__veLabel = qt.QLineEdit()
self.__veLabel.text = 'na'
importDataFormLayout.addRow('Frame identifying units:', self.__veLabel)
self.__veInitial = qt.QDoubleSpinBox()
self.__veInitial.value = 0
importDataFormLayout.addRow('Initial value:', self.__veInitial)
self.__veStep = qt.QDoubleSpinBox()
self.__veStep.value = 1
importDataFormLayout.addRow('Step:', self.__veStep)
self.__te = qt.QDoubleSpinBox()
self.__te.value = 1
importDataFormLayout.addRow('EchoTime:', self.__te)
self.__tr = qt.QDoubleSpinBox()
self.__tr.value = 1
importDataFormLayout.addRow('RepetitionTime:', self.__tr)
self.__fa = qt.QDoubleSpinBox()
self.__fa.value = 1
importDataFormLayout.addRow('FlipAngle:', self.__fa)
# Botón de importar
self.buttonImport = qt.QPushButton("Import")
self.buttonImport.toolTip = "Run the algorithm."
##self.buttonImport.enabled = True
importDataFormLayout.addRow(" ", self.buttonImport)
self.buttonImport.connect('clicked(bool)', self.importFunction)
##self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
################################### PARÁMETROS DE PROCESAMIENTO#################################################
## # Se crea la sección para seleccionar parámetros el volumen 4D en una pestaña desplegable
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
self.inputSelector = slicer.qMRMLNodeComboBox()
self.inputSelector.nodeTypes = ["vtkMRMLMultiVolumeNode"]
self.inputSelector.selectNodeUponCreation = True
self.inputSelector.addEnabled = True
self.inputSelector.removeEnabled = False
self.inputSelector.noneEnabled = True
self.inputSelector.showHidden = False
self.inputSelector.showChildNodeTypes = False
self.inputSelector.setMRMLScene( slicer.mrmlScene )
self.inputSelector.setToolTip( "Pick the input to the algorithm." )
parametersFormLayout.addRow("Volumen 4D: ", self.inputSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.inputSelector, 'setMRMLScene(vtkMRMLScene*)')
##########################PROCESAMIENTO##########################################################################
## # Se crea la sección para seleccionar procesamiento del volumen 4D en una pestaña desplegable
processingCollapsibleButton = ctk.ctkCollapsibleButton()
processingCollapsibleButton.text = "Processing"
self.layout.addWidget(processingCollapsibleButton)
processingFormLayout = qt.QFormLayout(processingCollapsibleButton)
# Botón de Segmentación
#Este botón solo se activa si el multivolumen ha sido seleccionado en la
#ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
#realiza el registro de los diferentes volumenes en el volumen 4D
self.buttonSegmentation = qt.QPushButton("Segmentation")
self.buttonSegmentation.toolTip = "Run the algorithm."
self.buttonSegmentation.enabled = True
processingFormLayout.addRow(" ", self.buttonSegmentation)
# Botón de modelo 3D
#Este botón solo se activa si el multivolumen ha sido seleccionado en la
#ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
#realiza el registro de los diferentes volumenes en el volumen 4D
self.buttonModel = qt.QPushButton("Show 3D model")
self.buttonModel.toolTip = "Run the algorithm."
self.buttonModel.enabled = True
processingFormLayout.addRow(" ",self.buttonModel)
########################################CURVAS#######################################################
## # Se crea la sección para seleccionar curvas del volumen 4D en una pestaña desplegable
curvesCollapsibleButton = ctk.ctkCollapsibleButton()
curvesCollapsibleButton.text = "Curves"
self.layout.addWidget(curvesCollapsibleButton)
curvesFormLayout = qt.QFormLayout(curvesCollapsibleButton)
# Botón de generación de curvas
#Este botón solo se activa si el multivolumen ha sido seleccionado en la
#ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
#realiza el registro de los diferentes volumenes en el volumen 4D
self.buttonCurves = qt.QPushButton("Generate curves")
self.buttonCurves.toolTip = "Run the algorithm."
self.buttonCurves.enabled = True
curvesFormLayout.addRow(" ",self.buttonCurves)
