def makePyramidWidgets(self):
self.pyramidTab = qt.QWidget()
self.parametersTabWidget.addTab(self.pyramidTab, 'Pyramid levels')
self.pyramidLayout = qt.QGridLayout(self.pyramidTab)
self.pyramidLayout.addWidget(qt.QLabel('Reference'), 0, 2)
self.pyramidLayout.addWidget(qt.QLabel('Floating'), 0, 3)
self.pyramidHighestSpinBox = qt.QSpinBox()
self.pyramidHighestSpinBox.value = 3
self.pyramidHighestSpinBox.setAlignment(qt.Qt.AlignCenter)
self.pyramidHighestSpinBox.valueChanged.connect(
self.onPyramidLevelsChanged)
self.pyramidHighestReferenceLabel = qt.QLabel()
self.pyramidHighestReferenceLabel.setAlignment(qt.Qt.AlignCenter)
self.pyramidHighestFloatingLabel = qt.QLabel()
self.pyramidHighestFloatingLabel.setAlignment(qt.Qt.AlignCenter)
self.pyramidLayout.addWidget(qt.QLabel('Highest:'), 1, 0)
self.pyramidLayout.addWidget(self.pyramidHighestSpinBox, 1, 1)
self.pyramidLayout.addWidget(self.pyramidHighestReferenceLabel, 1, 2)
self.pyramidLayout.addWidget(self.pyramidHighestFloatingLabel, 1, 3)
self.pyramidLowestSpinBox = qt.QSpinBox()
self.pyramidLowestSpinBox.value = 2
self.pyramidLowestSpinBox.setAlignment(qt.Qt.AlignCenter)
self.pyramidLowestSpinBox.valueChanged.connect(
self.onPyramidLevelsChanged)
self.pyramidLowestReferenceLabel = qt.QLabel()
self.pyramidLowestReferenceLabel.setAlignment(qt.Qt.AlignCenter)
self.pyramidLowestFloatingLabel = qt.QLabel()
self.pyramidLowestFloatingLabel.setAlignment(qt.Qt.AlignCenter)
self.pyramidLayout.addWidget(qt.QLabel('Lowest:'), 2, 0)
self.pyramidLayout.addWidget(self.pyramidLowestSpinBox, 2, 1)
self.pyramidLayout.addWidget(self.pyramidLowestReferenceLabel, 2, 2)
self.pyramidLayout.addWidget(self.pyramidLowestFloatingLabel, 2, 3)
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 create(self):
self.frame = qt.QFrame(self.parent)
self.frame.setLayout(qt.QHBoxLayout())
self.parent.layout().addWidget(self.frame)
self.label = qt.QLabel(self.frame)
self.label.setText("Label: ")
self.frame.layout().addWidget(self.label)
self.labelName = qt.QLabel(self.frame)
self.labelName.setText("")
self.frame.layout().addWidget(self.labelName)
self.colorSpin = qt.QSpinBox(self.frame)
self.colorSpin.setValue(int(tcl('EditorGetPaintLabel')))
self.colorSpin.setToolTip(
"Click colored patch at right to bring up color selection pop up window. Use the 'c' key to bring up color popup menu."
)
self.frame.layout().addWidget(self.colorSpin)
self.colorPatch = qt.QPushButton(self.frame)
self.frame.layout().addWidget(self.colorPatch)
self.updateParameterNode(slicer.mrmlScene, "ModifiedEvent")
self.updateGUIFromMRML(self.parameterNode, "ModifiedEvent")
self.frame.connect('destroyed(QObject)', self.cleanup)
self.colorSpin.connect('valueChanged(int)', self.updateMRMLFromGUI)
self.colorPatch.connect('clicked()', self.showColorBox)
# TODO: change this to look for specfic events (added, removed...)
# but this requires being able to access events by number from wrapped code
tag = slicer.mrmlScene.AddObserver("ModifiedEvent",
self.updateParameterNode)
self.observerTags.append((slicer.mrmlScene, tag))
def create(self):
self.frame = qt.QFrame(self.parent)
self.frame.objectName = 'EditColorFrame'
self.frame.setLayout(qt.QHBoxLayout())
self.parent.layout().addWidget(self.frame)
self.label = qt.QLabel(self.frame)
self.label.setText("Label: ")
self.frame.layout().addWidget(self.label)
self.labelName = qt.QLabel(self.frame)
self.labelName.setText("")
self.frame.layout().addWidget(self.labelName)
self.colorSpin = qt.QSpinBox(self.frame)
self.colorSpin.objectName = 'ColorSpinBox'
self.colorSpin.setMaximum( 64000)
self.colorSpin.setValue( EditUtil.getLabel() )
self.colorSpin.setToolTip( "Click colored patch at right to bring up color selection pop up window. Use the 'c' key to bring up color popup menu." )
self.frame.layout().addWidget(self.colorSpin)
self.colorPatch = qt.QPushButton(self.frame)
self.colorPatch.setObjectName('ColorPatchButton')
self.frame.layout().addWidget(self.colorPatch)
self.updateParameterNode(slicer.mrmlScene, vtk.vtkCommand.ModifiedEvent)
self.updateGUIFromMRML(self.parameterNode, vtk.vtkCommand.ModifiedEvent)
self.frame.connect( 'destroyed()', self.cleanup)
self.colorSpin.connect( 'valueChanged(int)', self.updateMRMLFromGUI)
self.colorPatch.connect( 'clicked()', self.showColorBox )
# TODO: change this to look for specfic events (added, removed...)
# but this requires being able to access events by number from wrapped code
self.addObserver(slicer.mrmlScene, vtk.vtkCommand.ModifiedEvent, self.updateParameterNode)
def setup(self):
# Instantiate and connect widgets ...
# Collapsible button
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the parameters collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
# fiber
self.fiberSelector = slicer.qMRMLNodeComboBox(
parametersCollapsibleButton)
self.fiberSelector.nodeTypes = (("vtkMRMLFiberBundleNode"), "")
self.fiberSelector.selectNodeUponCreation = False
self.fiberSelector.addEnabled = False
self.fiberSelector.removeEnabled = False
self.fiberSelector.noneEnabled = True
self.fiberSelector.showHidden = False
self.fiberSelector.showChildNodeTypes = False
self.fiberSelector.setMRMLScene(slicer.mrmlScene)
self.fiberSelector.setToolTip("Pick the fiber bundle to be converted.")
parametersFormLayout.addRow("Fiber Bundle", self.fiberSelector)
# label map
self.labelSelector = slicer.qMRMLNodeComboBox(
parametersCollapsibleButton)
self.labelSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.labelSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap",
1)
self.labelSelector.selectNodeUponCreation = False
self.labelSelector.addEnabled = False
self.labelSelector.removeEnabled = False
self.labelSelector.noneEnabled = True
self.labelSelector.showHidden = False
self.labelSelector.showChildNodeTypes = False
self.labelSelector.setMRMLScene(slicer.mrmlScene)
self.labelSelector.setToolTip(
"Pick the target label volume. Must already exists in order to define sampling grid. If needed, create one in the Editor module based on template volume."
)
parametersFormLayout.addRow("Target LabelMap", self.labelSelector)
# label value
self.labelValue = qt.QSpinBox(parametersCollapsibleButton)
self.labelValue.setToolTip(
"The numerical value for the rasterized fiber label.")
self.labelValue.setValue(1)
parametersFormLayout.addRow("Label Value", self.labelValue)
# apply
self.applyButton = qt.QPushButton(parametersCollapsibleButton)
self.applyButton.text = "Apply"
parametersFormLayout.addWidget(self.applyButton)
self.applyButton.connect('clicked()', self.onApply)
# Add vertical spacer
self.layout.addStretch(1)
def create(self):
super(IslandEffectOptions,self).create()
self.fullyConnected = qt.QCheckBox("Fully Connected", self.frame)
self.fullyConnected.setToolTip("When set, only pixels that share faces (not corners or edges) are considered connected.")
self.frame.layout().addWidget(self.fullyConnected)
self.widgets.append(self.fullyConnected)
self.sizeLabel = qt.QLabel("Minimum Size", self.frame)
self.sizeLabel.setToolTip("Minimum size of islands to be considered.")
self.frame.layout().addWidget(self.sizeLabel)
self.widgets.append(self.sizeLabel)
self.minimumSize = qt.QSpinBox(self.frame)
self.minimumSize.minimum = 0
self.minimumSize.maximum = vtk.VTK_INT_MAX
self.minimumSize.value = 0
self.frame.layout().addWidget(self.minimumSize)
self.widgets.append(self.minimumSize)
self.connections.append( (self.fullyConnected, "clicked()", self.updateMRMLFromGUI ) )
self.connections.append( (self.minimumSize, "valueChanged(int)", self.updateMRMLFromGUI ) )
def createIntWidget(self, name, type="int"):
w = qt.QSpinBox()
self.widgets.append(w)
if type == "uint8_t":
w.setRange(0, 255)
elif type == "int8_t":
w.setRange(-128, 127)
elif type == "uint16_t":
w.setRange(0, 65535)
elif type == "int16_t":
w.setRange(-32678, 32767)
elif type == "uint32_t" or type == "unsigned int":
w.setRange(0, 2147483647)
elif type == "int32_t" or type == "int":
w.setRange(-2147483648, 2147483647)
w.setValue(int(self._getParameterValue(name)))
w.connect("valueChanged(int)",
lambda val, name=name: self.onScalarChanged(name, val))
self.widgetConnections.append((w, "valueChanged(int)"))
return w
def createIntWidget(self, name, type="int"):
w = qt.QSpinBox()
self.widgets.append(w)
if type == "uint8_t":
w.setRange(0, 255)
elif type == "int8_t":
w.setRange(-128, 127)
elif type == "uint16_t":
w.setRange(0, 65535)
elif type == "int16_t":
w.setRange(-32678, 32767)
elif type == "uint32_t" or type == "uint64_t" or type == "unsigned int":
w.setRange(0, 2147483647)
elif type == "int32_t" or type == "uint64_t" or type == "int":
w.setRange(-2147483648, 2147483647)
exec('default = self.filter.Get{0}()'.format(name)
) in globals(), locals()
w.setValue(int(default))
w.connect("valueChanged(int)",
lambda val, name=name: self.onScalarChanged(name, val))
return w
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)
#
# input fiducial list selector
#
fiducialWarningLabel = qt.QLabel("Note: Parent transforms of fiducials are not used. Fiducials should be defined in the coordinate system that is being registered.")
fiducialWarningLabel.setWordWrap(True)
parametersFormLayout.addRow(fiducialWarningLabel)
self.inputFiducialSelector = slicer.qMRMLNodeComboBox()
self.inputFiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "")
self.inputFiducialSelector.selectNodeUponCreation = True
self.inputFiducialSelector.addEnabled = False
self.inputFiducialSelector.removeEnabled = False
self.inputFiducialSelector.noneEnabled = False
self.inputFiducialSelector.showHidden = False
self.inputFiducialSelector.showChildNodeTypes = False
self.inputFiducialSelector.setMRMLScene(slicer.mrmlScene)
self.inputFiducialSelector.setToolTip("Pick the input fiducial list for the algorithm.")
parametersFormLayout.addRow("Input fiducials: ", self.inputFiducialSelector)
#
# input model selector
#
self.inputModelSelector = slicer.qMRMLNodeComboBox()
self.inputModelSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.inputModelSelector.selectNodeUponCreation = True
self.inputModelSelector.addEnabled = False
self.inputModelSelector.removeEnabled = False
self.inputModelSelector.noneEnabled = False
self.inputModelSelector.showHidden = False
self.inputModelSelector.showChildNodeTypes = False
self.inputModelSelector.setMRMLScene(slicer.mrmlScene)
self.inputModelSelector.setToolTip("Pick the input model for the algorithm.")
parametersFormLayout.addRow("Input model: ", self.inputModelSelector)
#
# output transform selector
#
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = (("vtkMRMLLinearTransformNode"), "")
self.outputSelector.selectNodeUponCreation = True
self.outputSelector.addEnabled = True
self.outputSelector.removeEnabled = True
self.outputSelector.noneEnabled = False
self.outputSelector.showHidden = False
self.outputSelector.showChildNodeTypes = False
self.outputSelector.renameEnabled = True
self.outputSelector.setMRMLScene(slicer.mrmlScene)
self.outputSelector.setToolTip("Pick the output to the algorithm.")
parametersFormLayout.addRow("Output transform: ", self.outputSelector)
#
# check box to trigger taking screen shots for later use in tutorials
#
self.enableScreenshotsFlagCheckBox = qt.QCheckBox()
self.enableScreenshotsFlagCheckBox.checked = 0
self.enableScreenshotsFlagCheckBox.setToolTip("If checked, take screen shots for tutorials. Use Save Data to write them to disk.")
# parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox)
#
# scale factor for screen shots
#
self.screenshotScaleFactorSliderWidget = ctk.ctkSliderWidget()
self.screenshotScaleFactorSliderWidget.singleStep = 1.0
self.screenshotScaleFactorSliderWidget.minimum = 1.0
self.screenshotScaleFactorSliderWidget.maximum = 50.0
self.screenshotScaleFactorSliderWidget.value = 1.0
self.screenshotScaleFactorSliderWidget.setToolTip("Set scale factor for the screen shots.")
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
#
# Output panel
#
outputCollapsibleButton = ctk.ctkCollapsibleButton()
outputCollapsibleButton.text = "Output"
self.layout.addWidget(outputCollapsibleButton)
outputFormLayout = qt.QFormLayout(outputCollapsibleButton)
self.outputLine = qt.QLineEdit()
self.outputLine.setReadOnly(True)
outputFormLayout.addRow("Mean distance after registration:", self.outputLine)
#
# Advanced parameters
#
advancedCollapsibleButton = ctk.ctkCollapsibleButton()
advancedCollapsibleButton.text = "Advanced"
self.layout.addWidget(advancedCollapsibleButton)
# Layout
advancedCollapsibleButton.collapsed = True
advancedFormLayout = qt.QFormLayout(advancedCollapsibleButton)
#
# Transform type selector
#
self.typeSelector = qt.QComboBox()
self.typeSelector.insertItem(0, "Rigid")
self.typeSelector.insertItem(1, "Similarity")
self.typeSelector.insertItem(2, "Affine")
advancedFormLayout.addRow("Transform type: ", self.typeSelector)
#
# Iteration selector
#
self.iterationSpin = qt.QSpinBox()
self.iterationSpin.setMaximum(1000)
self.iterationSpin.setValue(100)
advancedFormLayout.addRow("Number of iterations:", self.iterationSpin)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.inputFiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
# Instantiate the logic class
self.logic = FiducialsToModelRegistrationLogic()
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)
#
# input volume selector
#
self.inputVolumeSelector = slicer.qMRMLNodeComboBox()
self.inputVolumeSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.inputVolumeSelector.addEnabled = False
self.inputVolumeSelector.removeEnabled = False
self.inputVolumeSelector.noneEnabled = False
self.inputVolumeSelector.showHidden = False
self.inputVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.inputVolumeSelector.setToolTip(
"Input volume that will be clipped.")
parametersFormLayout.addRow("Input Volume: ", self.inputVolumeSelector)
#
# clipping model selector
#
self.clippingModelSelector = slicer.qMRMLNodeComboBox()
self.clippingModelSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.clippingModelSelector.addEnabled = True
self.clippingModelSelector.removeEnabled = False
self.clippingModelSelector.noneEnabled = True
self.clippingModelSelector.showHidden = False
self.clippingModelSelector.renameEnabled = True
self.clippingModelSelector.selectNodeUponCreation = True
self.clippingModelSelector.showChildNodeTypes = False
self.clippingModelSelector.setMRMLScene(slicer.mrmlScene)
self.clippingModelSelector.setToolTip(
"Choose the clipping surface model.")
parametersFormLayout.addRow("Clipping surface: ",
self.clippingModelSelector)
#
# markup selector
#
self.clippingMarkupSelector = slicer.qMRMLNodeComboBox()
self.clippingMarkupSelector.nodeTypes = ((
"vtkMRMLMarkupsFiducialNode"), "")
self.clippingMarkupSelector.addEnabled = True
self.clippingMarkupSelector.removeEnabled = False
self.clippingMarkupSelector.noneEnabled = True
self.clippingMarkupSelector.showHidden = False
self.clippingMarkupSelector.renameEnabled = True
self.clippingMarkupSelector.baseName = "C"
self.clippingMarkupSelector.setMRMLScene(slicer.mrmlScene)
self.clippingMarkupSelector.setToolTip(
"If markups are selected then the clipping surface will be generated from the markup points. The surface is updated automatically when markups are moved."
)
parametersFormLayout.addRow("Clipping surface from markups: ",
self.clippingMarkupSelector)
#
# clip outside the surface
#
self.clipOutsideSurfaceCheckBox = qt.QCheckBox()
self.clipOutsideSurfaceCheckBox.checked = False
self.clipOutsideSurfaceCheckBox.setToolTip(
"If checked, voxel values will be filled outside the clipping surface."
)
parametersFormLayout.addRow("Clip outside: ",
self.clipOutsideSurfaceCheckBox)
#
# outside fill value
#
self.fillOutsideValueEdit = qt.QSpinBox()
self.fillOutsideValueEdit.setToolTip(
"Choose the voxel intensity that will be used to fill outside the clipped regions"
)
self.fillOutsideValueEdit.minimum = 0
self.fillOutsideValueEdit.maximum = 65535
self.fillOutsideValueEdit.value = 255
parametersFormLayout.addRow("Outside Fill value: ",
self.fillOutsideValueEdit)
#
# clip inside the surface
#
self.clipInsideSurfaceCheckBox = qt.QCheckBox()
self.clipInsideSurfaceCheckBox.checked = False
self.clipInsideSurfaceCheckBox.setToolTip(
"If checked, voxel values will be filled inside the clipping surface."
)
parametersFormLayout.addRow("Clip inside: ",
self.clipInsideSurfaceCheckBox)
#
# outside fill value
#
self.fillInsideValueEdit = qt.QSpinBox()
self.fillInsideValueEdit.setToolTip(
"Choose the voxel intensity that will be used to fill Inside the clipped regions"
)
self.fillInsideValueEdit.minimum = 0
self.fillInsideValueEdit.maximum = 65535
self.fillInsideValueEdit.value = 255
parametersFormLayout.addRow("Inside Fill value: ",
self.fillInsideValueEdit)
#
# 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 surface model."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputVolumeSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onInputVolumeSelect)
self.clippingModelSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onClippingModelSelect)
self.clippingMarkupSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onClippingMarkupSelect)
self.outputVolumeSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onOutputVolumeSelect)
# Define list of widgets for updateGUIFromParameterNode, updateParameterNodeFromGUI, and addGUIObservers
self.valueEditWidgets = {
"clipOutsideSurface": self.clipOutsideSurfaceCheckBox,
"fillOutsideValue": self.fillOutsideValueEdit,
"clipInsideSurface": self.clipInsideSurfaceCheckBox,
"fillInsideValue": self.fillInsideValueEdit
}
self.nodeSelectorWidgets = {
"InputVolume": self.inputVolumeSelector,
"ClippingModel": self.clippingModelSelector,
"ClippingMarkup": self.clippingMarkupSelector,
"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.setAndObserveClippingMarkupNode(
self.clippingMarkupSelector.currentNode())
self.addGUIObservers()
# Add vertical spacer
self.layout.addStretch(1)
self.updateApplyButtonState()
def setup( self ):
# check if the SlicerVmtk module is installed properly
# self.__vmtkInstalled = SlicerVmtkCommonLib.Helper.CheckIfVmtkIsInstalled()
# Helper.Debug("VMTK found: " + self.__vmtkInstalled)
#
# the I/O panel
#
ioCollapsibleButton = ctk.ctkCollapsibleButton()
ioCollapsibleButton.text = "Input/Output"
self.layout.addWidget( ioCollapsibleButton )
ioFormLayout = qt.QFormLayout( ioCollapsibleButton )
# inputVolume selector
self.__inputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__inputVolumeNodeSelector.objectName = 'inputVolumeNodeSelector'
self.__inputVolumeNodeSelector.toolTip = "Select the input volume."
self.__inputVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__inputVolumeNodeSelector.noneEnabled = False
self.__inputVolumeNodeSelector.addEnabled = False
self.__inputVolumeNodeSelector.removeEnabled = False
self.__inputVolumeNodeSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", "0" )
ioFormLayout.addRow( "Input Volume:", self.__inputVolumeNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__inputVolumeNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
self.__inputVolumeNodeSelector.connect( 'currentNodeChanged(vtkMRMLNode*)', self.onInputVolumeChanged )
# seed selector
self.__seedFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.__seedFiducialsNodeSelector.objectName = 'seedFiducialsNodeSelector'
self.__seedFiducialsNodeSelector.toolTip = "Select a fiducial to use as a Seed to detect the maximal diameter."
self.__seedFiducialsNodeSelector.nodeTypes = ['vtkMRMLAnnotationFiducialNode']
self.__seedFiducialsNodeSelector.baseName = "DiameterSeed"
self.__seedFiducialsNodeSelector.noneEnabled = False
self.__seedFiducialsNodeSelector.addEnabled = False
self.__seedFiducialsNodeSelector.removeEnabled = False
ioFormLayout.addRow( "Seed in largest Vessel:", self.__seedFiducialsNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__seedFiducialsNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
self.__seedFiducialsNodeSelector.connect( 'currentNodeChanged(vtkMRMLNode*)', self.onSeedChanged )
self.__ioAdvancedToggle = qt.QCheckBox( "Show Advanced Properties" )
self.__ioAdvancedToggle.setChecked( False )
ioFormLayout.addRow( self.__ioAdvancedToggle )
#
# I/O advanced panel
#
self.__ioAdvancedPanel = qt.QFrame( ioCollapsibleButton )
self.__ioAdvancedPanel.hide()
self.__ioAdvancedPanel.setFrameStyle( 6 )
ioFormLayout.addRow( self.__ioAdvancedPanel )
self.__ioAdvancedToggle.connect( "clicked()", self.onIOAdvancedToggle )
ioAdvancedFormLayout = qt.QFormLayout( self.__ioAdvancedPanel )
# lock button
self.__detectPushButton = qt.QPushButton()
self.__detectPushButton.text = "Detect parameters automatically"
self.__detectPushButton.checkable = True
self.__detectPushButton.checked = True
# self.__unLockPushButton.connect("clicked()", self.calculateParameters())
ioAdvancedFormLayout.addRow( self.__detectPushButton )
# outputVolume selector
self.__outputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__outputVolumeNodeSelector.toolTip = "Select the output labelmap."
self.__outputVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__outputVolumeNodeSelector.baseName = "VesselnessFiltered"
self.__outputVolumeNodeSelector.noneEnabled = False
self.__outputVolumeNodeSelector.addEnabled = True
self.__outputVolumeNodeSelector.selectNodeUponCreation = True
self.__outputVolumeNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow( "Output Volume:", self.__outputVolumeNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__outputVolumeNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
# previewVolume selector
self.__previewVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__previewVolumeNodeSelector.toolTip = "Select the preview volume."
self.__previewVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__previewVolumeNodeSelector.baseName = "VesselnessPreview"
self.__previewVolumeNodeSelector.noneEnabled = False
self.__previewVolumeNodeSelector.addEnabled = True
self.__previewVolumeNodeSelector.selectNodeUponCreation = True
self.__previewVolumeNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow( "Preview Volume:", self.__previewVolumeNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__previewVolumeNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
self.__minimumDiameterSpinBox = qt.QSpinBox()
self.__minimumDiameterSpinBox.minimum = 0
self.__minimumDiameterSpinBox.maximum = 1000
self.__minimumDiameterSpinBox.singleStep = 1
self.__minimumDiameterSpinBox.toolTip = "Specify the minimum Diameter manually."
ioAdvancedFormLayout.addRow( "Minimum Diameter [vx]:", self.__minimumDiameterSpinBox )
self.__maximumDiameterSpinBox = qt.QSpinBox()
self.__maximumDiameterSpinBox.minimum = 0
self.__maximumDiameterSpinBox.maximum = 1000
self.__maximumDiameterSpinBox.singleStep = 1
self.__maximumDiameterSpinBox.toolTip = "Specify the maximum Diameter manually."
ioAdvancedFormLayout.addRow( "Maximum Diameter [vx]:", self.__maximumDiameterSpinBox )
# add empty row
ioAdvancedFormLayout.addRow( "", qt.QWidget() )
# alpha slider
alphaLabel = qt.QLabel()
alphaLabel.text = "more Tubes <-> more Plates" + SlicerVmtkCommonLib.Helper.CreateSpace( 16 )
alphaLabel.setAlignment( 4 )
alphaLabel.toolTip = "A lower value detects tubes rather than plate-like structures."
ioAdvancedFormLayout.addRow( alphaLabel )
self.__alphaSlider = ctk.ctkSliderWidget()
self.__alphaSlider.decimals = 1
self.__alphaSlider.minimum = 0.1
self.__alphaSlider.maximum = 500
self.__alphaSlider.singleStep = 0.1
self.__alphaSlider.toolTip = alphaLabel.toolTip
ioAdvancedFormLayout.addRow( self.__alphaSlider )
# beta slider
betaLabel = qt.QLabel()
betaLabel.text = "more Blobs <-> more Tubes" + SlicerVmtkCommonLib.Helper.CreateSpace( 16 )
betaLabel.setAlignment( 4 )
betaLabel.toolTip = "A higher value detects tubes rather than blobs."
ioAdvancedFormLayout.addRow( betaLabel )
self.__betaSlider = ctk.ctkSliderWidget()
self.__betaSlider.decimals = 1
self.__betaSlider.minimum = 0.1
self.__betaSlider.maximum = 500
self.__betaSlider.singleStep = 0.1
self.__betaSlider.toolTip = betaLabel.toolTip
ioAdvancedFormLayout.addRow( self.__betaSlider )
# contrast slider
contrastLabel = qt.QLabel()
contrastLabel.text = "low Input Contrast <-> high Input Contrast" + SlicerVmtkCommonLib.Helper.CreateSpace( 14 )
contrastLabel.setAlignment( 4 )
contrastLabel.toolTip = "If the intensity contrast in the input image between vessel and background is high, choose a high value else choose a low value."
ioAdvancedFormLayout.addRow( contrastLabel )
self.__contrastSlider = ctk.ctkSliderWidget()
self.__contrastSlider.decimals = 0
self.__contrastSlider.minimum = 0
self.__contrastSlider.maximum = 500
self.__contrastSlider.singleStep = 10
self.__contrastSlider.toolTip = contrastLabel.toolTip
ioAdvancedFormLayout.addRow( self.__contrastSlider )
#
# Reset, preview and apply buttons
#
self.__buttonBox = qt.QDialogButtonBox()
self.__resetButton = self.__buttonBox.addButton( self.__buttonBox.RestoreDefaults )
self.__resetButton.toolTip = "Click to reset all input elements to default."
self.__previewButton = self.__buttonBox.addButton( self.__buttonBox.Discard )
self.__previewButton.setIcon( qt.QIcon() )
self.__previewButton.text = "Preview.."
self.__previewButton.toolTip = "Click to refresh the preview."
self.__startButton = self.__buttonBox.addButton( self.__buttonBox.Apply )
self.__startButton.setIcon( qt.QIcon() )
self.__startButton.text = "Start!"
self.__startButton.enabled = False
self.__startButton.toolTip = "Click to start the filtering."
self.layout.addWidget( self.__buttonBox )
self.__resetButton.connect( "clicked()", self.restoreDefaults )
self.__previewButton.connect( "clicked()", self.onRefreshButtonClicked )
self.__startButton.connect( "clicked()", self.onStartButtonClicked )
# be ready for events
self.__updating = 0
# set default values
self.restoreDefaults()
# compress the layout
self.layout.addStretch( 1 )
def createUserInterface(self):
'''
'''
self.__layout = self.__parent.createUserInterface()
# deactivate next button since it is the last step
self.buttonBoxHints = self.NextButtonDisabled
# the ROI parameters
voiGroupBox = qt.QGroupBox()
voiGroupBox.setTitle('Define VOI')
self.__layout.addWidget(voiGroupBox)
voiGroupBoxLayout = qt.QFormLayout(voiGroupBox)
self.__roiWidget = PythonQt.qSlicerAnnotationsModuleWidgets.qMRMLAnnotationROIWidget(
)
voiGroupBoxLayout.addWidget(self.__roiWidget)
self.__roi = slicer.vtkMRMLAnnotationROINode()
self.__roi.SetXYZ([0, 0, 0])
self.__roi.SetRadiusXYZ(100, 100, 100)
self.__roi.Initialize(slicer.mrmlScene)
self.__roi.AddObserver(vtk.vtkCommand.ModifiedEvent,
self.updateMRMLFromROI)
self.__roiWidget.setMRMLAnnotationROINode(self.__roi)
self.__roiWidget.setDisplayClippingBox(0)
#
# save groupbox
#
saveGroupBox = qt.QGroupBox()
saveGroupBox.setTitle('Save')
self.__layout.addWidget(saveGroupBox)
saveGroupBoxLayout = qt.QFormLayout(saveGroupBox)
self.__saveButton = qt.QPushButton('Create')
saveGroupBoxLayout.addRow("Create Template File:", self.__saveButton)
self.__saveButton.connect('clicked()', self.onSaveButtonClicked)
self.__saveIntermediateResultsCheckBox = qt.QCheckBox()
saveGroupBoxLayout.addRow("Save Intermediate Results:",
self.__saveIntermediateResultsCheckBox)
self.__saveIntermediateResultsCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__selectDirectoryButton = qt.QPushButton('Select')
saveGroupBoxLayout.addRow("Select Intermediate Directory:",
self.__selectDirectoryButton)
self.__selectDirectoryButton.connect(
'clicked()', self.onSelectDirectoryButtonClicked)
#
# post processing groupbox
#
postProcessingGroupBox = qt.QGroupBox()
postProcessingGroupBox.setTitle('Postprocessing')
self.__layout.addWidget(postProcessingGroupBox)
postProcessingGroupBoxLayout = qt.QFormLayout(postProcessingGroupBox)
self.__subparcellationCheckBox = qt.QCheckBox()
postProcessingGroupBoxLayout.addRow("Subparcellation enabled:",
self.__subparcellationCheckBox)
self.__subparcellationCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__minimumIslandSizeSpinBox = qt.QSpinBox()
self.__minimumIslandSizeSpinBox.minimum = 0
self.__minimumIslandSizeSpinBox.maximum = 200
self.__minimumIslandSizeSpinBox.singleStep = 1
postProcessingGroupBoxLayout.addRow("Minimum island size:",
self.__minimumIslandSizeSpinBox)
self.__minimumIslandSizeSpinBox.connect('stateChanged(int)',
self.propagateToMRML)
self.__twoDIslandNeighborhoodCheckBox = qt.QCheckBox()
postProcessingGroupBoxLayout.addRow(
"2D Island Neighborhood:", self.__twoDIslandNeighborhoodCheckBox)
self.__twoDIslandNeighborhoodCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
#
# Misc. groupbox
#
miscGroupBox = qt.QGroupBox()
miscGroupBox.setTitle('Misc.')
self.__layout.addWidget(miscGroupBox)
miscGroupBoxLayout = qt.QFormLayout(miscGroupBox)
self.__multithreadingCheckBox = qt.QCheckBox()
miscGroupBoxLayout.addRow("Multi-threading enabled:",
self.__multithreadingCheckBox)
self.__multithreadingCheckBox.connect('stateChanged(int)',
self.propagateToMRML)
def setup(self):
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.onVCMRMLSceneChanged)
w = qt.QWidget()
layout = qt.QGridLayout()
w.setLayout(layout)
self.layout.addWidget(w)
w.show()
self.layout = layout
# create frames
self.inputFrame = ctk.ctkCollapsibleButton()
self.inputFrame.text = "Input"
self.inputFrame.collapsed = 0
inputFrameLayout = qt.QFormLayout(self.inputFrame)
self.layout.addWidget(self.inputFrame)
self.ctrlFrame = ctk.ctkCollapsibleButton()
self.ctrlFrame.text = "Frame control"
self.ctrlFrame.collapsed = 0
ctrlFrameLayout = qt.QGridLayout(self.ctrlFrame)
self.layout.addWidget(self.ctrlFrame)
self.plotFrame = ctk.ctkCollapsibleButton()
self.plotFrame.text = "Plotting"
self.plotFrame.collapsed = 0
plotFrameLayout = qt.QGridLayout(self.plotFrame)
self.layout.addWidget(self.plotFrame)
self.plotSettingsFrame = ctk.ctkCollapsibleButton()
self.plotSettingsFrame.text = "Settings"
self.plotSettingsFrame.collapsed = 1
plotSettingsFrameLayout = qt.QGridLayout(self.plotSettingsFrame)
plotFrameLayout.addWidget(self.plotSettingsFrame, 0, 1)
label = qt.QLabel('Input multivolume')
self.__mvSelector = slicer.qMRMLNodeComboBox()
self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.__mvSelector.setMRMLScene(slicer.mrmlScene)
self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.onVCMRMLSceneChanged)
self.__mvSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.onInputChanged)
self.__mvSelector.addEnabled = 0
inputFrameLayout.addRow(label, self.__mvSelector)
label = qt.QLabel('Input secondary multivolume')
self.fgSelector = slicer.qMRMLNodeComboBox()
self.fgSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.fgSelector.setMRMLScene(slicer.mrmlScene)
self.fgSelector.addEnabled = 0
self.fgSelector.noneEnabled = 1
self.fgSelector.toolTip = "Secondary multivolume will be used for the secondary \
plot in interactive charting. As an example, this can be used to overlay the \
curve obtained by fitting a model to the data"
inputFrameLayout.addRow(label, self.fgSelector)
# TODO: initialize the slider based on the contents of the labels array
# slider to scroll over metadata stored in the vector container being explored
self.__mdSlider = ctk.ctkSliderWidget()
label = qt.QLabel('Current frame number')
# "play" control
self.playButton = qt.QPushButton('Play')
self.playButton.toolTip = 'Iterate over multivolume frames'
self.playButton.checkable = True
ctrlFrameLayout.addWidget(label, 0, 0)
ctrlFrameLayout.addWidget(self.__mdSlider, 0, 1)
ctrlFrameLayout.addWidget(self.playButton, 0, 2)
self.playButton.connect('toggled(bool)', self.onPlayButtonToggled)
self.__mdSlider.connect('valueChanged(double)', self.onSliderChanged)
label = qt.QLabel('Current frame copy')
self.__vfSelector = slicer.qMRMLNodeComboBox()
self.__vfSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__vfSelector.setMRMLScene(slicer.mrmlScene)
self.__vfSelector.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.onVFMRMLSceneChanged)
self.__vfSelector.addEnabled = 1
self.__vfSelector.enabled = 0
# do not show "children" of vtkMRMLScalarVolumeNode
self.__vfSelector.hideChildNodeTypes = ["vtkMRMLDiffusionWeightedVolumeNode", \
"vtkMRMLDiffusionTensorVolumeNode", "vtkMRMLVectorVolumeNode"]
self.extractFrame = False
self.extractButton = qt.QPushButton('Enable current frame copying')
self.extractButton.checkable = True
self.extractButton.connect('toggled(bool)', self.onExtractFrameToggled)
ctrlFrameLayout.addWidget(label, 1, 0)
ctrlFrameLayout.addWidget(self.__vfSelector, 1, 1, 1, 2)
ctrlFrameLayout.addWidget(self.extractButton, 2, 0, 1, 3)
# 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()
# label map for probing
label = qt.QLabel('Probed label volume')
self.__fSelector = slicer.qMRMLNodeComboBox()
self.__fSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__fSelector.addAttribute('vtkMRMLScalarVolumeNode', 'LabelMap',
'1')
self.__fSelector.toolTip = 'Label map to be probed'
self.__fSelector.setMRMLScene(slicer.mrmlScene)
self.__fSelector.addEnabled = 0
self.chartButton = qt.QPushButton('Chart')
self.chartButton.checkable = False
self.chartButton.connect('clicked()', self.onChartRequested)
plotSettingsFrameLayout.addWidget(label, 0, 0)
plotSettingsFrameLayout.addWidget(self.__fSelector, 0, 1)
plotSettingsFrameLayout.addWidget(self.chartButton, 0, 2)
self.iCharting = qt.QPushButton()
self.iCharting.text = 'Enable interactive charting'
self.iCharting.checkable = True
plotSettingsFrameLayout.addWidget(self.iCharting, 1, 0, 1, 3)
self.iCharting.setChecked(True)
self.iCharting.connect('toggled(bool)',
self.onInteractiveChartingChanged)
groupLabel = qt.QLabel('Interactive plotting mode:')
self.iChartingMode = qt.QButtonGroup()
self.iChartingIntensity = qt.QRadioButton('Signal intensity')
#self.iChartingIntensity.tooltip = 'Plot range adjusted dynamically to the range over the time course for the selected pixel'
self.iChartingIntensityFixedAxes = qt.QRadioButton(
'Fixed range intensity')
#self.iChartingIntensityFixedAxes.tooltip = "If checked, the extent of the vertical axis of the plot will be fixed to the range of the intensities in the input MultiVolume"
self.iChartingPercent = qt.QRadioButton('Percent change')
#self.iChartingPercent.tooltip = 'Percent change relative to the average of the first N frames (parameter set below)'
self.iChartingIntensity.setChecked(1)
self.groupWidget = qt.QWidget()
self.groupLayout = qt.QFormLayout(self.groupWidget)
self.groupLayout.addRow(groupLabel)
self.groupLayout.addRow(self.iChartingIntensity)
self.groupLayout.addRow(self.iChartingIntensityFixedAxes)
self.groupLayout.addRow(self.iChartingPercent)
self.baselineFrames = qt.QSpinBox()
self.baselineFrames.minimum = 1
label = qt.QLabel('Number of frames for baseline calculation')
self.groupLayout.addRow(label, self.baselineFrames)
self.xLogScaleCheckBox = qt.QCheckBox()
self.xLogScaleCheckBox.setChecked(0)
label = qt.QLabel('Use log scale for X axis')
self.groupLayout.addRow(self.xLogScaleCheckBox, label)
self.xLogScaleCheckBox.connect('stateChanged(int)',
self.onXLogScaleRequested)
self.yLogScaleCheckBox = qt.QCheckBox()
self.yLogScaleCheckBox.setChecked(0)
label = qt.QLabel('Use log scale for Y axis')
self.groupLayout.addRow(self.yLogScaleCheckBox, label)
self.yLogScaleCheckBox.connect('stateChanged(int)',
self.onYLogScaleRequested)
plotSettingsFrameLayout.addWidget(self.groupWidget, 2, 0)
# add chart container widget
self.__chartView = ctk.ctkVTKChartView(w)
plotFrameLayout.addWidget(self.__chartView, 3, 0, 1, 3)
self.__chart = self.__chartView.chart()
self.__chartTable = vtk.vtkTable()
self.__xArray = vtk.vtkFloatArray()
self.__yArray = vtk.vtkFloatArray()
# will crash if there is no name
self.__xArray.SetName('')
self.__yArray.SetName('signal intensity')
self.__chartTable.AddColumn(self.__xArray)
self.__chartTable.AddColumn(self.__yArray)
def setup(self):
self.imagesDirectory = "D:/w/data/DepthNetworkData/5/"
self.initializeButton = qt.QPushButton("Initialize")
self.initializeButton.clicked.connect(self.Initialize)
self.layout.addWidget(self.initializeButton)
imagesCollapseButton = ctk.ctkCollapsibleButton()
imagesCollapseButton.text = "Images"
self.layout.addWidget(imagesCollapseButton)
imagesLayout = qt.QHBoxLayout(imagesCollapseButton)
self.depthMapImageView = qt.QLabel()
self.RGBImageView = qt.QLabel()
self.depthMapImageView.resize(200, 200)
self.RGBImageView.resize(200, 200)
imagesLayout.addWidget(self.depthMapImageView)
imagesLayout.addWidget(self.RGBImageView)
self.RGBImageView.setSizePolicy(qt.QSizePolicy.MinimumExpanding,
qt.QSizePolicy.MinimumExpanding)
self.depthMapImageView.setSizePolicy(qt.QSizePolicy.MinimumExpanding,
qt.QSizePolicy.MinimumExpanding)
self.imageNumber = qt.QLabel("-")
self.layout.addWidget(self.imageNumber)
controlsWidget = qt.QWidget()
self.layout.addWidget(controlsWidget)
forwardsBackwardsLayout = qt.QHBoxLayout(controlsWidget)
self.backwardsButton = qt.QPushButton("<")
self.backwardsButton.clicked.connect(self.Backwards)
forwardsBackwardsLayout.addWidget(self.backwardsButton)
self.forwardsButton = qt.QPushButton(">")
self.forwardsButton.clicked.connect(self.Forwards)
forwardsBackwardsLayout.addWidget(self.forwardsButton)
self.focalLengthBox = ctk.ctkDoubleSpinBox()
self.focalLengthBox.maximum = 100000.0
self.focalLengthBox.minimum = 0.0
self.focalLengthBox.setValue(200.0)
self.layout.addWidget(self.focalLengthBox)
self.depthDividerBox = ctk.ctkDoubleSpinBox()
self.depthDividerBox.setValue(2.5)
self.depthDividerBox.maximum = 100000.0
self.depthDividerBox.minimum = 0.0
self.layout.addWidget(self.depthDividerBox)
self.pointCloudButton = qt.QPushButton("Create and render point cloud")
self.pointCloudButton.clicked.connect(self.OnConvertToPointCloud)
self.layout.addWidget(self.pointCloudButton)
inputsWidget = qt.QWidget()
self.layout.addWidget(inputsWidget)
inputsLayout = qt.QFormLayout(inputsWidget)
self.baseModelSelector = slicer.qMRMLNodeComboBox()
self.baseModelSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.baseModelSelector.selectNodeUponCreation = False
self.baseModelSelector.addEnabled = False
self.baseModelSelector.removeEnabled = True
self.baseModelSelector.renameEnabled = True
self.baseModelSelector.noneEnabled = False
self.baseModelSelector.showHidden = False
self.baseModelSelector.showChildNodeTypes = False
self.baseModelSelector.setMRMLScene(slicer.mrmlScene)
inputsLayout.addRow("Base Model: ", self.baseModelSelector)
self.pointCloudSelector = slicer.qMRMLNodeComboBox()
self.pointCloudSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.pointCloudSelector.selectNodeUponCreation = True
self.pointCloudSelector.addEnabled = True
self.pointCloudSelector.removeEnabled = True
self.pointCloudSelector.renameEnabled = True
self.pointCloudSelector.noneEnabled = False
self.pointCloudSelector.showHidden = False
self.pointCloudSelector.showChildNodeTypes = False
self.pointCloudSelector.setMRMLScene(slicer.mrmlScene)
inputsLayout.addRow("Point Cloud Model: ", self.pointCloudSelector)
self.booleanModelSelector = slicer.qMRMLNodeComboBox()
self.booleanModelSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.booleanModelSelector.selectNodeUponCreation = True
self.booleanModelSelector.addEnabled = True
self.booleanModelSelector.removeEnabled = True
self.booleanModelSelector.renameEnabled = True
self.booleanModelSelector.noneEnabled = False
self.booleanModelSelector.showHidden = False
self.booleanModelSelector.showChildNodeTypes = False
self.booleanModelSelector.setMRMLScene(slicer.mrmlScene)
inputsLayout.addRow("Boolean Model: ", self.booleanModelSelector)
self.transientModelSelector = slicer.qMRMLNodeComboBox()
self.transientModelSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.transientModelSelector.selectNodeUponCreation = True
self.transientModelSelector.addEnabled = True
self.transientModelSelector.removeEnabled = True
self.transientModelSelector.renameEnabled = True
self.transientModelSelector.noneEnabled = False
self.transientModelSelector.showHidden = False
self.transientModelSelector.showChildNodeTypes = False
self.transientModelSelector.setMRMLScene(slicer.mrmlScene)
inputsLayout.addRow("Transient Model: ", self.transientModelSelector)
self.transientTransformSelector = slicer.qMRMLNodeComboBox()
self.transientTransformSelector.nodeTypes = ((
"vtkMRMLLinearTransformNode"), "")
self.transientTransformSelector.selectNodeUponCreation = True
self.transientTransformSelector.addEnabled = True
self.transientTransformSelector.removeEnabled = True
self.transientTransformSelector.renameEnabled = True
self.transientTransformSelector.noneEnabled = False
self.transientTransformSelector.showHidden = False
self.transientTransformSelector.showChildNodeTypes = False
self.transientTransformSelector.setMRMLScene(slicer.mrmlScene)
inputsLayout.addRow("Transient Transform Node: ",
self.transientTransformSelector)
self.transformSelector = slicer.qMRMLNodeComboBox()
self.transformSelector.nodeTypes = (("vtkMRMLLinearTransformNode"), "")
self.transformSelector.selectNodeUponCreation = True
self.transformSelector.addEnabled = True
self.transformSelector.removeEnabled = True
self.transformSelector.renameEnabled = True
self.transformSelector.noneEnabled = False
self.transformSelector.showHidden = False
self.transformSelector.showChildNodeTypes = False
self.transformSelector.setMRMLScene(slicer.mrmlScene)
inputsLayout.addRow("Transform Node: ", self.transformSelector)
self.iterationsSpinBox = qt.QSpinBox()
self.iterationsSpinBox.setMaximum(50000)
self.iterationsSpinBox.setMinimum(100)
self.iterationsSpinBox.value = 1000
inputsLayout.addRow("Iterations: ", self.iterationsSpinBox)
self.landmarksSpinBox = qt.QSpinBox()
self.landmarksSpinBox.setMaximum(50000)
self.landmarksSpinBox.setMinimum(100)
self.landmarksSpinBox.value = 1000
inputsLayout.addRow("Landmarks: ", self.landmarksSpinBox)
self.booleanCheckBox = qt.QCheckBox()
self.booleanCheckBox.setChecked(False)
inputsLayout.addRow("Use boolean: ", self.booleanCheckBox)
self.registerButton = qt.QPushButton(
"Create, render, and register point cloud")
self.registerButton.clicked.connect(self.OnRegister)
self.layout.addWidget(self.registerButton)
spacer = qt.QSpacerItem(1, 14, qt.QSizePolicy.Expanding,
qt.QSizePolicy.Expanding)
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 = "ResectionVolume 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)
#
# Fiducial Selector
#
self.fiducialSelector = slicer.qMRMLNodeComboBox()
self.fiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "")
self.fiducialSelector.addEnabled = True
self.fiducialSelector.removeEnabled = False
self.fiducialSelector.noneEnabled = True
self.fiducialSelector.showHidden = False
self.fiducialSelector.renameEnabled = True
self.fiducialSelector.showChildNodeTypes = False
self.fiducialSelector.setMRMLScene(slicer.mrmlScene)
self.fiducialSelector.setToolTip(
"Select the fiducials to use for the resection area")
parametersFormLayout.addRow("Fiducial points: ", self.fiducialSelector)
#
# Resection model Selector
#
self.modelSelector = slicer.qMRMLNodeComboBox()
self.modelSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.modelSelector.addEnabled = True
self.modelSelector.removeEnabled = False
self.modelSelector.noneEnabled = True
self.modelSelector.showHidden = False
self.modelSelector.renameEnabled = True
self.modelSelector.selectNodeUponCreation = True
self.modelSelector.showChildNodeTypes = False
self.modelSelector.setMRMLScene(slicer.mrmlScene)
self.modelSelector.setToolTip("Choose the resection area model.")
parametersFormLayout.addRow("Resection area model: ",
self.modelSelector)
#
# Generate Button
#
self.generateSurface = qt.QCheckBox()
self.generateSurface.setToolTip("Generate the resection area surface")
self.generateSurface.checked = 0
parametersFormLayout.addRow("Generate resection surface",
self.generateSurface)
#
# Label Volume Selector
#
self.labelSelector = slicer.qMRMLNodeComboBox()
self.labelSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "")
self.labelSelector.addEnabled = False
self.labelSelector.removeEnabled = False
self.labelSelector.noneEnabled = True
self.labelSelector.showHidden = False
self.labelSelector.showChildNodeTypes = False
self.labelSelector.setMRMLScene(slicer.mrmlScene)
self.labelSelector.setToolTip("Choose the label map")
parametersFormLayout.addRow("Label map: ", self.labelSelector)
#
# Initial Label Value Selector
#
self.initialLabelValueSelector = qt.QSpinBox()
self.initialLabelValueSelector.setToolTip(
"Choose the value within the label map to recolor using the resection area"
)
self.initialLabelValueSelector.setValue(1)
parametersFormLayout.addRow("Label value for recoloring",
self.initialLabelValueSelector)
#
# Output Label Value Selector
#
self.outputLabelValueSelector = qt.QSpinBox()
self.outputLabelValueSelector.setToolTip(
"Choose the value to recolor the area within the resection to")
parametersFormLayout.addRow("Label value for resection area",
self.outputLabelValueSelector)
#
# Relabel button
#
self.recolorLabelButton = qt.QPushButton("Recolor label map")
self.recolorLabelButton.toolTip = "Recolor the label map to create a new label for the resection area."
self.recolorLabelButton.enabled = False
parametersFormLayout.addRow(self.recolorLabelButton)
#
# Connections
#
self.generateSurface.connect('toggled(bool)', self.onGenerateSurface)
self.fiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
self.modelSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
self.labelSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
self.recolorLabelButton.connect('clicked(bool)',
self.onRecolorLabelMap)
# Add vertical spacer
self.layout.addStretch(1)
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 = "LungRegistration 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 .vtk selector
#
self.inputVTKSelector = slicer.qMRMLNodeComboBox()
self.inputVTKSelector.nodeTypes = ( ("vtkMRMLModelNode"), "" )
self.inputVTKSelector.selectNodeUponCreation = True
self.inputVTKSelector.addEnabled = False
self.inputVTKSelector.removeEnabled = False
self.inputVTKSelector.noneEnabled = False
self.inputVTKSelector.showHidden = False
self.inputVTKSelector.showChildNodeTypes = False
self.inputVTKSelector.setMRMLScene( slicer.mrmlScene )
self.inputVTKSelector.setToolTip( "Pick the input convex hull to the algorithm." )
parametersFormLayout.addRow("Input .vtk atlas convex hull: ", self.inputVTKSelector)
#input CT image selector
self.inputSelector = slicer.qMRMLNodeComboBox()
self.inputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
#self.inputSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 0 )
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)
##
## atlas volume selector
##
self.atlasSelector = slicer.qMRMLNodeComboBox()
self.atlasSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
#self.leftAtlasSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 1 )
self.atlasSelector.selectNodeUponCreation = True
self.atlasSelector.addEnabled = False
self.atlasSelector.removeEnabled = False
self.atlasSelector.noneEnabled = False
self.atlasSelector.showHidden = False
self.atlasSelector.showChildNodeTypes = False
self.atlasSelector.setMRMLScene( slicer.mrmlScene )
self.atlasSelector.setToolTip( "Pick the atlas volume." )
parametersFormLayout.addRow("Atlas Volume: ", self.atlasSelector)
#
##
## right atlas volume selector
##
#self.rightAtlasSelector = slicer.qMRMLNodeComboBox()
#self.rightAtlasSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
##self.rightAtlasSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 2 )
#self.rightAtlasSelector.selectNodeUponCreation = True
#self.rightAtlasSelector.addEnabled = False
#self.rightAtlasSelector.removeEnabled = False
#self.rightAtlasSelector.noneEnabled = False
#self.rightAtlasSelector.showHidden = False
#self.rightAtlasSelector.showChildNodeTypes = False
#self.rightAtlasSelector.setMRMLScene( slicer.mrmlScene )
#self.rightAtlasSelector.setToolTip( "Pick the atlas volume." )
#parametersFormLayout.addRow("right Atlas Volume: ", self.rightAtlasSelector)
#
# output volume 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)
#Add parameters:
self.numberOfIterations = qt.QSpinBox()
self.numberOfIterations.setRange(1,1000000)
self.numberOfIterations.setValue(200)
self.numberOfIterations.setToolTip( "Specify the number of iterations to find the transformation." )
parametersFormLayout.addRow("Number of iterations (Registration part): ", self.numberOfIterations)
self.boneThreshold = qt.QSpinBox()
self.boneThreshold.setRange(1,1000000)
self.boneThreshold.setValue(600)
self.boneThreshold.setToolTip( "Threshold value for bone. Any voxel having HU intensity greater than or equal to this value will be considered bone and will be added to the fixed point set.." )
parametersFormLayout.addRow("Threshold value for bone (Registration part): ", self.boneThreshold)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Register")
self.applyButton.toolTip = "Run the registration 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)
self.inputVTKSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.atlasSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.boneThreshold.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
#self.rightAtlasSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
#self.outModel.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
#self.numberOfIterations.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
# Parent setup is commented out to not show reload&test in developer mode, as debugger is mostly used by developers
# but they are not interested in debugging this module.
# ScriptedLoadableModuleWidget.setup(self)
# Instantiate and connect widgets ...
# Settings Area
self.settingsCollapsibleButton = ctk.ctkCollapsibleButton()
self.settingsCollapsibleButton.text = "Settings"
self.settingsCollapsibleButton.collapsed = True
self.layout.addWidget(self.settingsCollapsibleButton)
settingsFormLayout = qt.QFormLayout(self.settingsCollapsibleButton)
# Debugger selector
self.debuggerSelector = qt.QComboBox()
self.debuggerSelector.toolTip = "Chose debugger server."
debugger = self.logic.getDebugger()
self.debuggerSelector.addItem("Eclipse")
self.debuggerSelector.addItem("PyCharm")
self.debuggerSelector.addItem("VisualStudio 2013/2015")
self.debuggerSelector.addItem("VisualStudio 2017")
self.debuggerSelector.addItem("VisualStudio Code")
if debugger == 'Eclipse':
self.debuggerSelector.currentIndex = 0
elif debugger == 'PyCharm':
self.debuggerSelector.currentIndex = 1
elif debugger == 'VisualStudio' or debugger == 'VisualStudio 2013/2015':
self.debuggerSelector.currentIndex = 2
elif debugger == 'VisualStudio 2017':
self.debuggerSelector.currentIndex = 3
elif debugger == 'VisualStudio Code':
self.debuggerSelector.currentIndex = 4
else:
self.debuggerSelector.currentIndex = -1
settingsFormLayout.addRow("Debugger: ", self.debuggerSelector)
self.debuggerSelector.connect('currentIndexChanged(int)',
self.onDebuggerSelected)
# pydevd.py path selector
pydevdDir = self.logic.getEclipsePydevdDir(
enableAutoDetect=(debugger == 'Eclipse'))
self.pydevdDirSelector = ctk.ctkPathLineEdit()
self.pydevdDirSelector.setCurrentPath(pydevdDir)
self.pydevdDirSelector.filters = self.pydevdDirSelector.Dirs
self.pydevdDirSelector.setMaximumWidth(300)
self.pydevdDirSelector.setToolTip(
"Set the path to pydevd.py. It is in the eclipse folder within plugins/...pydev.../pysrc."
)
self.pydevdDirLabel = qt.QLabel("Eclipse pydevd.py directory:")
settingsFormLayout.addRow(self.pydevdDirLabel, self.pydevdDirSelector)
# pycharm-debug.egg path selector
pyCharmDebugEggPath = self.logic.getPyCharmDebugEggPath(
enableAutoDetect=(debugger == 'PyCharm'))
self.pyCharmDebugEggPathSelector = ctk.ctkPathLineEdit()
self.pyCharmDebugEggPathSelector.setCurrentPath(pyCharmDebugEggPath)
self.pyCharmDebugEggPathSelector.nameFilters = ['pycharm-debug.egg']
self.pyCharmDebugEggPathSelector.setMaximumWidth(300)
self.pyCharmDebugEggPathSelector.setToolTip(
"Set the path to pycharm-debug.egg . It is in the .../PyCharm/debug-eggs folder."
)
self.pyCharmDebugEggPathLabel = qt.QLabel(
"PyCharm pycharm-debug.egg path:")
settingsFormLayout.addRow(self.pyCharmDebugEggPathLabel,
self.pyCharmDebugEggPathSelector)
# port number
self.portInputSpinBox = qt.QSpinBox()
self.portInputSpinBox.minimum = 0
self.portInputSpinBox.maximum = 65535
portNumber = self.logic.getPortNumber()
self.portInputSpinBox.setValue(int(portNumber))
settingsFormLayout.addRow("Port:", self.portInputSpinBox)
# ptvsd connection secret word
secret = self.logic.getSecret()
self.secretEditor = qt.QLineEdit()
self.secretEditor.text = secret
self.secretEditor.setToolTip(
"Set the secret word for VisualStudio remote debugger.")
self.secretLabel = qt.QLabel("Secret:")
settingsFormLayout.addRow(self.secretLabel, self.secretEditor)
if not self.isCurrentSettingValid():
self.settingsCollapsibleButton.collapsed = False
# Connection Area
connectionCollapsibleButton = ctk.ctkCollapsibleButton()
connectionCollapsibleButton.text = "Connection"
connectionCollapsibleButton.collapsed = False
self.layout.addWidget(connectionCollapsibleButton)
connectionFormLayout = qt.QFormLayout(connectionCollapsibleButton)
# Connect Button
self.connectButton = qt.QPushButton("Connect to debug server")
self.connectButton.toolTip = "Connect to remote debug server"
self.connectButton.setAutoFillBackground(True)
self.connectButton.setStyleSheet(
"background-color: rgb(150, 255, 150); color: rgb(0, 0, 0)")
connectionFormLayout.addRow(self.connectButton)
# Auto-connect button (only show after a successful connection to make sure
# Slicer does not hang on startup due to failed attempt to connect to debugger)
self.autoConnectCheckBox = qt.QCheckBox()
self.autoConnectCheckBox.visible = False
self.autoConnectCheckBox.checked = self.logic.getDebuggerAutoConnect()
self.autoConnectCheckBox.setToolTip(
"If checked, Slicer will attempt to connect to the remote debugger on startup."
)
self.autoConnectCheckBoxLabel = qt.QLabel(
"Auto-connect on next application startup:")
self.autoConnectCheckBoxLabel.visible = False
connectionFormLayout.addRow(self.autoConnectCheckBoxLabel,
self.autoConnectCheckBox)
if self.logic.isConnected():
# already connected
self.onConnectionComplete(True)
# Connections
self.connectButton.connect('clicked(bool)', self.onConnect)
self.autoConnectCheckBox.connect('toggled(bool)',
self.onAutoConnectChanged)
# Add vertical spacer
self.layout.addStretch(1)
self.onDebuggerSelected()
def setup(self):
# Instantiate and connect widgets ...
if self.developerMode:
#
# 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 = "VolumeProbe 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 All")
self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests."
reloadFormLayout.addWidget(self.reloadAndTestButton)
self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest)
# reload and run specific tests
scenarios = ("Three Volume", "View Watcher", "ROIManager",)
for scenario in scenarios:
button = qt.QPushButton("Reload and Test %s" % scenario)
self.reloadAndTestButton.toolTip = "Reload this module and then run the %s self test." % scenario
reloadFormLayout.addWidget(button)
button.connect('clicked()', lambda s=scenario: self.onReloadAndTest(scenario=s))
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
"""
#
# target volume selector
#
self.inputSelector = slicer.qMRMLNodeComboBox()
self.inputSelector.nodeTypes = ( ("vtkMRMLVolumeNode"), "" )
self.inputSelector.selectNodeUponCreation = True
self.inputSelector.addEnabled = False
self.inputSelector.removeEnabled = False
self.inputSelector.noneEnabled = False
self.inputSelector.showHidden = False
self.inputSelector.showChildNodeTypes = True
self.inputSelector.setMRMLScene( slicer.mrmlScene )
self.inputSelector.setToolTip( "Pick the input to the algorithm." )
parametersFormLayout.addRow("Target Volume: ", self.inputSelector)
"""
#
# Add ROI
#
self.drawROICheck = qt.QCheckBox()
parametersFormLayout.addRow("Draw ROI", self.drawROICheck)
self.drawROICheck.connect("toggled(bool)", self.onDrawROIToggled)
self.ROIRadiusSlider = ctk.ctkSliderWidget()
#self.ROIRadiusSlider.setMinimum(1)
#self.ROIRadiusSlider.setMaximum(100)
self.ROIRadiusSlider.setValue(self.ROIRadius)
parametersFormLayout.addRow("ROI Radius", self.ROIRadiusSlider)
self.ROIRadiusSlider.connect("valueChanged(double)", self.onROIRadiusChanged)
#
# Add Histogram
self.numBins = qt.QSpinBox()
self.numBins.setRange(0, 200)
self.numBins.setEnabled(1)
self.numBins.setValue(20)
parametersFormLayout.addRow("Number of Bins", self.numBins)
self.histogramArray = vtk.vtkDoubleArray()
self.histogramArray.SetNumberOfComponents(1)
self.histogramArray.SetNumberOfTuples(0)
self.histogram = ctk.ctkVTKHistogram()
self.histogram.setDataArray(self.histogramArray)
self.histogram.numberOfBins = self.numBins.value
self.histogramView = ctk.ctkTransferFunctionView()
self.histogramItem = ctk.ctkTransferFunctionBarsItem(self.histogram)
self.histogramItem.barWidth = 0.7
self.histogramView.scene().addItem(self.histogramItem)
parametersFormLayout.addRow("Histogram", self.histogramView)
self.histogramView.show()
self.minField = qt.QSpinBox()
self.minField.setRange(-100000, 100000)
self.minField.setEnabled(0)
parametersFormLayout.addRow("Min Value", self.minField)
self.maxField = qt.QSpinBox()
self.maxField.setRange(-100000, 100000)
self.maxField.setEnabled(0)
parametersFormLayout.addRow("Max Value", self.maxField)
self.meanField = qt.QSpinBox()
self.meanField.setRange(-100000, 100000)
self.meanField.setEnabled(0)
parametersFormLayout.addRow("Mean Value", self.meanField)
self.medianField = qt.QSpinBox()
self.medianField.setRange(-100000, 100000)
self.medianField.setEnabled(0)
parametersFormLayout.addRow("Median Value", self.medianField)
self.stdField = qt.QSpinBox()
self.stdField.setRange(-100000, 100000)
self.stdField.setEnabled(0)
parametersFormLayout.addRow("STD Value", self.stdField)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
# check if the SlicerVmtk module is installed properly
# self.__vmtkInstalled = SlicerVmtkCommonLib.Helper.CheckIfVmtkIsInstalled()
# Helper.Debug("VMTK found: " + self.__vmtkInstalled)
#
# the I/O panel
#
ioCollapsibleButton = ctk.ctkCollapsibleButton()
ioCollapsibleButton.text = "Input/Output"
self.layout.addWidget(ioCollapsibleButton)
ioFormLayout = qt.QFormLayout(ioCollapsibleButton)
# inputVolume selector
self.__inputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__inputVolumeNodeSelector.objectName = 'inputVolumeNodeSelector'
self.__inputVolumeNodeSelector.toolTip = "Select the input volume. This should always be the original image and not a vesselness image, if possible."
self.__inputVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__inputVolumeNodeSelector.noneEnabled = False
self.__inputVolumeNodeSelector.addEnabled = False
self.__inputVolumeNodeSelector.removeEnabled = False
self.__inputVolumeNodeSelector.addAttribute("vtkMRMLScalarVolumeNode",
"LabelMap", "0")
ioFormLayout.addRow("Input Volume:", self.__inputVolumeNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.__inputVolumeNodeSelector,
'setMRMLScene(vtkMRMLScene*)')
self.__inputVolumeNodeSelector.connect(
'currentNodeChanged(vtkMRMLNode*)', self.onInputVolumeChanged)
self.__inputVolumeNodeSelector.connect('nodeActivated(vtkMRMLNode*)',
self.onInputVolumeChanged)
# seed selector
self.__seedFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.__seedFiducialsNodeSelector.objectName = 'seedFiducialsNodeSelector'
self.__seedFiducialsNodeSelector.toolTip = "Select a hierarchy containing the fiducials to use as Seeds."
self.__seedFiducialsNodeSelector.nodeTypes = [
'vtkMRMLAnnotationHierarchyNode'
]
self.__seedFiducialsNodeSelector.baseName = "Seeds"
self.__seedFiducialsNodeSelector.noneEnabled = False
self.__seedFiducialsNodeSelector.addEnabled = False
self.__seedFiducialsNodeSelector.removeEnabled = False
ioFormLayout.addRow("Seeds:", self.__seedFiducialsNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.__seedFiducialsNodeSelector,
'setMRMLScene(vtkMRMLScene*)')
self.__ioAdvancedToggle = qt.QCheckBox("Show Advanced I/O Properties")
self.__ioAdvancedToggle.setChecked(False)
ioFormLayout.addRow(self.__ioAdvancedToggle)
#
# I/O advanced panel
#
self.__ioAdvancedPanel = qt.QFrame(ioCollapsibleButton)
self.__ioAdvancedPanel.hide()
self.__ioAdvancedPanel.setFrameStyle(6)
ioFormLayout.addRow(self.__ioAdvancedPanel)
self.__ioAdvancedToggle.connect("clicked()", self.onIOAdvancedToggle)
ioAdvancedFormLayout = qt.QFormLayout(self.__ioAdvancedPanel)
# inputVolume selector
self.__vesselnessVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__vesselnessVolumeNodeSelector.objectName = 'vesselnessVolumeNodeSelector'
self.__vesselnessVolumeNodeSelector.toolTip = "Select the input vesselness volume. This is optional input."
self.__vesselnessVolumeNodeSelector.nodeTypes = [
'vtkMRMLScalarVolumeNode'
]
self.__vesselnessVolumeNodeSelector.noneEnabled = True
self.__vesselnessVolumeNodeSelector.addEnabled = False
self.__vesselnessVolumeNodeSelector.removeEnabled = False
self.__vesselnessVolumeNodeSelector.addAttribute(
"vtkMRMLScalarVolumeNode", "LabelMap", "0")
ioAdvancedFormLayout.addRow("Vesselness Volume:",
self.__vesselnessVolumeNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.__vesselnessVolumeNodeSelector,
'setMRMLScene(vtkMRMLScene*)')
self.__vesselnessVolumeNodeSelector.setCurrentNode(None)
# stopper selector
self.__stopperFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.__stopperFiducialsNodeSelector.objectName = 'stopperFiducialsNodeSelector'
self.__stopperFiducialsNodeSelector.toolTip = "Select a hierarchy containing the fiducials to use as Stoppers. Whenever one stopper is reached, the segmentation stops."
self.__stopperFiducialsNodeSelector.nodeTypes = [
'vtkMRMLAnnotationHierarchyNode'
]
self.__stopperFiducialsNodeSelector.baseName = "Stoppers"
self.__stopperFiducialsNodeSelector.noneEnabled = False
self.__stopperFiducialsNodeSelector.addEnabled = True
self.__stopperFiducialsNodeSelector.removeEnabled = False
ioAdvancedFormLayout.addRow("Stoppers:",
self.__stopperFiducialsNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.__stopperFiducialsNodeSelector,
'setMRMLScene(vtkMRMLScene*)')
# outputVolume selector
self.__outputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__outputVolumeNodeSelector.toolTip = "Select the output labelmap."
self.__outputVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__outputVolumeNodeSelector.baseName = "LevelSetSegmentation"
self.__outputVolumeNodeSelector.noneEnabled = False
self.__outputVolumeNodeSelector.addEnabled = True
self.__outputVolumeNodeSelector.selectNodeUponCreation = True
self.__outputVolumeNodeSelector.addAttribute("vtkMRMLScalarVolumeNode",
"LabelMap", "1")
self.__outputVolumeNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow("Output Labelmap:",
self.__outputVolumeNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.__outputVolumeNodeSelector,
'setMRMLScene(vtkMRMLScene*)')
# outputModel selector
self.__outputModelNodeSelector = slicer.qMRMLNodeComboBox()
self.__outputModelNodeSelector.objectName = 'outputModelNodeSelector'
self.__outputModelNodeSelector.toolTip = "Select the output model."
self.__outputModelNodeSelector.nodeTypes = ['vtkMRMLModelNode']
self.__outputModelNodeSelector.baseName = "LevelSetSegmentationModel"
self.__outputModelNodeSelector.hideChildNodeTypes = [
'vtkMRMLAnnotationNode'
] # hide all annotation nodes
self.__outputModelNodeSelector.noneEnabled = False
self.__outputModelNodeSelector.addEnabled = True
self.__outputModelNodeSelector.selectNodeUponCreation = True
self.__outputModelNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow("Output Model:",
self.__outputModelNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.__outputModelNodeSelector,
'setMRMLScene(vtkMRMLScene*)')
#
# the segmentation panel
#
segmentationCollapsibleButton = ctk.ctkCollapsibleButton()
segmentationCollapsibleButton.text = "Segmentation"
self.layout.addWidget(segmentationCollapsibleButton)
segmentationFormLayout = qt.QFormLayout(segmentationCollapsibleButton)
# Threshold slider
thresholdLabel = qt.QLabel()
thresholdLabel.text = "Thresholding" + SlicerVmtkCommonLib.Helper.CreateSpace(
7)
thresholdLabel.toolTip = "Choose the intensity range to segment."
thresholdLabel.setAlignment(4)
segmentationFormLayout.addRow(thresholdLabel)
self.__thresholdSlider = slicer.qMRMLRangeWidget()
segmentationFormLayout.addRow(self.__thresholdSlider)
self.__thresholdSlider.connect('valuesChanged(double,double)',
self.onThresholdSliderChanged)
self.__segmentationAdvancedToggle = qt.QCheckBox(
"Show Advanced Segmentation Properties")
self.__segmentationAdvancedToggle.setChecked(False)
segmentationFormLayout.addRow(self.__segmentationAdvancedToggle)
#
# segmentation advanced panel
#
self.__segmentationAdvancedPanel = qt.QFrame(
segmentationCollapsibleButton)
self.__segmentationAdvancedPanel.hide()
self.__segmentationAdvancedPanel.setFrameStyle(6)
segmentationFormLayout.addRow(self.__segmentationAdvancedPanel)
self.__segmentationAdvancedToggle.connect(
"clicked()", self.onSegmentationAdvancedToggle)
segmentationAdvancedFormLayout = qt.QFormLayout(
self.__segmentationAdvancedPanel)
# inflation slider
inflationLabel = qt.QLabel()
inflationLabel.text = "less inflation <-> more inflation" + SlicerVmtkCommonLib.Helper.CreateSpace(
14)
inflationLabel.setAlignment(4)
inflationLabel.toolTip = "Define how fast the segmentation expands."
segmentationAdvancedFormLayout.addRow(inflationLabel)
self.__inflationSlider = ctk.ctkSliderWidget()
self.__inflationSlider.decimals = 0
self.__inflationSlider.minimum = -100
self.__inflationSlider.maximum = 100
self.__inflationSlider.singleStep = 10
self.__inflationSlider.toolTip = inflationLabel.toolTip
segmentationAdvancedFormLayout.addRow(self.__inflationSlider)
# curvature slider
curvatureLabel = qt.QLabel()
curvatureLabel.text = "less curvature <-> more curvature" + SlicerVmtkCommonLib.Helper.CreateSpace(
14)
curvatureLabel.setAlignment(4)
curvatureLabel.toolTip = "Choose a high curvature to generate a smooth segmentation."
segmentationAdvancedFormLayout.addRow(curvatureLabel)
self.__curvatureSlider = ctk.ctkSliderWidget()
self.__curvatureSlider.decimals = 0
self.__curvatureSlider.minimum = -100
self.__curvatureSlider.maximum = 100
self.__curvatureSlider.singleStep = 10
self.__curvatureSlider.toolTip = curvatureLabel.toolTip
segmentationAdvancedFormLayout.addRow(self.__curvatureSlider)
# attraction slider
attractionLabel = qt.QLabel()
attractionLabel.text = "less attraction to gradient <-> more attraction to gradient" + SlicerVmtkCommonLib.Helper.CreateSpace(
14)
attractionLabel.setAlignment(4)
attractionLabel.toolTip = "Configure how the segmentation travels towards gradient ridges (vessel lumen wall)."
segmentationAdvancedFormLayout.addRow(attractionLabel)
self.__attractionSlider = ctk.ctkSliderWidget()
self.__attractionSlider.decimals = 0
self.__attractionSlider.minimum = -100
self.__attractionSlider.maximum = 100
self.__attractionSlider.singleStep = 10
self.__attractionSlider.toolTip = attractionLabel.toolTip
segmentationAdvancedFormLayout.addRow(self.__attractionSlider)
# iteration spinbox
self.__iterationSpinBox = qt.QSpinBox()
self.__iterationSpinBox.minimum = 0
self.__iterationSpinBox.maximum = 5000
self.__iterationSpinBox.singleStep = 10
self.__iterationSpinBox.toolTip = "Choose the number of evolution iterations."
segmentationAdvancedFormLayout.addRow(
SlicerVmtkCommonLib.Helper.CreateSpace(100) + "Iterations:",
self.__iterationSpinBox)
#
# Reset, preview and apply buttons
#
self.__buttonBox = qt.QDialogButtonBox()
self.__resetButton = self.__buttonBox.addButton(
self.__buttonBox.RestoreDefaults)
self.__resetButton.toolTip = "Click to reset all input elements to default."
self.__previewButton = self.__buttonBox.addButton(
self.__buttonBox.Discard)
self.__previewButton.setIcon(qt.QIcon())
self.__previewButton.text = "Preview.."
self.__previewButton.toolTip = "Click to refresh the preview."
self.__startButton = self.__buttonBox.addButton(self.__buttonBox.Apply)
self.__startButton.setIcon(qt.QIcon())
self.__startButton.text = "Start!"
self.__startButton.enabled = False
self.__startButton.toolTip = "Click to start the filtering."
self.layout.addWidget(self.__buttonBox)
self.__resetButton.connect("clicked()", self.restoreDefaults)
self.__previewButton.connect("clicked()", self.onRefreshButtonClicked)
self.__startButton.connect("clicked()", self.onStartButtonClicked)
# be ready for events
self.__updating = 0
# set default values
self.restoreDefaults()
# compress the layout
self.layout.addStretch(1)
def setup(self):
# Instantiate and connect widgets ...
# 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 = "FiberBundleToLabelMap Reload"
self.layout.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."
self.layout.addWidget(self.reloadAndTestButton)
self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest)
# Collapsible button
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "A collapsible button"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the parameters collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
# fiber
self.fiberSelector = slicer.qMRMLNodeComboBox(
parametersCollapsibleButton)
self.fiberSelector.nodeTypes = (("vtkMRMLFiberBundleNode"), "")
self.fiberSelector.selectNodeUponCreation = False
self.fiberSelector.addEnabled = False
self.fiberSelector.removeEnabled = False
self.fiberSelector.noneEnabled = True
self.fiberSelector.showHidden = False
self.fiberSelector.showChildNodeTypes = False
self.fiberSelector.setMRMLScene(slicer.mrmlScene)
self.fiberSelector.setToolTip("Pick the fiber bundle to be converted.")
parametersFormLayout.addRow("Fiber Bundle", self.fiberSelector)
# label map
self.labelSelector = slicer.qMRMLNodeComboBox(
parametersCollapsibleButton)
self.labelSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "")
self.labelSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap",
1)
self.labelSelector.selectNodeUponCreation = False
self.labelSelector.addEnabled = False
self.labelSelector.removeEnabled = False
self.labelSelector.noneEnabled = True
self.labelSelector.showHidden = False
self.labelSelector.showChildNodeTypes = False
self.labelSelector.setMRMLScene(slicer.mrmlScene)
self.labelSelector.setToolTip("Pick the target label volume.")
parametersFormLayout.addRow("Target LabelMap", self.labelSelector)
# label value
self.labelValue = qt.QSpinBox(parametersCollapsibleButton)
self.labelValue.setToolTip(
"The numerical value for the rasterized fiber label.")
self.labelValue.setValue(1)
parametersFormLayout.addRow("Label Value", self.labelValue)
# apply
self.applyButton = qt.QPushButton(parametersCollapsibleButton)
self.applyButton.text = "Apply"
parametersFormLayout.addWidget(self.applyButton)
self.applyButton.connect('clicked()', self.onApply)
# Add vertical spacer
self.layout.addStretch(1)
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.logic = DualModalityCalibrationLogic()
# Instantiate and connect widgets
#
# Calibration Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Calibration input and output transforms"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# Optical tracking system transform selector
#
self.opticalPointerSelectorLabel = qt.QLabel()
self.opticalPointerSelectorLabel.setText(
"OpPointerToOpRef Transform: ")
self.opticalPointerSelector = slicer.qMRMLNodeComboBox()
self.opticalPointerSelector.nodeTypes = ([
"vtkMRMLLinearTransformNode"
])
self.opticalPointerSelector.noneEnabled = False
self.opticalPointerSelector.addEnabled = False
self.opticalPointerSelector.removeEnabled = True
self.opticalPointerSelector.setMRMLScene(slicer.mrmlScene)
self.opticalPointerSelector.setToolTip(
"Pick a known transform corresponding to the optical pointer's coordinate frame"
)
parametersFormLayout.addRow(self.opticalPointerSelectorLabel,
self.opticalPointerSelector)
#
# Em tracking system transform selector
#
self.EmPointerSelectorLabel = qt.QLabel()
self.EmPointerSelectorLabel.setText("EmPointerToEmTracker Transform: ")
self.emPointerSelector = slicer.qMRMLNodeComboBox()
self.emPointerSelector.nodeTypes = (["vtkMRMLTransformNode"])
self.emPointerSelector.noneEnabled = False
self.emPointerSelector.addEnabled = False
self.emPointerSelector.removeEnabled = True
self.emPointerSelector.setMRMLScene(slicer.mrmlScene)
self.emPointerSelector.setToolTip(
"Pick a known transform corresponding to the Em pointer's coordinate frame"
)
parametersFormLayout.addRow(self.EmPointerSelectorLabel,
self.emPointerSelector)
#
# Initial landmark registration result transform selector
#
self.initialEmTrackerToOpRefSelectorLabel = qt.QLabel()
self.initialEmTrackerToOpRefSelectorLabel.setText(
"Initial EmTrackerToOpRef Transform: ")
self.initialEmTrackerToOpRefSelector = slicer.qMRMLNodeComboBox()
self.initialEmTrackerToOpRefSelector.nodeTypes = ([
"vtkMRMLTransformNode"
])
self.initialEmTrackerToOpRefSelector.noneEnabled = False
self.initialEmTrackerToOpRefSelector.addEnabled = True
self.initialEmTrackerToOpRefSelector.removeEnabled = True
self.initialEmTrackerToOpRefSelector.baseName = "EmTrackerToOpRefInitial"
self.initialEmTrackerToOpRefSelector.setMRMLScene(slicer.mrmlScene)
self.initialEmTrackerToOpRefSelector.setToolTip(
"Pick a known transform corresponding to the Em pointer's coordinate frame"
)
parametersFormLayout.addRow(self.initialEmTrackerToOpRefSelectorLabel,
self.initialEmTrackerToOpRefSelector)
self.outputEmTrackerToOpRefTransformSelectorLabel = qt.QLabel(
"Output EmTrackerToOpRef transform: ")
self.outputEmTrackerToOpRefTransformSelector = slicer.qMRMLNodeComboBox(
)
self.outputEmTrackerToOpRefTransformSelector.nodeTypes = ([
"vtkMRMLTransformNode"
])
self.outputEmTrackerToOpRefTransformSelector.noneEnabled = True
self.outputEmTrackerToOpRefTransformSelector.addEnabled = True
self.outputEmTrackerToOpRefTransformSelector.removeEnabled = True
self.outputEmTrackerToOpRefTransformSelector.baseName = "EmTrackerToOpRef"
self.outputEmTrackerToOpRefTransformSelector.setMRMLScene(
slicer.mrmlScene)
self.outputEmTrackerToOpRefTransformSelector.setToolTip(
"Select the transform to output the EmTrackerToOpRef calibration result to"
)
parametersFormLayout.addRow(
self.outputEmTrackerToOpRefTransformSelectorLabel,
self.outputEmTrackerToOpRefTransformSelector)
self.outputEmPointerGtruthToOpPointerTransformSelectorLabel = qt.QLabel(
"Output EmPointerGtruthToOpPointer transform: ")
self.outputEmPointerGtruthToOpPointerTransformSelector = slicer.qMRMLNodeComboBox(
)
self.outputEmPointerGtruthToOpPointerTransformSelector.nodeTypes = ([
"vtkMRMLTransformNode"
])
self.outputEmPointerGtruthToOpPointerTransformSelector.noneEnabled = True
self.outputEmPointerGtruthToOpPointerTransformSelector.addEnabled = True
self.outputEmPointerGtruthToOpPointerTransformSelector.removeEnabled = True
self.outputEmPointerGtruthToOpPointerTransformSelector.baseName = "EmPointerGtruthToOpPointer"
self.outputEmPointerGtruthToOpPointerTransformSelector.setMRMLScene(
slicer.mrmlScene)
self.outputEmPointerGtruthToOpPointerTransformSelector.setToolTip(
"Select the transform to output the EmPointerGtruthToOpPointer calibration result to"
)
parametersFormLayout.addRow(
self.outputEmPointerGtruthToOpPointerTransformSelectorLabel,
self.outputEmPointerGtruthToOpPointerTransformSelector)
# Select defaults (to make debugging easier)
opPointerToOpRefNode = slicer.util.getNode('OpPointerToOpRef')
if opPointerToOpRefNode:
self.opticalPointerSelector.setCurrentNode(opPointerToOpRefNode)
emPointerToEmTrackerNode = slicer.util.getNode('EmPointerToEmTracker')
if emPointerToEmTrackerNode:
self.emPointerSelector.setCurrentNode(emPointerToEmTrackerNode)
emTrackerToOpRefInitialNode = slicer.util.getNode(
'EmTrackerToOpRefInitial')
if emTrackerToOpRefInitialNode:
self.initialEmTrackerToOpRefSelector.setCurrentNode(
emTrackerToOpRefInitialNode)
emTrackerToOpRefOutputNode = slicer.util.getNode('EmTrackerToOpRef')
if emTrackerToOpRefOutputNode:
self.outputEmTrackerToOpRefTransformSelector.setCurrentNode(
emTrackerToOpRefOutputNode)
emPointerGtruthToOpPointerOutputNode = slicer.util.getNode(
'EmPointerGtruthToOpPointer')
if emPointerGtruthToOpPointerOutputNode:
self.outputEmPointerGtruthToOpPointerTransformSelector.setCurrentNode(
emPointerGtruthToOpPointerOutputNode)
#
# Controls Area
#
controlsCollapsibleButton = ctk.ctkCollapsibleButton()
controlsCollapsibleButton.text = "Controls"
self.layout.addWidget(controlsCollapsibleButton)
# Layout within the dummy collapsible button
controlsFormLayout = qt.QFormLayout(controlsCollapsibleButton)
#
# Number of data points to be collected input
#
self.numberDataPointsInputLabel = qt.QLabel()
self.numberDataPointsInputLabel.setText(
"Number of Collected Data Points:")
self.numberDataPointsInput = qt.QSpinBox()
self.numberDataPointsInput.maximum = 5000
self.numberDataPointsInput.minimum = 10
self.numberDataPointsInputLabel.setToolTip(
"Select how many sample points will be used in calculations")
controlsFormLayout.addRow(self.numberDataPointsInputLabel,
self.numberDataPointsInput)
#self.numberDataPoints = self.numberDataPointsInput.value
#
# Delay spinbox
#
self.delaySelectorLabel = qt.QLabel()
self.delaySelectorLabel.setText("Delay (seconds):")
self.delaySelector = qt.QSpinBox()
self.delaySelector.minimum = 1
self.delaySelector.maximum = 10
self.delaySelector.value = 5
self.delaySelector.setToolTip(
"Time to wait before starting data collection after clicking 'Start data collection' button"
)
controlsFormLayout.addRow(self.delaySelectorLabel, self.delaySelector)
#
# Start data collection button
#
self.startButton = qt.QPushButton("Start data collection")
self.startButton.toolTip = "Start collecting data that will be used in calculations"
self.startButton.enabled = True
self.startButton.connect('clicked(bool)', self.onStartDataCollection)
controlsFormLayout.addRow(self.startButton)
#
# Delay countdown timer
#
self.delayTimer = qt.QTimer()
self.delayTimerLabel = qt.QLabel()
self.delayTimer.setInterval(1000) # 1 second
self.delayTimer.setSingleShot(True)
self.delayTimer.connect('timeout()', self.onDelayTimerTimeout)
controlsFormLayout.addRow(self.delayTimerLabel)
#
# Data collection progress bar
#
self.collectionProgressBar = qt.QProgressBar()
self.collectionProgressBar.setRange(0, 100)
self.collectionProgressBar.setVisible(False)
controlsFormLayout.addRow(self.collectionProgressBar)
#
# Display Area
#
displayCollapsibleButton = ctk.ctkCollapsibleButton()
displayCollapsibleButton.text = "Calibration results"
self.layout.addWidget(displayCollapsibleButton)
# Layout within the dummy collapsible button
displayFormLayout = qt.QFormLayout(displayCollapsibleButton)
#
# Error metrics
#
self.transErrorLabel = qt.QLabel("Position error: N/A")
self.rotErrorLabel = qt.QLabel("Orientation error: N/A")
displayFormLayout.addRow(self.transErrorLabel)
displayFormLayout.addRow(self.rotErrorLabel)
# Add vertical spacer
self.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 ...
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
transformWarningLabel = qt.QLabel( "Note: Parent transforms of models are not used. Models should be defined in the coordinate system that is being registered." )
transformWarningLabel.setWordWrap( True )
parametersFormLayout.addRow(transformWarningLabel)
#
# input target (fixed, dense) model selector
#
self.inputTargetModelSelector = slicer.qMRMLNodeComboBox()
self.inputTargetModelSelector.nodeTypes = ( ("vtkMRMLModelNode"), "" )
self.inputTargetModelSelector.selectNodeUponCreation = True
self.inputTargetModelSelector.addEnabled = False
self.inputTargetModelSelector.removeEnabled = False
self.inputTargetModelSelector.noneEnabled = False
self.inputTargetModelSelector.showHidden = False
self.inputTargetModelSelector.showChildNodeTypes = False
self.inputTargetModelSelector.setMRMLScene( slicer.mrmlScene )
self.inputTargetModelSelector.setToolTip( "Select the model the other will be transformed to. This model required to contain a dense set of points." )
parametersFormLayout.addRow("Input fixed (dense) model: ", self.inputTargetModelSelector)
#
# input source (moving) model selector
#
self.inputSourceModelSelector = slicer.qMRMLNodeComboBox()
self.inputSourceModelSelector.nodeTypes = ( ("vtkMRMLModelNode"), "" )
self.inputSourceModelSelector.selectNodeUponCreation = True
self.inputSourceModelSelector.addEnabled = False
self.inputSourceModelSelector.removeEnabled = False
self.inputSourceModelSelector.noneEnabled = False
self.inputSourceModelSelector.showHidden = False
self.inputSourceModelSelector.showChildNodeTypes = False
self.inputSourceModelSelector.setMRMLScene( slicer.mrmlScene )
self.inputSourceModelSelector.setToolTip( "Select the model that will be transformed. This model may require a sparse set of points." )
parametersFormLayout.addRow("Input moving (sparse) model: ", self.inputSourceModelSelector)
#
# output transform selector
#
self.outputSourceToTargetTransformSelector = slicer.qMRMLNodeComboBox()
self.outputSourceToTargetTransformSelector.nodeTypes = ( ("vtkMRMLLinearTransformNode"), "" )
self.outputSourceToTargetTransformSelector.selectNodeUponCreation = True
self.outputSourceToTargetTransformSelector.addEnabled = True
self.outputSourceToTargetTransformSelector.removeEnabled = True
self.outputSourceToTargetTransformSelector.noneEnabled = False
self.outputSourceToTargetTransformSelector.showHidden = False
self.outputSourceToTargetTransformSelector.showChildNodeTypes = False
self.outputSourceToTargetTransformSelector.renameEnabled = True
self.outputSourceToTargetTransformSelector.setMRMLScene( slicer.mrmlScene )
self.outputSourceToTargetTransformSelector.setToolTip( "Pick the moving to fixed transform computed by the algorithm." )
parametersFormLayout.addRow("Output transform: ", self.outputSourceToTargetTransformSelector)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
#
# Output panel
#
outputCollapsibleButton = ctk.ctkCollapsibleButton()
outputCollapsibleButton.text = "Output"
self.layout.addWidget( outputCollapsibleButton )
outputFormLayout = qt.QFormLayout( outputCollapsibleButton )
self.outputLine = qt.QLineEdit()
self.outputLine.setReadOnly( True )
outputFormLayout.addRow( "Mean distance after registration:", self.outputLine )
#
# Advanced parameters
#
advancedCollapsibleButton = ctk.ctkCollapsibleButton()
advancedCollapsibleButton.text = "Advanced"
self.layout.addWidget(advancedCollapsibleButton)
# Layout
advancedCollapsibleButton.collapsed = True
advancedFormLayout = qt.QFormLayout(advancedCollapsibleButton)
#
# Transform type selector
#
self.typeSelector = qt.QComboBox()
self.typeSelector.insertItem( 0, "Rigid" )
self.typeSelector.insertItem( 1, "Similarity" )
self.typeSelector.insertItem( 2, "Affine" )
advancedFormLayout.addRow("Transform type: ", self.typeSelector)
#
# Iteration selector
#
self.iterationSpin = qt.QSpinBox()
self.iterationSpin.setMaximum( 1000 )
self.iterationSpin.setValue( 100 )
advancedFormLayout.addRow("Number of iterations:", self.iterationSpin)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputTargetModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.inputSourceModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.outputSourceToTargetTransformSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
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 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 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 = "CMRToolkitRegistration Reload"
self.layout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
# Register Volume collapsible button
collapsibleButton = ctk.ctkCollapsibleButton()
collapsibleButton.text = "Register Volume"
self.layout.addWidget(collapsibleButton)
# Layout within the dummy collapsible button
formLayout = qt.QFormLayout(collapsibleButton)
# The image volume selectors
self.fixedFrame = qt.QFrame(collapsibleButton)
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(collapsibleButton)
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(collapsibleButton)
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(collapsibleButton)
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("Image volumes are cropped to area around LA", collapsibleButton)
self.cropCheckBox.toolTip = "For best registration, indicate whether the volumes have been cropped to the LA 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")
registerButton.toolTip = "Register Volume Two (Moving) onto Volume One (Fixed)."
formLayout.addWidget(registerButton)
registerButton.connect('clicked(bool)', self.onRegisterButtonClicked)
# Advanced Registration Parameters collapsible button
collapsibleButton2 = ctk.ctkCollapsibleButton()
collapsibleButton2.text = "Advanced Registration Parameters"
collapsibleButton2.collapsedHeight = 350
collapsibleButton2.collapsed = True
self.layout.addWidget(collapsibleButton2)
formLayout2 = qt.QFormLayout(collapsibleButton2)
# Registration options
self.regnFrame = qt.QFrame(collapsibleButton2)
self.regnFrame.setLayout(qt.QHBoxLayout())
formLayout2.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.addItem("PipelineRigid")
self.regnComboBox.addItem("PipelineAffine")
self.regnComboBox.addItem("PipelineBSpline")
self.regnComboBox.setCurrentIndex(-1)
self.regnFrame.layout().addWidget(self.regnComboBox)
# Metric options
self.metFrame = qt.QFrame(collapsibleButton2)
self.metFrame.setLayout(qt.QHBoxLayout())
formLayout2.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("MattesMI")
self.metComboBox.addItem("NormCorr")
self.metComboBox.addItem("MeanSqrd")
self.metComboBox.setCurrentIndex(-1)
self.metFrame.layout().addWidget(self.metComboBox)
# Initialization options
self.initFrame = qt.QFrame(collapsibleButton2)
self.initFrame.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.initFrame)
self.initSelector = qt.QLabel("Select the Type of Initialization: ", self.initFrame)
self.initFrame.layout().addWidget(self.initSelector)
self.initComboBox = qt.QComboBox()
self.initComboBox.setLayout(qt.QHBoxLayout())
self.initComboBox.addItem("ImageCenters")
self.initComboBox.addItem("CentersOfMass")
self.initComboBox.addItem("SecondMoments")
self.initComboBox.setCurrentIndex(-1)
self.initFrame.layout().addWidget(self.initComboBox)
# Interpolation options
self.interpFrame = qt.QFrame(collapsibleButton2)
self.interpFrame.setLayout(qt.QHBoxLayout())
formLayout2.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.setCurrentIndex(-1)
self.interpFrame.layout().addWidget(self.interpComboBox)
# Maximum number of iterations
self.iterFrame = qt.QFrame(collapsibleButton2)
self.iterFrame.setLayout(qt.QHBoxLayout())
formLayout2.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)
# Sampling Ratio Slider
self.sampframe = qt.QFrame(collapsibleButton2)
self.sampframe.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.sampframe)
self.sampSliderSelector = qt.QLabel("Sampling Ratio (Accuracy of Registration): ", self.sampframe)
self.sampframe.layout().addWidget(self.sampSliderSelector)
self.sampSliderFrame = ctk.ctkSliderWidget()
self.sampSliderFrame.minimum = 0
self.sampSliderFrame.maximum = 1
self.sampSliderFrame.decimals = 2
self.sampSliderFrame.singleStep = 0.01
self.sampframe.layout().addWidget(self.sampSliderFrame)
# Sample from fixed/moving overlap check box
self.sampleCheckBox = qt.QCheckBox("Sample from fixed/moving image overlap", collapsibleButton2)
self.sampleCheckBox.toolTip = "Limit metric evaluation to the fixed image region overlapped by the moving image"
formLayout2.addWidget(self.sampleCheckBox)
# Set local var as instance attribute
self.registerButton = registerButton
def setup(self):
self.vtkSelectorFrame = qt.QFrame(self.parent)
self.vtkSelectorFrame.setLayout(qt.QHBoxLayout())
self.parent.layout().addWidget(self.vtkSelectorFrame)
self.vtkSelectorLabel = qt.QLabel("Input Fiber Bundle: ",
self.vtkSelectorFrame)
self.vtkSelectorFrame.layout().addWidget(self.vtkSelectorLabel)
self.vtkSelector = slicer.qMRMLNodeComboBox(self.vtkSelectorFrame)
self.vtkSelector.nodeTypes = ("vtkMRMLFiberBundleNode",
"vtkMRMLFiberBundleNode")
self.vtkSelector.selectNodeUponCreation = False
self.vtkSelector.addEnabled = False
self.vtkSelector.removeEnabled = False
self.vtkSelector.noneEnabled = True
self.vtkSelector.setMRMLScene(slicer.mrmlScene)
self.vtkSelector.setToolTip("Select the Fiber Bundle to filter")
self.vtkSelectorFrame.layout().addWidget(self.vtkSelector)
self.outputSelectorFrame = qt.QFrame(self.parent)
self.outputSelectorFrame.setLayout(qt.QHBoxLayout())
self.parent.layout().addWidget(self.outputSelectorFrame)
self.outputSelectorLabel = qt.QLabel("Output Fiber Bundle: ",
self.outputSelectorFrame)
self.outputSelectorFrame.layout().addWidget(self.outputSelectorLabel)
self.outputSelector = slicer.qMRMLNodeComboBox(
self.outputSelectorFrame)
self.outputSelector.nodeTypes = ("vtkMRMLFiberBundleNode",
"vtkMRMLFiberBundleNode")
self.outputSelector.selectNodeUponCreation = False
self.outputSelector.addEnabled = True
self.outputSelector.removeEnabled = True
self.outputSelector.noneEnabled = True
self.outputSelector.setMRMLScene(slicer.mrmlScene)
self.outputSelector.setToolTip("Select the output Fiber Bundle")
self.outputSelectorFrame.layout().addWidget(self.outputSelector)
self.thresholdFrame = qt.QFrame(self.parent)
self.thresholdFrame.setLayout(qt.QHBoxLayout())
self.parent.layout().addWidget(self.thresholdFrame)
self.thresholdMinLabel = qt.QLabel("Min: ", self.thresholdFrame)
self.thresholdFrame.layout().addWidget(self.thresholdMinLabel)
self.thresholdMin = qt.QSpinBox(self.thresholdFrame)
self.thresholdMin.setSingleStep(1)
self.thresholdMin.setRange(0, 1000)
self.thresholdMin.setValue(0)
self.thresholdMin.enabled = False
self.thresholdFrame.layout().addWidget(self.thresholdMin)
self.thresholdMaxLabel = qt.QLabel("Max: ", self.thresholdFrame)
self.thresholdFrame.layout().addWidget(self.thresholdMaxLabel)
self.thresholdMax = qt.QSpinBox(self.thresholdFrame)
self.thresholdMax.setSingleStep(1)
self.thresholdMax.setRange(0, 1000)
self.thresholdMax.setValue(1)
self.thresholdMax.enabled = False
self.thresholdFrame.layout().addWidget(self.thresholdMax)
self.calculateLengthButton = qt.QPushButton("Calculate Length Stats")
self.calculateLengthButton.enabled = False
self.parent.layout().addWidget(self.calculateLengthButton)
self.applyThresholdButton = qt.QPushButton("Apply Min-Max Threshold")
self.applyThresholdButton.enabled = False
self.parent.layout().addWidget(self.applyThresholdButton)
self.parent.layout().addStretch(1)
self.calculateLengthButton.connect('clicked()', self.onCalculateLength)
self.applyThresholdButton.connect('clicked()', self.onApplyThreshold)
self.vtkSelector.connect('nodeActivated(vtkMRMLNode*)',
self.onVtkSelect)
self.outputSelector.connect('nodeActivated(vtkMRMLNode*)',
self.onOutputSelect)
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)
