def create(self, registrationState):
"""Make the plugin-specific user interface"""
super(LocalBRAINSFitPlugin, self).create(registrationState)
self.LocalBRAINSFitMode = "Small"
self.VerboseMode = "Quiet"
#
# Local Refinment Pane - initially hidden
# - interface options for linear registration
#
localBRAINSFitCollapsibleButton = ctk.ctkCollapsibleButton()
localBRAINSFitCollapsibleButton.text = "Local BRAINSFit"
localBRAINSFitFormLayout = qt.QFormLayout()
localBRAINSFitCollapsibleButton.setLayout(localBRAINSFitFormLayout)
self.widgets.append(localBRAINSFitCollapsibleButton)
buttonGroup = qt.QButtonGroup()
self.widgets.append(buttonGroup)
buttonLayout = qt.QVBoxLayout()
localBRAINSFitModeButtons = {}
self.LocalBRAINSFitModes = ("Small", "Large")
for mode in self.LocalBRAINSFitModes:
localBRAINSFitModeButtons[mode] = qt.QRadioButton()
localBRAINSFitModeButtons[mode].text = mode
localBRAINSFitModeButtons[mode].setToolTip(
"Run the refinement in a %s local region." % mode.lower())
buttonLayout.addWidget(localBRAINSFitModeButtons[mode])
buttonGroup.addButton(localBRAINSFitModeButtons[mode])
self.widgets.append(localBRAINSFitModeButtons[mode])
localBRAINSFitModeButtons[mode].connect(
'clicked()', lambda m=mode: self.onLocalBRAINSFitMode(m))
localBRAINSFitModeButtons[self.LocalBRAINSFitMode].checked = True
localBRAINSFitFormLayout.addRow("Local BRAINSFit Mode ", buttonLayout)
buttonGroup = qt.QButtonGroup()
self.widgets.append(buttonGroup)
buttonLayout = qt.QVBoxLayout()
verboseModeButtons = {}
self.VerboseModes = ("Quiet", "Verbose")
for mode in self.VerboseModes:
verboseModeButtons[mode] = qt.QRadioButton()
verboseModeButtons[mode].text = mode
verboseModeButtons[mode].setToolTip(
"Run the refinement in %s mode." % mode.lower())
buttonLayout.addWidget(verboseModeButtons[mode])
buttonGroup.addButton(verboseModeButtons[mode])
self.widgets.append(verboseModeButtons[mode])
verboseModeButtons[mode].connect(
'clicked()', lambda m=mode: self.onVerboseMode(m))
verboseModeButtons[self.VerboseMode].checked = True
localBRAINSFitFormLayout.addRow("Verbose Mode ", buttonLayout)
self.parent.layout().addWidget(localBRAINSFitCollapsibleButton)
def setup(self):
""" Setup all UI elements and prepare data """
# TODO: following line is only for the purpose of testing
self._loadedVolumeNodes = OrderedDict({volume.GetID: volume for volume
in slicer.util.getNodesByClass('vtkMRMLScalarVolumeNode')})
ScriptedLoadableModuleWidget.setup(self)
self._setupPatientWatchBox()
self._setupViewSettingGroupBox()
self._setupCollapsibleLayoutButton()
self._patientAssessmentWidget = AssessmentWidget(forms=self.getSetting("Patient_Assessment_Forms"),
title="Patient Level Assessment")
self._studyAssessmentWidget = AssessmentWidget(forms=self.getSetting("Study_Assessment_Forms"),
title="Study Level Assessment")
self._prostateMeasurementsWidget = ProstateWidget()
self._findingsWidget = FindingsWidget(maximumNumber=4)
self._exportToHTMLButton = UICreationHelpers.createButton("Export to HTML")
self.layout.addWidget(self._collapsibleLayoutButton)
self._setupCollapsibleMultiVolumeExplorerButton()
self.layout.addWidget(self._collapsibleMultiVolumeButton)
self.layout.addWidget(self._patientAssessmentWidget)
self.layout.addWidget(self._studyAssessmentWidget)
self.layout.addWidget(self._prostateMeasurementsWidget)
self.layout.addWidget(self._findingsWidget)
self.layout.addWidget(self._exportToHTMLButton)
self._stepButtonGroup = qt.QButtonGroup()
self._stepButtonGroup.addButton(self._patientAssessmentWidget, 1)
self._stepButtonGroup.addButton(self._studyAssessmentWidget, 2)
self._stepButtonGroup.addButton(self._prostateMeasurementsWidget, 3)
self._stepButtonGroup.addButton(self._findingsWidget, 4)
self.layout.addStretch(1)
self._setupConnections()
self.updateGUIFromData()
def setup(self):
self.setLayout(qt.QGridLayout())
self.statusLabel = qt.QLabel("Status:")
self.textLabel = qt.QLabel()
self.layout().addWidget(self.statusLabel, 0, 0)
self.layout().addWidget(self.textLabel, 0, 1, 1, 2)
self.progress = qt.QProgressBar()
self.progress.maximum = 0
self.progress.setAlignment(qt.Qt.AlignCenter)
self.layout().addWidget(self.progress, 1, 0, 1, qt.QSizePolicy.Maximum)
self.buttonGroup = qt.QButtonGroup()
self.skipButton = self.createButton(self.skipButtonText)
self.cancelButton = self.createButton(self.cancelButtonText)
self.directoryImportButton = self.createDirectoryButton(
text="Import from directory",
caption="Choose directory to import DICOM data from")
self.buttonGroup.addButton(self.skipButton)
self.buttonGroup.addButton(self.cancelButton)
self.layout().addWidget(self.skipButton, 2, 0)
self.layout().addWidget(self.cancelButton, 2, 1)
self.layout().addWidget(self.directoryImportButton, 2, 2)
buttonHeight = 30
for b in [
self.skipButton, self.cancelButton, self.directoryImportButton
]:
b.minimumHeight = buttonHeight
self.setupConnections()
def open_radio(self, cmd=None, title=None, name=None):
self.group.append([
qt.QButtonGroup(1, qt.QGroupBox.Horizontal, title,
self.group[-1][0]), -1
])
self.mode.append('v')
self.transistors.append(___qttransistor___(cmd))
if name:
setattr(self, name, self.transistors[-1])
def setupRegistrationResultButtons(self):
self.rigidResultButton = self.createButton('Rigid', checkable=True, name='rigid')
self.affineResultButton = self.createButton('Affine', checkable=True, name='affine')
self.bSplineResultButton = self.createButton('BSpline', checkable=True, name='bSpline')
self.registrationButtonGroup = qt.QButtonGroup()
self.registrationButtonGroup.addButton(self.rigidResultButton, 1)
self.registrationButtonGroup.addButton(self.affineResultButton, 2)
self.registrationButtonGroup.addButton(self.bSplineResultButton, 3)
self.registrationTypesGroupBox = qt.QGroupBox("Type")
self.registrationTypesGroupBoxLayout = qt.QFormLayout(self.registrationTypesGroupBox)
self.registrationTypesGroupBoxLayout.addWidget(self.createVLayout([self.rigidResultButton,
self.affineResultButton,
self.bSplineResultButton]))
def setup(self):
self.setLayout(qt.QVBoxLayout())
self.deviceButtonGroup = qt.QButtonGroup()
self.deviceButtonGroup.setExclusive(True)
vBoxDeviceButtonGroup = qt.QWidget()
vBoxDeviceButtonGroup.setLayout(qt.QGridLayout())
numberOfColumns = 4 if len(self.registeredDeviceClasses) < 5 or len(self.registeredDeviceClasses) > 6 else 3
for currentWidgetIndex, deviceClass in enumerate(self.registeredDeviceClasses):
deviceWidgetButton = self.createDeviceButton(deviceClass)
self.deviceWidgetFrames[deviceClass.ID] = DeviceImplantWidget(deviceClass)
self.deviceButtonGroup.addButton(deviceWidgetButton)
vBoxDeviceButtonGroup.layout().addWidget(deviceWidgetButton,
int(currentWidgetIndex/numberOfColumns), currentWidgetIndex % numberOfColumns)
self.deviceButtonGroup.connect('buttonClicked(QAbstractButton*)', self.onSwitchDevice)
self.layout().addWidget(vBoxDeviceButtonGroup)
def show(self):
for item in self._mpvbox.children():
if isinstance(item, qt.QWidget):
self._mpvbox.removeChild(item)
del item
self._mp = None
group = qt.QButtonGroup(None, "mp")
n = 0
for media in iface.getControl().getMediaSet():
mp = media.getMountPoint()
if not self._mp:
self._mp = mp
qt.QObject.connect(radio, qt.SIGNAL("clicked()"), self.ok)
radio = qt.QRadioButton(mp, self._mpvbox)
group.insert(radio)
act = RadioAction(radio, mp)
act.connect(self, "_mp", mp)
radio.show()
n += 1
if n == 0:
iface.error(_("No local media found!"))
return None
elif n == 1:
return self._mp
self._window.show()
self._window.raiseW()
mp = None
while True:
self._result = self._window.exec_loop()
if self._result == qt.QDialog.Accepted:
mp = self._mp
break
mp = None
break
self._window.hide()
return mp
def setup(self):
"""
Called when the user opens the module the first time and the widget is initialized.
"""
ScriptedLoadableModuleWidget.setup(self)
# Load widget from .ui file (created by Qt Designer)
uiWidget = slicer.util.loadUI(
self.resourcePath('UI/RegistrationBasedCorrespondence.ui'))
self.layout.addWidget(uiWidget)
self.ui = slicer.util.childWidgetVariables(uiWidget)
self.methodButtonGroup = qt.QButtonGroup()
self.methodButtonGroup.setExclusive(True)
self.methodButtonGroup.addButton(self.ui.DiffeoButton)
self.methodButtonGroup.addButton(self.ui.BSplineButton)
self.logic = RegistrationBasedCorrespondenceLogic()
self.ui.ApplyButton.connect('clicked(bool)', self.onApplyButton)
def setup(self):
"""This is called one time when the module GUI is initialized
"""
CIP_ParenchymaSubtypeTrainingWidget.setup(self)
self.volumeSelectionLayout.addRow("Slice size:", None)
self.sliceSelectionRadioButtonGroup = qt.QButtonGroup()
for id in range(len(self.sliceMeasurements)):
button = qt.QRadioButton("{} mm".format(
self.sliceMeasurements[id]))
self.sliceSelectionRadioButtonGroup.addButton(button, id)
self.volumeSelectionLayout.addRow("", button)
# Add button for reslicing
self.resliceButton = qt.QPushButton("Reslice")
self.volumeSelectionLayout.addRow("", self.resliceButton)
self.resliceButton.connect('clicked()',
self.__onResliceButtonClicked__)
# Select by default the airway type
self.typesRadioButtonGroup.buttons()[2].setChecked(True)
self.updateState()
def setupElements(self):
self.layout().addWidget(qt.QLabel(self.text), 0, 0)
self.ratingButtonGroup = qt.QButtonGroup()
for rateValue in range(1, self.maximumValue + 1):
attributeName = "button" + str(rateValue)
setattr(self, attributeName,
self.createButton('', icon=self.unfilledStarIcon))
self.ratingButtonGroup.addButton(getattr(self, attributeName),
rateValue)
for button in list(self.ratingButtonGroup.buttons()):
button.setCursor(qt.Qt.PointingHandCursor)
self.ratingLabel = self.createLabel("")
row = self.createHLayout(
list(self.ratingButtonGroup.buttons()) + [self.ratingLabel])
self.layout().addWidget(row, 1, 0)
self.disableWidgetCheckbox = qt.QCheckBox(
"Don't display this window again")
self.disableWidgetCheckbox.checked = False
self.layout().addWidget(self.disableWidgetCheckbox, 2, 0)
def setupOptionsFrame(self):
# Load widget from .ui file. This .ui file can be edited using Qt Designer
# (Edit / Application Settings / Developer / Qt Designer -> launch).
uiWidget = slicer.util.loadUI(
os.path.join(os.path.dirname(__file__), "SegmentEditorEffect.ui"))
self.scriptedEffect.addOptionsWidget(uiWidget)
self.ui = slicer.util.childWidgetVariables(uiWidget)
# Set scene in MRML widgets. Make sure that in Qt designer
# "mrmlSceneChanged(vtkMRMLScene*)" signal in is connected to each MRML widget's.
# "setMRMLScene(vtkMRMLScene*)" slot.
uiWidget.setMRMLScene(slicer.mrmlScene)
# Order of buttons in the buttongroup must be the same order as the corresponding
# options in ARG_OPTIONS[].
self.ui.regionGroup = qt.QButtonGroup()
self.ui.regionGroup.addButton(self.ui.regionOuterSurfaceRadioButton)
self.ui.regionGroup.addButton(self.ui.regionLargestCavityRadioButton)
self.ui.regionGroup.addButton(self.ui.regionSegmentRadioButton)
self.ui.shellOffsetDirectionGroup = qt.QButtonGroup()
self.ui.shellOffsetDirectionGroup.addButton(
self.ui.shellOffsetInsideRadioButton)
self.ui.shellOffsetDirectionGroup.addButton(
self.ui.shellOffsetOutsideRadioButton)
self.ui.outputTypeGroup = qt.QButtonGroup()
self.ui.outputTypeGroup.addButton(self.ui.outputSegmentRadioButton)
self.ui.outputTypeGroup.addButton(self.ui.outputNewSegmentRadioButton)
self.ui.outputTypeGroup.addButton(self.ui.outputModelRadioButton)
# Widget to arguments mapping
self.valueEditWidgets = {
ARG_REGION: self.ui.regionGroup,
ARG_REGION_SEGMENT_ID: self.ui.regionSegmentSelector,
ARG_CARVE_HOLES_IN_OUTER_SURFACE:
self.ui.carveHolesInOuterSurfaceCheckBox,
ARG_CARVE_HOLES_IN_OUTER_SURFACE_DIAMETER:
self.ui.carveHolesInOuterSurfaceDiameterSlider,
ARG_SPLIT_CAVITIES: self.ui.splitCavitiesCheckBox,
ARG_SPLIT_CAVITIES_DIAMETER: self.ui.splitCavitiesDiameterSlider,
ARG_CREATE_SHELL: self.ui.createShellCheckBox,
ARG_SHELL_THICKNESS: self.ui.shellThicknessSlider,
ARG_SHELL_OFFSET_DIRECTION: self.ui.shellOffsetDirectionGroup,
ARG_SHELL_PRESERVE_CRACKS: self.ui.shellPreserveCracksCheckBox,
ARG_OUTPUT_TYPE: self.ui.outputTypeGroup,
ARG_OUTPUT_MODEL_NODE: self.ui.outputModelNodeSelector,
ARG_SMOOTHING_FACTOR: self.ui.smoothingFactorSlider,
ARG_REMESH_OVERSAMPLING: self.ui.remeshOversamplingSlider,
ARG_SHRINKWRAP_ITERATIONS: self.ui.iterationsSlider,
ARG_SAVE_INTERMEDIATE_RESULTS:
self.ui.saveIntermediateResultsCheckBox
}
# Add connections
for argName, widget in self.valueEditWidgets.items():
widgetClassName = widget.metaObject().getClassName()
if widgetClassName == "qMRMLSliderWidget" or widgetClassName == "ctkSliderWidget":
widget.connect("valueChanged(double)", self.updateMRMLFromGUI)
elif widgetClassName == "QCheckBox":
widget.connect("stateChanged(int)", self.updateMRMLFromGUI)
elif widgetClassName == "qMRMLNodeComboBox":
widget.connect("currentNodeChanged(vtkMRMLNode*)",
self.updateMRMLFromGUI)
elif widgetClassName == "QButtonGroup":
widget.connect("buttonClicked(int)", self.updateMRMLFromGUI)
elif widgetClassName == "qMRMLSegmentSelectorWidget":
widget.connect("currentSegmentChanged(QString)",
self.updateMRMLFromGUI)
else:
raise Exception(
"Unexpected widget class: {0}".format(widgetClassName))
self.ui.applyButton.connect('clicked()', self.onApply)
def setup(self):
"""
Called when the user opens the module the first time and the widget is initialized.
"""
ScriptedLoadableModuleWidget.setup(self)
# Load widget from .ui file (created by Qt Designer).
# Additional widgets can be instantiated manually and added to self.layout.
uiWidget = slicer.util.loadUI(self.resourcePath('UI/QReads.ui'))
self.layout.addWidget(uiWidget)
self.ui = slicer.util.childWidgetVariables(uiWidget)
self.slabModeButtonGroup = qt.QButtonGroup()
self.slabModeButtonGroup.addButton(self.ui.SlabModeMaxRadioButton,
vtk.VTK_IMAGE_SLAB_MAX)
self.slabModeButtonGroup.addButton(self.ui.SlabModeMeanRadioButton,
vtk.VTK_IMAGE_SLAB_MEAN)
self.slabModeButtonGroup.addButton(self.ui.SlabModeMinRadioButton,
vtk.VTK_IMAGE_SLAB_MIN)
self.ui.ZoomComboBox.addItems(self.ZOOM_ACTIONS)
# Set scene in MRML widgets. Make sure that in Qt designer the top-level qMRMLWidget's
# "mrmlSceneChanged(vtkMRMLScene*)" signal in is connected to each MRML widget's.
# "setMRMLScene(vtkMRMLScene*)" slot.
#uiWidget.setMRMLScene(slicer.mrmlScene)
# Create logic class. Logic implements all computations that should be possible to run
# in batch mode, without a graphical user interface.
self.logic = QReadsLogic()
# Connections
# These connections ensure that we update parameter node when scene is closed
self.addObserver(slicer.mrmlScene, slicer.mrmlScene.StartCloseEvent,
self.onSceneStartClose)
self.addObserver(slicer.mrmlScene, slicer.mrmlScene.EndCloseEvent,
self.onSceneEndClose)
self.addObserver(slicer.mrmlScene, slicer.mrmlScene.NodeAddedEvent,
self.onNodeAdded)
# These connections ensure that whenever user changes some settings on the GUI, that is saved in the MRML scene
# (in the selected parameter node).
self.ui.ShowReferenceMarkersButton.connect(
"clicked()", self.updateParameterNodeFromGUI)
self.ui.ResetReferenceMarkersButton.connect(
"clicked()", QReadsLogic.resetReferenceMarkers)
self.ui.SlabButton.connect("clicked()",
self.updateParameterNodeFromGUI)
self.slabModeButtonGroup.connect("buttonClicked(int)",
self.updateParameterNodeFromGUI)
self.ui.SlabThicknessSliderWidget.connect(
"valueChanged(double)", self.updateParameterNodeFromGUI)
self.ui.InverseGrayButton.connect("clicked(bool)",
self.updateParameterNodeFromGUI)
# Increasing the level will make the image darker, whereas decreasing the level value will make the image brighter
self.ui.BrightnessUpButton.connect(
"clicked()",
lambda step=-self.BRIGHTNESS_STEP: QReadsLogic.updateWindowLevel(
levelStep=step))
self.ui.BrightnessDownButton.connect(
"clicked()",
lambda step=self.BRIGHTNESS_STEP: QReadsLogic.updateWindowLevel(
levelStep=step))
# Increasing window will reduce display contrast, whereas decreasing the window increases the brightness
self.ui.ContrastUpButton.connect(
"clicked()",
lambda step=-self.CONTRAST_STEP: QReadsLogic.updateWindowLevel(
windowStep=step))
self.ui.ContrastDownButton.connect(
"clicked()",
lambda step=self.CONTRAST_STEP: QReadsLogic.updateWindowLevel(
windowStep=step))
self.ui.CTBodySoftTissueWLPresetButton.connect(
"clicked()",
lambda presetName="CT-BodySoftTissue": self.logic.
setWindowLevelPreset(presetName))
self.ui.CTBoneWLPresetButton.connect(
"clicked()",
lambda presetName="CT-Bone": self.logic.setWindowLevelPreset(
presetName))
self.ui.CTBrainWLPresetButton.connect(
"clicked()",
lambda presetName="CT-Head": self.logic.setWindowLevelPreset(
presetName))
self.ui.CTLungWLPresetButton.connect(
"clicked()",
lambda presetName="CT-Lung": self.logic.setWindowLevelPreset(
presetName))
self.ui.ZoomComboBox.connect("currentTextChanged(QString)",
self.updateParameterNodeFromGUI)
self.ui.CloseApplicationPushButton.connect("clicked()",
slicer.util.quit)
# Make sure parameter node is initialized (needed for module reload)
self.initializeParameterNode()
# Hide main window components
slicer.util.setApplicationLogoVisible(False)
slicer.util.setMenuBarsVisible(False)
slicer.util.setModuleHelpSectionVisible(False)
slicer.util.setModulePanelTitleVisible(False)
slicer.util.setToolbarsVisible(False)
# Layout
slicer.app.layoutManager().setLayout(self.logic.registerCustomLayout())
for viewName, viewColor in QReadsLogic.SLICEVIEW_BACKGROUND_COLORS.items(
):
sliceWidget = slicer.app.layoutManager().sliceWidget(viewName)
sliceWidget.sliceView().setBackgroundColor(qt.QColor(viewColor))
sliceNode = sliceWidget.mrmlSliceNode()
sliceNode.SetOrientationMarkerType(
slicer.vtkMRMLAbstractViewNode.OrientationMarkerTypeAxes)
sliceNode.SetSliceVisible(True)
for viewName, viewColor in QReadsLogic.THREEDVIEW_BACKGROUND_COLORS.items(
):
with NodeModify(slicer.util.getNode("vtkMRMLViewNode%s" %
viewName)) as viewNode:
viewNode.SetBackgroundColor(0., 0., 0.)
viewNode.SetBackgroundColor2(0., 0., 0.)
viewNode.SetBoxVisible(False)
viewNode.SetAxisLabelsVisible(False)
viewNode.SetOrientationMarkerType(
slicer.vtkMRMLAbstractViewNode.OrientationMarkerTypeAxes)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
self.caseInfoCollapsibleButton = ctk.ctkCollapsibleButton()
self.caseInfoCollapsibleButton.text = "Case information"
self.caseInfoCollapsibleButton.collapsed = False
self.layout.addWidget(self.caseInfoCollapsibleButton)
self.caseAreaLayout = qt.QGridLayout(self.caseInfoCollapsibleButton)
# Select case
row = 0
self.loadCaseButton = ctk.ctkPushButton()
self.loadCaseButton.text = "Load case"
self.loadCaseButton.toolTip = "Load a case folder"
self.caseAreaLayout.addWidget(self.loadCaseButton, row, 0)
# Reset button
self.resetButton = ctk.ctkPushButton()
self.resetButton.text = "Close case"
self.resetButton.toolTip = "Close the current case"
self.caseAreaLayout.addWidget(self.resetButton, row, 1)
# Case info
row += 1
self.caseInfoFrame = qt.QFrame()
self.caseInfoFrame.setFrameStyle(0x0002 | 0x0010)
self.caseInfoFrame.lineWidth = 2
self.caseInfoFrame.setStyleSheet(
"background-color: #EEEEEE; margin: 10px")
self.caseAreaLayout.addWidget(self.caseInfoFrame, row, 0, 1, 2)
self.caseInfoFrameLayout = qt.QGridLayout()
self.caseInfoFrame.setLayout(self.caseInfoFrameLayout)
self.caseIdLabel = qt.QLabel("Case id: ")
self.caseIdLabel.setStyleSheet("font-weight: bold")
self.caseInfoFrameLayout.addWidget(self.caseIdLabel, 0, 0)
self.showEnhancementCheckboxGroup = qt.QButtonGroup()
self.showJustOriginalButton = qt.QRadioButton("Original only")
self.showJustOriginalButton.setChecked(True)
self.showEnhancementCheckboxGroup.addButton(
self.showJustOriginalButton, 0)
self.caseInfoFrameLayout.addWidget(self.showJustOriginalButton, 1, 0)
self.showOriginalPlusEnhancedButton = qt.QRadioButton(
"Original and enhanced")
self.showEnhancementCheckboxGroup.addButton(
self.showOriginalPlusEnhancedButton, 1)
self.caseInfoFrameLayout.addWidget(self.showOriginalPlusEnhancedButton,
2, 0)
self.showJustEnhancedButton = qt.QRadioButton("Enhanced only")
self.showEnhancementCheckboxGroup.addButton(
self.showJustEnhancedButton, 2)
self.caseInfoFrameLayout.addWidget(self.showJustEnhancedButton, 3, 0)
# Center Volumes button
self.centerVolumesButton = ctk.ctkPushButton()
self.centerVolumesButton.text = "Center image/s"
self.centerVolumesButton.toolTip = "Center all the current visible images"
self.centerVolumesButton.setFixedWidth(200)
# self.centerVolumesButton.toolTip = "Load a case folder"
self.caseInfoFrameLayout.addWidget(self.centerVolumesButton, 4, 0)
# Enhancement fine tuning
self.vascularFactorLabel = qt.QLabel("Vascular factor")
self.vascularFactorLabel.setStyleSheet("font-weight: bold")
self.caseInfoFrameLayout.addWidget(self.vascularFactorLabel, 0, 1)
self.vascularFactorSlider = qt.QSlider()
self.vascularFactorSlider.orientation = 2 # Vertical
self.vascularFactorSlider.value = 5
self.vascularFactorSlider.minimum = 0
self.vascularFactorSlider.maximum = 10
# self.vascularFactorSlider.setStyleSheet("margin-top:10px;padding-top:20px")
# self.vascularFactorSlider.setToolTip("Move the slider for a fine tuning segmentation")
self.caseInfoFrameLayout.addWidget(self.vascularFactorSlider, 1, 1, 4,
1, 0x0004)
self.enhancementFactorLabel = qt.QLabel("Enhancement factor")
self.enhancementFactorLabel.setStyleSheet("font-weight: bold")
self.caseInfoFrameLayout.addWidget(self.enhancementFactorLabel, 0, 2)
self.enhancementFactorSlider = qt.QSlider()
self.enhancementFactorSlider.orientation = 2 # Vertical
self.enhancementFactorSlider.minimum = 0
self.enhancementFactorSlider.maximum = 10
self.enhancementFactorSlider.value = 5
# self.vascularFactorSlider.setStyleSheet("margin-top:10px;padding-top:20px")
# self.vascularFactorSlider.setToolTip("Move the slider for a fine tuning segmentation")
self.caseInfoFrameLayout.addWidget(self.enhancementFactorSlider, 1, 2,
4, 1, 0x0004)
# Editor
row += 1
self.editorWidget = ui.CustomEditorWidget(self.parent)
self.editorWidget.setup()
self.editorCollapsibleButton = self.editorWidget.editLabelMapsFrame
self.editorCollapsibleButton.text = "Edit the current eye image"
self.editorCollapsibleButton.collapsed = False
self.editorWidget.toolsColor.terminologyCollapsibleButton.setVisible(
False)
self.layout.addWidget(self.editorCollapsibleButton)
### DIAGNOSIS
self.diagnosisCollapsibleButton = ctk.ctkCollapsibleButton()
self.diagnosisCollapsibleButton.text = "Diagnosis"
self.diagnosisCollapsibleButton.collapsed = False
self.layout.addWidget(self.diagnosisCollapsibleButton)
self.diagnosisAreaLayout = qt.QVBoxLayout(
self.diagnosisCollapsibleButton)
# Visual Acuity
label = qt.QLabel("Visual acuity (VA): ")
label.setStyleSheet("margin: 10px 0 0 10px; font-weight: bold")
self.diagnosisAreaLayout.addWidget(label)
self.vaFrame = qt.QFrame()
self.vaFrame.setFrameStyle(0x0002 | 0x0010)
self.vaFrame.lineWidth = 2
self.vaFrame.setStyleSheet("background-color: #EEEEEE; margin: 10px")
self.vaFrame.setFixedWidth(240)
self.diagnosisAreaLayout.addWidget(self.vaFrame)
self.vaFrameLayout = qt.QGridLayout(self.vaFrame)
self.vaFrameLayout.addWidget(qt.QLabel("OS"), 0, 0)
self.osLineEdit = qt.QLineEdit()
self.osLineEdit.setFixedWidth(80)
self.osLineEdit.setStyleSheet("background-color: white")
self.vaFrameLayout.addWidget(self.osLineEdit, 0, 1)
self.vaFrameLayout.addWidget(qt.QLabel("OD"), 1, 0)
self.odLineEdit = qt.QLineEdit()
self.odLineEdit.setFixedWidth(80)
self.odLineEdit.setStyleSheet("background-color: white")
self.vaFrameLayout.addWidget(self.odLineEdit, 1, 1)
self.vaModalityButtonGroup = qt.QButtonGroup()
self.scvaRadioButton = qt.QRadioButton()
self.scvaRadioButton.setText("SCVA")
self.vaFrameLayout.addWidget(self.scvaRadioButton, 0, 2)
self.vaModalityButtonGroup.addButton(self.scvaRadioButton)
self.bcvaRadioButton = qt.QRadioButton()
self.bcvaRadioButton.setText("BCVA")
self.vaFrameLayout.addWidget(self.bcvaRadioButton, 1, 2)
self.vaModalityButtonGroup.addButton(self.bcvaRadioButton)
self.ucvaRadioButton = qt.QRadioButton()
self.ucvaRadioButton.setText("UCVA")
self.vaFrameLayout.addWidget(self.ucvaRadioButton, 2, 2)
self.vaModalityButtonGroup.addButton(self.ucvaRadioButton)
# Problems detected
label = qt.QLabel("Problems detected: ")
label.setStyleSheet("margin: 10px 0 0 10px; font-weight: bold")
self.diagnosisAreaLayout.addWidget(label)
self.problemsFrame = qt.QFrame()
self.problemsFrame.setFrameStyle(0x0002 | 0x0010)
self.problemsFrame.lineWidth = 2
self.problemsFrame.setStyleSheet(
"background-color: #EEEEEE; margin: 10px")
self.diagnosisAreaLayout.addWidget(self.problemsFrame)
self.problemsFrameLayout = qt.QGridLayout()
self.problemsFrame.setLayout(self.problemsFrameLayout)
self.problemsButtons = []
self.microaneurysmsCheckbox = qt.QCheckBox()
self.microaneurysmsCheckbox.setText("Microaneurysms")
self.problemsFrameLayout.addWidget(self.microaneurysmsCheckbox, 0, 0)
self.problemsButtons.append(self.microaneurysmsCheckbox)
self.exudatesCheckbox = qt.QCheckBox()
self.exudatesCheckbox.setText("Exudates")
self.problemsFrameLayout.addWidget(self.exudatesCheckbox, 0, 1)
self.problemsButtons.append(self.exudatesCheckbox)
self.haemorrhagesCheckbox = qt.QCheckBox()
self.haemorrhagesCheckbox.setText("Haemorrhages")
self.problemsFrameLayout.addWidget(self.haemorrhagesCheckbox, 0, 2)
self.problemsButtons.append(self.haemorrhagesCheckbox)
self.cottonWoolSpotsCheckbox = qt.QCheckBox()
self.cottonWoolSpotsCheckbox.setText("Cotton wool spots")
self.problemsFrameLayout.addWidget(self.cottonWoolSpotsCheckbox, 1, 0)
self.problemsButtons.append(self.cottonWoolSpotsCheckbox)
self.NeovascularisationCheckbox = qt.QCheckBox()
self.NeovascularisationCheckbox.setText("Neovascularisation")
self.problemsFrameLayout.addWidget(self.NeovascularisationCheckbox, 1,
1)
self.problemsButtons.append(self.NeovascularisationCheckbox)
label = qt.QLabel("Diabetic retinopathy diagnosis: ")
label.setStyleSheet("margin: 10px 0 0 10px; font-weight: bold")
self.diagnosisAreaLayout.addWidget(label)
# Diabetic Retinopathy diagnosis
self.diabeticRetinopathyDiagnosisFrame = qt.QFrame()
self.diabeticRetinopathyDiagnosisFrame.setFrameStyle(0x0002 | 0x0010)
self.diabeticRetinopathyDiagnosisFrame.lineWidth = 2
self.diabeticRetinopathyDiagnosisFrame.setStyleSheet(
"background-color: #EEEEEE; margin: 10px")
self.diagnosisAreaLayout.addWidget(
self.diabeticRetinopathyDiagnosisFrame)
self.diabeticRetinopathyDiagnosisFrameLayout = qt.QHBoxLayout()
self.diabeticRetinopathyDiagnosisFrame.setLayout(
self.diabeticRetinopathyDiagnosisFrameLayout)
self.diagnosisRadioButtonGroup = qt.QButtonGroup()
for i in range(5):
rb = qt.QRadioButton(str(i))
self.diagnosisRadioButtonGroup.addButton(rb, i)
self.diabeticRetinopathyDiagnosisFrameLayout.addWidget(rb)
self.diagnosisRadioButtonGroup.buttons()[0].setChecked(True)
# Additional comments
label = qt.QLabel("Additional comments:")
label.setStyleSheet("margin: 10px 0 0 10px; font-weight: bold")
self.diagnosisAreaLayout.addWidget(label)
row += 1
self.additionalCommentsText = qt.QTextEdit()
self.additionalCommentsText.setStyleSheet("margin: 10px")
self.diagnosisAreaLayout.addWidget(self.additionalCommentsText)
self.saveReportButton = ctk.ctkPushButton()
self.saveReportButton.text = "Save report"
self.saveReportButton.setFixedWidth(300)
self.diagnosisAreaLayout.addWidget(self.saveReportButton)
self.printReportButton = ctk.ctkPushButton()
self.printReportButton.text = "Save and generate PDF"
self.printReportButton.setFixedWidth(300)
self.diagnosisAreaLayout.addWidget(self.printReportButton)
self.expertModeCollapsibleButton = ctk.ctkCollapsibleButton()
self.expertModeCollapsibleButton.text = "Expert mode"
self.expertModeCollapsibleButton.collapsed = True
self.layout.addWidget(self.expertModeCollapsibleButton)
self.expertModeLayout = qt.QVBoxLayout(
self.expertModeCollapsibleButton)
self.expertModeCheckbox = qt.QCheckBox("Activate expert mode")
self.expertModeCheckbox.checked = False
self.expertModeLayout.addWidget(self.expertModeCheckbox)
self.layout.addStretch(1)
# Connections
self.loadCaseButton.connect('clicked()', self.__onLoadCaseClicked__)
# self.loadReportButton.connect('clicked()', self.__onLoadReportClicked__)
self.showEnhancementCheckboxGroup.connect(
"buttonClicked (int)", self.__onEnhancementButtonGroupClicked__)
self.centerVolumesButton.connect('clicked()',
SlicerUtil.centerAllVolumes)
self.vascularFactorSlider.connect('sliderReleased()',
self.__onEnhancementFineTuning__)
self.enhancementFactorSlider.connect('sliderReleased()',
self.__onEnhancementFineTuning__)
self.saveReportButton.connect('clicked()',
self.__onSaveReportClicked__)
self.printReportButton.connect('clicked()',
self.__onPrintReportClicked__)
self.resetButton.connect('clicked()', self.reset)
self.expertModeCheckbox.connect("stateChanged(int)",
self.__onExpertModeStateChanged__)
slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.EndCloseEvent,
self.__onSceneClosed__)
# Set default layout Red
SlicerUtil.changeLayoutRedSingle()
self.refreshUI()
def setup(self):
"""This is called one time when the module GUI is initialized
"""
ScriptedLoadableModuleWidget.setup(self)
# Create objects that can be used anywhere in the module. Example: in most cases there should be just one
# object of the logic class
self.logic = CIP_PAARatioLogic()
#
# Create all the widgets. Example Area
mainAreaCollapsibleButton = ctk.ctkCollapsibleButton()
mainAreaCollapsibleButton.text = "Main parameters"
self.layout.addWidget(mainAreaCollapsibleButton)
self.mainAreaLayout = qt.QGridLayout(mainAreaCollapsibleButton)
self.label = qt.QLabel("Select the volume")
self.label.setStyleSheet("margin:10px 0 20px 7px")
self.mainAreaLayout.addWidget(self.label, 0, 0)
self.volumeSelector = slicer.qMRMLNodeComboBox()
self.volumeSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "")
self.volumeSelector.name = "paa_volumeSelector"
self.volumeSelector.selectNodeUponCreation = True
self.volumeSelector.autoFillBackground = True
self.volumeSelector.addEnabled = True
self.volumeSelector.noneEnabled = False
self.volumeSelector.removeEnabled = False
self.volumeSelector.showHidden = False
self.volumeSelector.showChildNodeTypes = False
self.volumeSelector.setMRMLScene(slicer.mrmlScene)
self.volumeSelector.setStyleSheet(
"margin:0px 0 0px 0; padding:2px 0 2px 5px")
self.mainAreaLayout.addWidget(self.volumeSelector, 0, 1)
self.jumptToTemptativeSliceButton = ctk.ctkPushButton()
self.jumptToTemptativeSliceButton.name = "jumptToTemptativeSliceButton"
self.jumptToTemptativeSliceButton.text = "Jump to temptative slice"
self.jumptToTemptativeSliceButton.toolTip = "Jump to the best estimated slice to place the rulers"
self.jumptToTemptativeSliceButton.setIcon(
qt.QIcon("{0}/ruler.png".format(SlicerUtil.CIP_ICON_DIR)))
self.jumptToTemptativeSliceButton.setIconSize(qt.QSize(20, 20))
self.jumptToTemptativeSliceButton.setStyleSheet("font-weight: bold;")
# self.jumptToTemptativeSliceButton.setFixedWidth(140)
self.mainAreaLayout.addWidget(self.jumptToTemptativeSliceButton, 1, 1)
### Structure Selector
self.structuresGroupbox = qt.QGroupBox("Select the structure")
self.groupboxLayout = qt.QVBoxLayout()
self.structuresGroupbox.setLayout(self.groupboxLayout)
self.mainAreaLayout.addWidget(self.structuresGroupbox, 2, 0)
self.structuresButtonGroup = qt.QButtonGroup()
# btn = qt.QRadioButton("None")
# btn.visible = False
# self.structuresButtonGroup.addButton(btn)
# self.groupboxLayout.addWidget(btn)
btn = qt.QRadioButton("Both")
btn.name = "paaButton"
btn.checked = True
self.structuresButtonGroup.addButton(btn, 0)
self.groupboxLayout.addWidget(btn)
btn = qt.QRadioButton("Pulmonary Arterial")
btn.name = "paRadioButton"
self.structuresButtonGroup.addButton(btn, 1)
self.groupboxLayout.addWidget(btn)
btn = qt.QRadioButton("Aorta")
btn.name = "aortaRadioButton"
self.structuresButtonGroup.addButton(btn, 2)
self.groupboxLayout.addWidget(btn)
### Buttons toolbox
self.buttonsToolboxFrame = qt.QFrame()
self.buttonsToolboxLayout = qt.QGridLayout()
self.buttonsToolboxFrame.setLayout(self.buttonsToolboxLayout)
self.mainAreaLayout.addWidget(self.buttonsToolboxFrame, 2, 1)
self.placeRulersButton = ctk.ctkPushButton()
self.placeRulersButton.text = "Place ruler/s"
self.placeRulersButton.name = "placeRulersButton"
self.placeRulersButton.toolTip = "Place the ruler/s for the selected structure/s in the current slice"
self.placeRulersButton.setIcon(
qt.QIcon("{0}/ruler.png".format(SlicerUtil.CIP_ICON_DIR)))
self.placeRulersButton.setIconSize(qt.QSize(20, 20))
self.placeRulersButton.setFixedWidth(105)
self.placeRulersButton.setStyleSheet("font-weight:bold")
self.buttonsToolboxLayout.addWidget(self.placeRulersButton, 0, 0)
self.moveUpButton = ctk.ctkPushButton()
self.moveUpButton.text = "Move up"
self.moveUpButton.toolTip = "Move the selected ruler/s one slice up"
self.moveUpButton.setIcon(
qt.QIcon("{0}/move_up.png".format(SlicerUtil.CIP_ICON_DIR)))
self.moveUpButton.setIconSize(qt.QSize(20, 20))
self.moveUpButton.setFixedWidth(95)
self.buttonsToolboxLayout.addWidget(self.moveUpButton, 0, 1)
self.moveDownButton = ctk.ctkPushButton()
self.moveDownButton.text = "Move down"
self.moveDownButton.toolTip = "Move the selected ruler/s one slice down"
self.moveDownButton.setIcon(
qt.QIcon("{0}/move_down.png".format(SlicerUtil.CIP_ICON_DIR)))
self.moveDownButton.setIconSize(qt.QSize(20, 20))
self.moveDownButton.setFixedWidth(95)
self.buttonsToolboxLayout.addWidget(self.moveDownButton, 0, 2)
self.removeButton = ctk.ctkPushButton()
self.removeButton.text = "Remove ALL rulers"
self.removeButton.toolTip = "Remove all the rulers for this volume"
self.removeButton.setIcon(
qt.QIcon("{0}/delete.png".format(SlicerUtil.CIP_ICON_DIR)))
self.removeButton.setIconSize(qt.QSize(20, 20))
self.buttonsToolboxLayout.addWidget(self.removeButton, 1, 1, 1, 2, 2)
### Textboxes
self.textboxesFrame = qt.QFrame()
self.textboxesLayout = qt.QFormLayout()
self.textboxesFrame.setLayout(self.textboxesLayout)
self.textboxesFrame.setFixedWidth(190)
self.mainAreaLayout.addWidget(self.textboxesFrame, 3, 0)
self.paTextBox = qt.QLineEdit()
self.paTextBox.setReadOnly(True)
self.textboxesLayout.addRow("PA (mm): ", self.paTextBox)
self.aortaTextBox = qt.QLineEdit()
self.aortaTextBox.setReadOnly(True)
self.textboxesLayout.addRow("Aorta (mm): ", self.aortaTextBox)
self.ratioTextBox = qt.QLineEdit()
self.ratioTextBox.name = "ratioTextBox"
self.ratioTextBox.setReadOnly(True)
self.textboxesLayout.addRow("Ratio PA/A: ", self.ratioTextBox)
# Save case data
self.reportsCollapsibleButton = ctk.ctkCollapsibleButton()
self.reportsCollapsibleButton.text = "Reporting"
self.layout.addWidget(self.reportsCollapsibleButton)
self.reportsLayout = qt.QHBoxLayout(self.reportsCollapsibleButton)
self.storedColumnNames = [
"caseId", "paDiameterMm", "aortaDiameterMm", "pa1r", "pa1a",
"pa1s", "pa2r", "pa2a", "pa2s", "a1r", "a1a", "a1s", "a2r", "a2a",
"a2s"
]
columns = CaseReportsWidget.getColumnKeysNormalizedDictionary(
self.storedColumnNames)
self.reportsWidget = CaseReportsWidget(
self.moduleName,
columns,
parentWidget=self.reportsCollapsibleButton)
self.reportsWidget.setup()
# Init state
self.resetModuleState()
self.preventSavingState = False
self.saveStateBeforeEnteringModule()
self.preventSavingState = True
self.switchToRedView()
#####
# Case navigator
if SlicerUtil.isSlicerACILLoaded():
caseNavigatorAreaCollapsibleButton = ctk.ctkCollapsibleButton()
caseNavigatorAreaCollapsibleButton.text = "Case navigator"
self.layout.addWidget(caseNavigatorAreaCollapsibleButton, 0x0020)
# caseNavigatorLayout = qt.QVBoxLayout(caseNavigatorAreaCollapsibleButton)
# Add a case list navigator
from ACIL.ui import CaseNavigatorWidget
self.caseNavigatorWidget = CaseNavigatorWidget(
self.moduleName, caseNavigatorAreaCollapsibleButton)
self.caseNavigatorWidget.setup()
self.layout.addStretch()
# Connections
self.observers = []
self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.onVolumeSelectorChanged)
self.jumptToTemptativeSliceButton.connect(
'clicked()', self.onJumpToTemptativeSliceButtonClicked)
self.placeRulersButton.connect('clicked()', self.onPlaceRulersClicked)
self.moveUpButton.connect('clicked()', self.onMoveUpRulerClicked)
self.moveDownButton.connect('clicked()', self.onMoveDownRulerClicked)
self.removeButton.connect('clicked()', self.onRemoveRulerClicked)
self.reportsWidget.addObservable(
self.reportsWidget.EVENT_SAVE_BUTTON_CLICKED, self.onSaveReport)
# Init state
self.resetModuleState()
self.preventSavingState = False
self.saveStateBeforeEnteringModule()
self.preventSavingState = True
def setup(self):
"""Init the widget """
# self.firstLoad = True
ScriptedLoadableModuleWidget.setup(self)
# Create objects that can be used anywhere in the module. Example: in most cases there should be just one
# object of the logic class
self._initLogic_()
##########
# Main area
self.mainAreaCollapsibleButton = ctk.ctkCollapsibleButton()
self.mainAreaCollapsibleButton.text = "Main area"
self.layout.addWidget(self.mainAreaCollapsibleButton,
SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.mainLayout = qt.QGridLayout(self.mainAreaCollapsibleButton)
# Node selector
volumeLabel = qt.QLabel("Active volume: ")
volumeLabel.setStyleSheet("margin-left:5px")
self.mainLayout.addWidget(volumeLabel, 0, 0)
self.volumeSelector = slicer.qMRMLNodeComboBox()
self.volumeSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "")
self.volumeSelector.selectNodeUponCreation = True
self.volumeSelector.autoFillBackground = True
self.volumeSelector.addEnabled = False
self.volumeSelector.noneEnabled = False
self.volumeSelector.removeEnabled = False
self.volumeSelector.showHidden = False
self.volumeSelector.showChildNodeTypes = False
self.volumeSelector.setMRMLScene(slicer.mrmlScene)
self.volumeSelector.setMinimumWidth(150)
self.volumeSelector.setStyleSheet("margin: 15px 0")
# self.volumeSelector.selectNodeUponCreation = False
self.mainLayout.addWidget(self.volumeSelector, 0, 1, 1, 2)
self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self._onMainVolumeChanged_)
### Radio buttons frame
self.radioButtonsFrame = qt.QFrame()
self.radioButtonsLayout = qt.QHBoxLayout(self.radioButtonsFrame)
self.typesFrame = qt.QFrame()
self.radioButtonsLayout.addWidget(self.typesFrame)
self.typesLayout = qt.QVBoxLayout(self.typesFrame)
labelsStyle = "font-weight: bold; margin: 0 0 10px 0px;"
# Types Radio Buttons
typesLabel = qt.QLabel("Select type")
typesLabel.setStyleSheet(labelsStyle)
self.typesLayout.addWidget(typesLabel)
self.typesRadioButtonGroup = qt.QButtonGroup()
for key in self.logic.params.mainTypes.keys():
rbitem = qt.QRadioButton(self.logic.params.getMainTypeLabel(key))
self.typesRadioButtonGroup.addButton(rbitem, key)
self.typesLayout.addWidget(rbitem)
self.typesRadioButtonGroup.buttons()[0].setChecked(True)
# Subtypes Radio buttons
# The content will be loaded dynamically every time the main type is modified
self.subtypesFrame = qt.QFrame()
self.radioButtonsLayout.addWidget(self.subtypesFrame)
self.subtypesLayout = qt.QVBoxLayout(self.subtypesFrame)
subtypesLabel = qt.QLabel("Select subtype")
subtypesLabel.setStyleSheet(labelsStyle)
self.subtypesLayout.addWidget(subtypesLabel)
self.subtypesLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.subtypesRadioButtonGroup = qt.QButtonGroup()
# Add all the subtypes (we will filter later in "updateState" function)
for key in self.logic.params.subtypes.keys():
# Build the description
rbitem = qt.QRadioButton(self.logic.params.getSubtypeLabel(key))
self.subtypesRadioButtonGroup.addButton(rbitem, key)
self.subtypesLayout.addWidget(rbitem,
SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.subtypesLayout.addStretch()
# Region radio buttons
self.regionsFrame = qt.QFrame()
self.radioButtonsLayout.addWidget(self.regionsFrame)
self.regionsLayout = qt.QVBoxLayout(self.regionsFrame)
regionsLabel = qt.QLabel("Select region")
regionsLabel.setStyleSheet(labelsStyle)
self.regionsLayout.addWidget(regionsLabel)
self.regionsLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.regionsLayout.setStretch(0, 0)
self.regionsRadioButtonGroup = qt.QButtonGroup()
self.regionsFrame = qt.QFrame()
# Add all the regions
for key in self.logic.params.regions.keys():
# Build the description
rbitem = qt.QRadioButton(self.logic.params.getRegionLabel(key))
self.regionsRadioButtonGroup.addButton(rbitem, key)
self.regionsLayout.addWidget(rbitem,
SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.regionsLayout.addStretch()
self.regionsRadioButtonGroup.buttons()[0].setChecked(True)
# Artifact radio buttons (Add them to the same layout as the type)
# self.separatorLabel = qt.QLabel("------------")
# labelsStyle = "margin: 5px 0 5px 0;"
# self.separatorLabel.setStyleSheet(labelsStyle)
# self.typesLayout.addWidget(self.separatorLabel)
# self.artifactsLabel = qt.QLabel("Select artifact")
# labelsStyle = "font-weight: bold; margin: 15px 0 10px 0;"
# self.artifactsLabel.setStyleSheet(labelsStyle)
# self.typesLayout.addWidget(self.artifactsLabel)
# self.artifactsRadioButtonGroup = qt.QButtonGroup()
# for artifactId in self.logic.params.artifacts.iterkeys():
# rbitem = qt.QRadioButton(self.logic.params.getArtifactLabel(artifactId))
# self.artifactsRadioButtonGroup.addButton(rbitem, artifactId)
# self.typesLayout.addWidget(rbitem)
# self.artifactsRadioButtonGroup.buttons()[0].setChecked(True)
#
self.typesLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.typesLayout.addStretch()
# Connections
self.typesRadioButtonGroup.connect("buttonClicked (QAbstractButton*)",
self.__onTypesRadioButtonClicked__)
self.subtypesRadioButtonGroup.connect(
"buttonClicked (QAbstractButton*)",
self.__onSecondaryRadioButtonClicked__)
self.regionsRadioButtonGroup.connect(
"buttonClicked (QAbstractButton*)",
self.__onSecondaryRadioButtonClicked__)
# self.artifactsRadioButtonGroup.connect("buttonClicked (QAbstractButton*)", self.__onTypesRadioButtonClicked__)
self.mainLayout.addWidget(self.radioButtonsFrame, 2, 0, 1, 3,
SlicerUtil.ALIGNMENT_VERTICAL_TOP)
# Save results button
self.saveResultsButton = ctk.ctkPushButton()
self.saveResultsButton.setText("Save results")
self.saveResultsButton.toolTip = "Save the results labelmap in the specified directory"
self.saveResultsButton.setIcon(
qt.QIcon("{0}/Save.png".format(SlicerUtil.CIP_ICON_DIR)))
self.saveResultsButton.setIconSize(qt.QSize(20, 20))
self.saveResultsButton.setFixedWidth(135)
self.mainLayout.addWidget(self.saveResultsButton, 4, 0)
self.saveResultsButton.connect('clicked()',
self._onSaveResultsButtonClicked_)
# Save results directory button
defaultPath = os.path.join(
SlicerUtil.getSettingsDataFolder(self.moduleName),
"results") # Assign a default path for the results
path = SlicerUtil.settingGetOrSetDefault(self.moduleName,
"SaveResultsDirectory",
defaultPath)
self.saveResultsDirectoryButton = ctk.ctkDirectoryButton()
self.saveResultsDirectoryButton.directory = path
self.saveResultsDirectoryButton.setMaximumWidth(440)
self.mainLayout.addWidget(self.saveResultsDirectoryButton, 4, 1, 1, 2)
self.saveResultsDirectoryButton.connect(
"directoryChanged (QString)", self._onSaveResultsDirectoryChanged_)
self._createSegmentEditorWidget_()
# MIP viewer (by default it will be hidden)
self.mipCollapsibleButton = ctk.ctkCollapsibleButton()
self.mipCollapsibleButton.text = "MIP viewer"
mipLayout = qt.QVBoxLayout(self.mipCollapsibleButton)
self.mainLayout.addWidget(self.mipCollapsibleButton)
self.mipViewer = CIPUI.MIPViewerWidget(mipLayout)
self.mipCollapsibleButton.setVisible(False)
self.mipViewer.setup()
self.mipViewer.isCrosshairEnabled = False
self.mipCollapsibleButton.collapsed = True
#####
# Case navigator
self.caseNavigatorWidget = None
if SlicerUtil.isSlicerACILLoaded():
caseNavigatorAreaCollapsibleButton = ctk.ctkCollapsibleButton()
caseNavigatorAreaCollapsibleButton.text = "Case navigator"
self.layout.addWidget(caseNavigatorAreaCollapsibleButton, 0x0020)
# caseNavigatorLayout = qt.QVBoxLayout(caseNavigatorAreaCollapsibleButton)
# Add a case list navigator
from ACIL.ui import CaseNavigatorWidget
self.caseNavigatorWidget = CaseNavigatorWidget(
self.moduleName, caseNavigatorAreaCollapsibleButton)
self.caseNavigatorWidget.setup()
# Listen for event in order to save the current labelmap before moving to the next case
self.caseNavigatorWidget.addObservable(
self.caseNavigatorWidget.EVENT_PRE_NEXT,
self._checkSaveChanges_)
self.caseNavigatorWidget.addObservable(
self.caseNavigatorWidget.EVENT_PRE_PREVIOUS,
self._checkSaveChanges_)
self.caseNavigatorWidget.addObservable(
self.caseNavigatorWidget.EVENT_PRE_LABELMAP_LOAD,
self._onPreNavigatorLabelmapLoaded_)
self.caseNavigatorWidget.addObservable(
self.caseNavigatorWidget.EVENT_LABELMAP_LOADED,
self._onNavigatorLabelmapLoaded_)
self.layout.addStretch()
# Extra Connections
self._createSceneObservers_()
self.disableEvents = False
self.setMainTypeGUIProperties()
def _addCustomizationSection(self):
customizationCollapsibleButton = ctk.ctkCollapsibleButton()
customizationCollapsibleButton.text = 'Extraction Customization'
customizationCollapsibleButton.collapsed = True
self.layout.addWidget(customizationCollapsibleButton)
customizationFormLayout = qt.QFormLayout(customizationCollapsibleButton)
#
# Radiobuttons to select customization Type
#
self.manualCustomizationRadioButton = qt.QRadioButton()
self.manualCustomizationRadioButton.text = 'Manual Customization'
self.manualCustomizationRadioButton.checked = True
customizationFormLayout.layout().addWidget(self.manualCustomizationRadioButton)
self.parameterFileCustomizationRadioButton = qt.QRadioButton()
self.parameterFileCustomizationRadioButton.text = 'Parameter File Customization'
self.parameterFileCustomizationRadioButton.checked = False
customizationFormLayout.layout().addWidget(self.parameterFileCustomizationRadioButton)
#
# Manual Customization
#
self.manualCustomizationGroupBox = qt.QGroupBox('Manual Customization')
self.manualCustomizationGroupBox.visible = True
# self.manualCustomizationGroupBox.checkable = True
customizationFormLayout.addWidget(self.manualCustomizationGroupBox)
manualCustomizationFormLayout = qt.QFormLayout(self.manualCustomizationGroupBox)
# Feature Class section
featureClassCollapsibleButton = ctk.ctkCollapsibleButton()
featureClassCollapsibleButton.text = 'Feature Classes'
featureClassCollapsibleButton.collapsed = False
manualCustomizationFormLayout.addWidget(featureClassCollapsibleButton)
featureClassLayout = qt.QFormLayout(featureClassCollapsibleButton)
self.featuresLayout = qt.QHBoxLayout()
featureClassLayout.addRow('Features:', self.featuresLayout)
self.featuresButtonGroup = qt.QButtonGroup(self.featuresLayout)
self.featuresButtonGroup.exclusive = False
# Get the feature classes dynamically
self.features = list(getFeatureClasses().keys())
# Create a checkbox for each feature
featureButtons = {}
for feature in self.features:
featureButtons[feature] = qt.QCheckBox(feature)
# TODO: decide which features to enable by default
featureButtons[feature].checked = False
if feature == 'firstorder':
featureButtons[feature].checked = True
self.featuresButtonGroup.addButton(featureButtons[feature])
self.featuresLayout.layout().addWidget(featureButtons[feature])
# set the ID to be the index of this feature in the list
self.featuresButtonGroup.setId(featureButtons[feature], self.features.index(feature))
# Add buttons to select all or none
self.buttonsLayout = qt.QHBoxLayout()
featureClassLayout.addRow('Toggle Features:', self.buttonsLayout)
self.calculateAllFeaturesButton = qt.QPushButton('All Features')
self.calculateAllFeaturesButton.toolTip = 'Calculate all feature classes.'
self.calculateAllFeaturesButton.enabled = True
self.buttonsLayout.addWidget(self.calculateAllFeaturesButton)
self.calculateNoFeaturesButton = qt.QPushButton('No Features')
self.calculateNoFeaturesButton.toolTip = 'Calculate no feature classes.'
self.calculateNoFeaturesButton.enabled = True
self.buttonsLayout.addWidget(self.calculateNoFeaturesButton)
# Resampling and Filtering
filteringCollapsibleButton = ctk.ctkCollapsibleButton()
filteringCollapsibleButton.text = 'Resampling and Filtering'
filteringCollapsibleButton.collapsed = False
manualCustomizationFormLayout.addRow(filteringCollapsibleButton)
# Layout within the dummy collapsible button
filteringFormLayout = qt.QFormLayout(filteringCollapsibleButton)
# Resampling
self.resampledVoxelSize = qt.QLineEdit()
self.resampledVoxelSize.toolTip = 'Three floating-point numbers separated by comma defining the resampled pixel ' \
'size (mm).'
filteringFormLayout.addRow('Resampled voxel size', self.resampledVoxelSize)
# LoG kernel sizes. default to 5 (?)
self.logKernelSizes = qt.QLineEdit()
self.logKernelSizes.toolTip = 'Laplacian of Gaussian filter kernel sizes (mm), separated by comma. ' \
'If empty, no LoG filtering will be applied.'
filteringFormLayout.addRow('LoG kernel sizes', self.logKernelSizes)
# Wavelet
self.waveletCheckBox = qt.QCheckBox()
self.waveletCheckBox.checked = 0
self.waveletCheckBox.toolTip = 'If checked, PyRadiomics will calculate features on the image after applying ' \
'wavelet transformation'
filteringFormLayout.addRow('Wavelet-based features', self.waveletCheckBox)
#
# Feature calculation settings
#
settingsCollapsibleButton = ctk.ctkCollapsibleButton()
settingsCollapsibleButton.text = 'Settings'
settingsCollapsibleButton.collapsed = False
manualCustomizationFormLayout.addWidget(settingsCollapsibleButton)
# Layout within the dummy collapsible button
settingsFormLayout = qt.QFormLayout(settingsCollapsibleButton)
# bin width, defaults to 25
self.binWidthSliderWidget = ctk.ctkSliderWidget()
self.binWidthSliderWidget.singleStep = 1
self.binWidthSliderWidget.decimals = 2
self.binWidthSliderWidget.minimum = 0.01
self.binWidthSliderWidget.maximum = 100
self.binWidthSliderWidget.value = 25
self.binWidthSliderWidget.toolTip = 'Set the bin width'
settingsFormLayout.addRow('Bin Width', self.binWidthSliderWidget)
# symmetricalGLCM flag, defaults to false
self.symmetricalGLCMCheckBox = qt.QCheckBox()
self.symmetricalGLCMCheckBox.checked = 1
self.symmetricalGLCMCheckBox.toolTip = 'Use a symmetrical GLCM matrix'
settingsFormLayout.addRow('Enforce Symmetrical GLCM', self.symmetricalGLCMCheckBox)
#
# Parameter File Customization
#
self.parameterCustomizationGroupBox = qt.QGroupBox('Parameter File Customization')
self.parameterCustomizationGroupBox.visible = False
# self.parameterCustomizationGroupBox.checkable = True
customizationFormLayout.addWidget(self.parameterCustomizationGroupBox)
parameterCustomizationFormLayout = qt.QFormLayout(self.parameterCustomizationGroupBox)
# Path edit to select parameter file
self.parameterFilePathLineEdit = ctk.ctkPathLineEdit()
parameterCustomizationFormLayout.addRow("Parameter File", self.parameterFilePathLineEdit)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
self.setupViewSettingsArea()
# Setup a logger for the extension log messages
self.logger = logging.getLogger('SlicerCaseIterator')
self.logic = None
# These variables hold connections to other parts of Slicer, such as registered keyboard shortcuts and
# Event observers
self.shortcuts = []
self.observers = []
# Instantiate and connect widgets ...
#
# ComboBox for mode selection
#
self.modeGroup = qt.QGroupBox("Mode Selection")
self.modeGroup.setLayout(qt.QFormLayout())
self.layout.addWidget(self.modeGroup)
modes = IteratorFactory.getImplementationNames()
self.modeComboBox = qt.QComboBox()
self.modeComboBox.addItems([""] + modes)
self.modeGroup.layout().addWidget(self.modeComboBox)
#
# Select and Load input data section
#
self.inputDataCollapsibleButton = ctk.ctkCollapsibleButton()
self.inputDataCollapsibleButton.text = 'Select and Load case data'
self.layout.addWidget(self.inputDataCollapsibleButton)
#
# Parameters Area
#
self.parametersCollapsibleButton = ctk.ctkCollapsibleButton()
self.parametersCollapsibleButton.text = 'Case iteration parameters'
self.layout.addWidget(self.parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(self.parametersCollapsibleButton)
#
# Reader Name
#
self.txtReaderName = qt.QLineEdit()
self.txtReaderName.text = ''
self.txtReaderName.toolTip = 'Name of the current reader; if not empty, this name will be added to the filename ' \
'of saved masks'
parametersFormLayout.addRow('Reader name', self.txtReaderName)
#
# Start position
#
self.npStart = qt.QSpinBox()
self.npStart.minimum = 1
self.npStart.maximum = 999999
self.npStart.value = 1
self.npStart.toolTip = 'Start position in the CSV file (1 = first patient)'
parametersFormLayout.addRow('Start position', self.npStart)
#
# Visualization Properties
#
self.visualizationPropertiesCollapsibleButton = ctk.ctkCollapsibleButton(
)
self.visualizationPropertiesCollapsibleButton.text = 'Visualization properties'
self.layout.addWidget(self.visualizationPropertiesCollapsibleButton)
visualizationPropertiesFormLayout = qt.QVBoxLayout(
self.visualizationPropertiesCollapsibleButton)
#
# Mask Groupbox
#
self.maskGroup = qt.QGroupBox("Mask")
self.maskGroup.setLayout(qt.QFormLayout())
visualizationPropertiesFormLayout.addWidget(self.maskGroup)
self.sliceFill2DSlider = slicer.qMRMLSliderWidget()
self.sliceFill2DSlider.minimum = 0.0
self.sliceFill2DSlider.maximum = 1.0
self.sliceFill2DSlider.singleStep = 0.1
self.maskGroup.layout().addRow("Slice 2D fill:",
self.sliceFill2DSlider)
self.sliceOutline2DSlider = slicer.qMRMLSliderWidget()
self.sliceOutline2DSlider.minimum = 0.0
self.sliceOutline2DSlider.maximum = 1.0
self.sliceOutline2DSlider.singleStep = 0.1
self.sliceOutline2DSlider.value = 1.0
self.maskGroup.layout().addRow("Slice 2D outline:",
self.sliceOutline2DSlider)
#
# Progressbar
#
self.progressBar = qt.QProgressBar()
self.progressBar.setFormat("%v/%m")
self.progressBar.visible = False
self.layout.addWidget(self.progressBar)
#
# Case Button Row
#
self.caseButtonWidget = qt.QWidget()
self.caseButtonWidget.setLayout(qt.QHBoxLayout())
self.layout.addWidget(self.caseButtonWidget)
#
# Reset
#
self.resetButton = qt.QPushButton('Start Batch')
self.resetButton.enabled = False
self.caseButtonWidget.layout().addWidget(self.resetButton)
#
# Previous Case
#
self.previousButton = qt.QPushButton('Previous Case')
self.previousButton.enabled = False
self.previousButton.toolTip = '(Ctrl+P) Press this button to go to the previous case, previous new masks are not reloaded'
self.caseButtonWidget.layout().addWidget(self.previousButton)
#
# Load CSV / Next Case
#
self.nextButton = qt.QPushButton('Next Case')
self.nextButton.enabled = False
self.nextButton.toolTip = '(Ctrl+N) Press this button to go to the next case'
self.caseButtonWidget.layout().addWidget(self.nextButton)
#
# Collapsible Button group for enabling only one at a time
#
self.collapsibleButtonGroup = qt.QButtonGroup()
self.collapsibleButtonGroup.setExclusive(True)
self.collapsibleButtonGroup.addButton(self.inputDataCollapsibleButton)
self.collapsibleButtonGroup.addButton(self.parametersCollapsibleButton)
self.collapsibleButtonGroup.addButton(
self.visualizationPropertiesCollapsibleButton)
self.layout.addStretch(1)
#
# Connect buttons to functions
#
self.modeComboBox.currentTextChanged.connect(self.onModeSelected)
self.previousButton.connect('clicked(bool)', self.onPrevious)
self.nextButton.connect('clicked(bool)', self.onNext)
self.resetButton.connect('clicked(bool)', self.onReset)
self.sliceFill2DSlider.valueChanged.connect(
lambda value: self.updateSegmentationProperties())
self.sliceOutline2DSlider.valueChanged.connect(
lambda value: self.updateSegmentationProperties())
if len(modes) == 1:
self.modeComboBox.hide()
self.onModeSelected(modes[1])
self._setGUIstate(csv_loaded=False)
def create(self, registrationState):
"""Make the plugin-specific user interface"""
super(LocalSimpleITKPlugin, self).create(registrationState)
# To avoid the overhead of importing SimpleITK during application
# startup, the import of SimpleITK is delayed until it is needed.
global sitk
import SimpleITK as sitk
global sitkUtils
import sitkUtils
print("LocalSimpleITKPlugin.create")
self.LocalSimpleITKMode = "Small"
self.VerboseMode = "Quiet"
#
# Local Refinment Pane - initially hidden
# - interface options for linear registration
#
localSimpleITKCollapsibleButton = ctk.ctkCollapsibleButton()
localSimpleITKCollapsibleButton.text = "Local SimpleITK"
localSimpleITKFormLayout = qt.QFormLayout()
localSimpleITKCollapsibleButton.setLayout(localSimpleITKFormLayout)
self.widgets.append(localSimpleITKCollapsibleButton)
buttonGroup = qt.QButtonGroup()
self.widgets.append(buttonGroup)
buttonLayout = qt.QVBoxLayout()
localSimpleITKModeButtons = {}
self.LocalSimpleITKModes = ("Small", "Large")
for mode in self.LocalSimpleITKModes:
localSimpleITKModeButtons[mode] = qt.QRadioButton()
localSimpleITKModeButtons[mode].text = mode
localSimpleITKModeButtons[mode].setToolTip(
"Run the refinement in a %s local region." % mode.lower())
buttonLayout.addWidget(localSimpleITKModeButtons[mode])
buttonGroup.addButton(localSimpleITKModeButtons[mode])
self.widgets.append(localSimpleITKModeButtons[mode])
localSimpleITKModeButtons[mode].connect(
'clicked()', lambda m=mode: self.onLocalSimpleITKMode(m))
localSimpleITKModeButtons[self.LocalSimpleITKMode].checked = True
localSimpleITKFormLayout.addRow("Local SimpleITK Mode ", buttonLayout)
buttonGroup = qt.QButtonGroup()
self.widgets.append(buttonGroup)
buttonLayout = qt.QVBoxLayout()
verboseModeButtons = {}
self.VerboseModes = ("Quiet", "Verbose", "Full Verbose")
for mode in self.VerboseModes:
verboseModeButtons[mode] = qt.QRadioButton()
verboseModeButtons[mode].text = mode
verboseModeButtons[mode].setToolTip(
"Run the refinement in %s mode." % mode.lower())
buttonLayout.addWidget(verboseModeButtons[mode])
buttonGroup.addButton(verboseModeButtons[mode])
self.widgets.append(verboseModeButtons[mode])
verboseModeButtons[mode].connect(
'clicked()', lambda m=mode: self.onVerboseMode(m))
verboseModeButtons[self.VerboseMode].checked = True
localSimpleITKFormLayout.addRow("Verbose Mode ", buttonLayout)
self.parent.layout().addWidget(localSimpleITKCollapsibleButton)
def setup(self):
#->> TODO could also specify with Qt Designer instead in future (QtUiTools)
# IO COLLAPSIBLE BUTTON
ioCollapsibleButton = ctk.ctkCollapsibleButton()
ioCollapsibleButton.text = "IO"
self.layout.addWidget(ioCollapsibleButton)
# Layout within the io collapsible button
ioFormLayout = qt.QFormLayout(ioCollapsibleButton)
# inputVolume node selector 1
inputNodeSelector1 = slicer.qMRMLNodeComboBox()
inputNodeSelector1.objectName = 'inputNodeSelector1'
inputNodeSelector1.toolTip = "Select the 1st input volume to be segmented."
inputNodeSelector1.nodeTypes = ['vtkMRMLScalarVolumeNode']
inputNodeSelector1.noneEnabled = False
inputNodeSelector1.addEnabled = False
inputNodeSelector1.removeEnabled = False
inputNodeSelector1.editEnabled = True
inputNodeSelector1.connect('currentNodeChanged(vtkMRMLNode*)',
self.setInputNode1)
ioFormLayout.addRow("Input Volume 1:", inputNodeSelector1)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
inputNodeSelector1, 'setMRMLScene(vtkMRMLScene*)')
self.inputNodeSelector1 = inputNodeSelector1
#->> TODO for all parameters, provide slots to set them, and use internal values to eventually pass them into the PDF segmenter - for using the interactive PDF segmenter somewhere else, ex in editor module
# inputVolume node selector 2
inputNodeSelector2 = slicer.qMRMLNodeComboBox()
inputNodeSelector2.objectName = 'inputNodeSelector2'
inputNodeSelector2.toolTip = "Select the 2nd input volume to be segmented."
inputNodeSelector2.nodeTypes = ['vtkMRMLScalarVolumeNode']
inputNodeSelector2.noneEnabled = True
inputNodeSelector2.addEnabled = False
inputNodeSelector2.removeEnabled = False
inputNodeSelector2.editEnabled = True
inputNodeSelector2.connect('currentNodeChanged(vtkMRMLNode*)',
self.setInputNode2)
ioFormLayout.addRow("Input Volume 2 (optional):", inputNodeSelector2)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
inputNodeSelector2, 'setMRMLScene(vtkMRMLScene*)')
self.inputNodeSelector2 = inputNodeSelector2
# inputVolume node selector 3
inputNodeSelector3 = slicer.qMRMLNodeComboBox()
inputNodeSelector3.objectName = 'inputNodeSelector3'
inputNodeSelector3.toolTip = "Select the 3rd input volume to be segmented."
inputNodeSelector3.nodeTypes = ['vtkMRMLScalarVolumeNode']
inputNodeSelector3.noneEnabled = True
inputNodeSelector3.addEnabled = False
inputNodeSelector3.removeEnabled = False
inputNodeSelector3.editEnabled = True
inputNodeSelector3.connect('currentNodeChanged(vtkMRMLNode*)',
self.setInputNode3)
ioFormLayout.addRow("Input Volume 3 (optional):", inputNodeSelector3)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
inputNodeSelector3, 'setMRMLScene(vtkMRMLScene*)')
self.inputNodeSelector3 = inputNodeSelector3
# outputVolume node selector
outputNodeSelector = slicer.qMRMLNodeComboBox()
outputNodeSelector.objectName = 'outputNodeSelector'
outputNodeSelector.toolTip = "Select the output volume to be segmented."
outputNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
outputNodeSelector.noneEnabled = False
outputNodeSelector.addEnabled = True
outputNodeSelector.removeEnabled = False
outputNodeSelector.editEnabled = True
outputNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.setOutputNode)
ioFormLayout.addRow("Output Volume:", outputNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
outputNodeSelector, 'setMRMLScene(vtkMRMLScene*)')
self.outputNodeSelector = outputNodeSelector
# LABEL MAP COLLAPSIBLE BUTTON
labelMapCollapsibleButton = ctk.ctkCollapsibleButton()
labelMapCollapsibleButton.text = "Label Maps"
self.layout.addWidget(labelMapCollapsibleButton)
# Layout within the labelMap collapsible button
labelMapFormLayout = qt.QFormLayout(labelMapCollapsibleButton)
# labelMap node selector
labelMapNodeSelector = slicer.qMRMLNodeComboBox()
labelMapNodeSelector.objectName = 'labelMapNodeSelector'
labelMapNodeSelector.toolTip = "Select the label map roughly outlining the structure to be segmented and its background."
labelMapNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
labelMapNodeSelector.addAttribute("vtkMRMLScalarVolumeNode",
"LabelMap", True)
labelMapNodeSelector.noneEnabled = False
labelMapNodeSelector.addEnabled = True
labelMapNodeSelector.removeEnabled = False
labelMapNodeSelector.editEnabled = True
labelMapNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.setLabelMapNode)
labelMapFormLayout.addRow("Label Map:", labelMapNodeSelector)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
labelMapNodeSelector,
'setMRMLScene(vtkMRMLScene*)')
self.labelMapNodeSelector = labelMapNodeSelector
# Create frame editor widget
editorFrame = qt.QFrame()
editorFrame.setLayout(qt.QVBoxLayout())
palette = editorFrame.palette
bgColor = 240
palette.setColor(qt.QPalette.Background,
qt.QColor(bgColor, bgColor, bgColor))
editorFrame.setPalette(palette)
editorFrame.setAutoFillBackground(True)
labelMapFormLayout.addRow(editorFrame)
self.editorFrame = editorFrame
# initialize editor widget: using parent frame, embedded is true and list of effects
self.editorWidget = __main__.EditorWidget(
parent=self.editorFrame,
embedded=True,
suppliedEffects=self.editorEffects,
showVolumesFrame=False)
# voidLabel selector
# The voidLabel selector selects which label corresponds to the void label
# All other labels in the label map will be extracted and set to object labels
voidLabelSpinBox = qt.QSpinBox()
voidLabelSpinBox.objectName = 'voidLabelSpinBox'
voidLabelSpinBox.toolTip = "Value that represents nothing in the label map. All other labels represent objects."
voidLabelSpinBox.setMinimum(0)
voidLabelSpinBox.setMaximum(255) # temporary value to start
voidLabelSpinBox.enabled = False
labelMapFormLayout.addRow("Void Id:", voidLabelSpinBox)
self.voidLabelSpinBox = voidLabelSpinBox
#->> TODO: later on, would like a label combo box that shows only those labels
# that are included in the label map
# The following code starts in that direction, but does not work
# BEGIN hacking
## voidLabelSelector = slicer.qMRMLLabelComboBox()
## voidLabelSelector.maximumColorCount = 256 #->> TODO
## labelMapFormLayout.addRow("Void Label:", voidLabelSelector)
## self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
## voidLabelSelector, 'setMRMLScene(vtkMRMLScene*)')
## # create a new vtkMRMLColorTableNode to hold the labels in the label map
## colorLogic = slicer.vtkSlicerColorLogic()
## defaultID = colorLogic.GetDefaultEditorColorNodeID()
## defaultNode = slicer.mrmlScene.GetNodeByID(defaultID)
## if defaultNode:
## # create the node based on the default editor color node
## self.labelsColorNode = slicer.vtkMRMLColorTableNode()
## self.labelsColorNode.Copy(defaultNode)
## # substitute in a new lookup table that we will manipulate
## lookupTable = vtk.vtkLookupTable()
## lookupTable.DeepCopy(defaultNode.GetLookupTable())
## defaultLookupTable = defaultNode.GetLookupTable()
## list = [3,5,7,9]
## lookupTable.SetNumberOfTableValues(len(list))
## for i in range(0, len(list)):
## orig = []
## defaultLookupTable.GetTableValue(list[i], orig)
## lookupTable.SetTableValue(i, defaultNode.GetLookupTable().
## self.labelsColorNode.SetLookupTable(lookupTable)
## # set the new color node to the selector
## # voidLabelSelector.setMRMLColorNode(self.labelsColorNode)
## print "lut:", self.labelsColorNode.GetLookupTable()
## self.voidLabelSelector = voidLabelSelector
# END hacking
#->> TODO: another alternative is to use an EditColor - but it is heavily coupled
# to the editor logic, using an editor parameter node that ties it with the editor
# widget's EditColor
# Create a frame to give the EditColor a suitable parent
## voidLabelFrame = qt.QFrame()
## voidLabelFrame.setLayout(qt.QHBoxLayout())
## voidLabelFrame.toolTip = "Value that represents nothing in the label map. All labels not equal to the void id represent objects."
## voidLabelSelector = EditorLib.EditColor(parent=voidLabelFrame)
## labelMapFormLayout.addRow("Void Id", voidLabelFrame)
## self.voidLabelSelector = voidLabelSelector
# SEGMENTATION PARAMETERS COLLAPSIBLE BUTTON
segmentationCollapsibleButton = ctk.ctkCollapsibleButton()
segmentationCollapsibleButton.text = "Segmentation Parameters"
self.layout.addWidget(segmentationCollapsibleButton)
# Layout within the parameters collapsible button
segmentationFormLayout = qt.QFormLayout(segmentationCollapsibleButton)
# segmentation "goal" buttons
self.goalButtonList = []
goalButtonGroup = qt.QButtonGroup()
goalGroupBox = qt.QGroupBox()
goalGroupBox.objectName = 'goalGroupBox'
goalGroupBox.toolTip = "Select what the goal segmentation looks like"
goalGroupBoxLayout = qt.QHBoxLayout()
for i in range(0, len(self.goalButtonTexts)):
button = qt.QToolButton()
button.setText(self.goalButtonTexts[i])
button.setCheckable(True)
goalButtonGroup.addButton(button, i)
goalGroupBoxLayout.addWidget(button)
self.goalButtonList.append(button)
self.goalButtonList[self.goalButtonDefault].setChecked(True)
goalButtonGroup.setExclusive(True)
goalButtonGroup.connect('buttonClicked(int)',
self.setGoalSegmentationType)
goalGroupBox.setLayout(goalGroupBoxLayout)
goalGroupBox.setFlat(True)
segmentationFormLayout.addRow("Goal Segmentation:", goalGroupBox)
self.goalButtonGroup = goalButtonGroup
# ADVANCED PARAMETERS COLLAPSIBLE BUTTON
advancedCollapsibleButton = ctk.ctkCollapsibleButton()
advancedCollapsibleButton.text = "Advanced Parameters"
self.layout.addWidget(advancedCollapsibleButton)
# Layout within the parameters collapsible button
advancedFormLayout = qt.QFormLayout(advancedCollapsibleButton)
# Erosion radius spin box
erosionSpinBox = qt.QSpinBox()
erosionSpinBox.objectName = 'erosionSpinBox'
erosionSpinBox.toolTip = "Set the erosion radius."
erosionSpinBox.setMinimum(0)
erosionSpinBox.connect('valueChanged(int)', self.setErosionRadius)
advancedFormLayout.addRow("Erosion Radius:", erosionSpinBox)
self.erosionSpinBox = erosionSpinBox
# Hole fill iterations spin box
holeFillSpinBox = qt.QSpinBox()
holeFillSpinBox.objectName = 'holeFillSpinBox'
holeFillSpinBox.toolTip = "Set the number of hole filling iterations."
holeFillSpinBox.setMinimum(0)
holeFillSpinBox.connect('valueChanged(int)',
self.setHoleFillIterations)
advancedFormLayout.addRow("Hole Fill Iterations:", holeFillSpinBox)
self.holeFillSpinBox = holeFillSpinBox
# falsePositiveRatio spin box
falsePositiveRatioSpinBox = qt.QDoubleSpinBox()
falsePositiveRatioSpinBox.objectName = 'falsePositiveRatioSpinBox'
falsePositiveRatioSpinBox.toolTip = "Relative Cost of False Positive vs. false negative."
falsePositiveRatioSpinBox.setMinimum(0.0)
falsePositiveRatioSpinBox.setValue(1.0) # Default
falsePositiveRatioSpinBox.setSingleStep(0.1)
advancedFormLayout.addRow("False Positive Ratio:",
falsePositiveRatioSpinBox)
self.falsePositiveRatioSpinBox = falsePositiveRatioSpinBox
# 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(3.0) # Default
probabilitySmoothingStdDevSpinBox.setSingleStep(0.1)
advancedFormLayout.addRow("Probability Smoothing Standard Deviation:",
probabilitySmoothingStdDevSpinBox)
self.probabilitySmoothingStdDevSpinBox = probabilitySmoothingStdDevSpinBox
# draft check box
draftCheckBox = qt.QCheckBox()
draftCheckBox.objectName = 'draftCheckBox'
draftCheckBox.toolTip = "Generate draft results?"
advancedFormLayout.addRow("Draft Mode:", draftCheckBox)
self.draftCheckBox = draftCheckBox
# reclassifyObjectMask check box
reclassifyObjectMaskCheckBox = qt.QCheckBox()
reclassifyObjectMaskCheckBox.objectName = 'reclassifyObjectMaskCheckBox'
reclassifyObjectMaskCheckBox.toolTip = "Perform classification on voxels within the object mask?"
reclassifyObjectMaskCheckBox.setChecked(True)
advancedFormLayout.addRow("Reclassify Object Mask:",
reclassifyObjectMaskCheckBox)
self.reclassifyObjectMaskCheckBox = reclassifyObjectMaskCheckBox
# reclassifyNotObjectMask check box
reclassifyNotObjectMaskCheckBox = qt.QCheckBox()
reclassifyNotObjectMaskCheckBox.objectName = 'reclassifyNotObjectMaskCheckBox'
reclassifyNotObjectMaskCheckBox.toolTip = "Perform classification on all non-void voxels?"
reclassifyNotObjectMaskCheckBox.setChecked(True)
advancedFormLayout.addRow("Reclassify Not Object Mask:",
reclassifyNotObjectMaskCheckBox)
self.reclassifyNotObjectMaskCheckBox = reclassifyNotObjectMaskCheckBox
# SEGMENTATION BUTTON
segmentCollapsibleButton = ctk.ctkCollapsibleButton()
segmentCollapsibleButton.text = "Run Segmentation"
self.layout.addWidget(segmentCollapsibleButton)
# Layout within the parameters collapsible button
segmentFormLayout = qt.QFormLayout(segmentCollapsibleButton)
# segmentation button
segmentationButton = qt.QPushButton("Segment")
segmentationButton.toolTip = "Perform PDF Segmentation."
segmentFormLayout.addRow(segmentationButton)
segmentationButton.connect('clicked()',
self.onSegmentationButtonClicked)
# Now that we've created all UI elements, apply the default goal segmentation type
self.setGoalSegmentationType(self.goalButtonDefault)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Inputs
inputsCollapsibleButton = ctk.ctkCollapsibleButton()
inputsCollapsibleButton.text = "Inputs"
self.layout.addWidget(inputsCollapsibleButton)
inputsFormLayout = qt.QFormLayout(inputsCollapsibleButton)
self.modelPointsSelector = slicer.qMRMLNodeComboBox()
self.modelPointsSelector.nodeTypes = ["vtkMRMLMarkupsFiducialNode"]
self.modelPointsSelector.selectNodeUponCreation = True
self.modelPointsSelector.addEnabled = True
self.modelPointsSelector.removeEnabled = True
self.modelPointsSelector.noneEnabled = True
self.modelPointsSelector.showHidden = False
self.modelPointsSelector.showChildNodeTypes = False
self.modelPointsSelector.setMRMLScene(slicer.mrmlScene)
self.modelPointsSelector.setToolTip(
"Pick the fiducials that define the cylinder top, bottom, and sphere centre."
)
inputsFormLayout.addRow("Model Fiducials: ", self.modelPointsSelector)
self.modelPointsSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onModelPointsSelected)
self.qSlider_SphereRadius = ctk.ctkSliderWidget()
self.qSlider_SphereRadius.singleStep = 0.1
self.qSlider_SphereRadius.minimum = 0
self.qSlider_SphereRadius.maximum = 20
self.qSlider_SphereRadius.value = 10
self.qSlider_SphereRadius.setToolTip("Set sphere radius.")
self.qSlider_SphereRadius.valueChanged.connect(self.onSliderChange)
inputsFormLayout.addRow("Sphere Radius: ", self.qSlider_SphereRadius)
self.qSlider_CylinderRadius = ctk.ctkSliderWidget()
self.qSlider_CylinderRadius.singleStep = 0.1
self.qSlider_CylinderRadius.minimum = 0
self.qSlider_CylinderRadius.maximum = 20
self.qSlider_CylinderRadius.value = 7.5
self.qSlider_CylinderRadius.setToolTip("Set cylinder radius.")
self.qSlider_CylinderRadius.valueChanged.connect(self.onSliderChange)
inputsFormLayout.addRow("Cylinder Radius: ",
self.qSlider_CylinderRadius)
self.qSlider_CylinderHeight = ctk.ctkSliderWidget()
self.qSlider_CylinderHeight.singleStep = 0.1
self.qSlider_CylinderHeight.minimum = 5
self.qSlider_CylinderHeight.maximum = 120
self.qSlider_CylinderHeight.value = 30
self.qSlider_CylinderHeight.setToolTip("Set cylinder height.")
self.qSlider_CylinderHeight.valueChanged.connect(self.onSliderChange)
inputsFormLayout.addRow("Cylinder Height", self.qSlider_CylinderHeight)
self.updateFibersButton = qt.QPushButton("Update the fibers")
self.updateFibersButton.toolTip = "Recalculate the fibers."
inputsFormLayout.addRow("Fiber and Grey Matter:",
self.updateFibersButton)
self.updateFibersButton.stateChanged.connect(
self.onUpdateFibersClicked)
self.writeScoresButton = qt.QPushButton("Save the scores")
self.writeScoresButton.toolTip = "Write the functional scores to disk."
inputsFormLayout.addRow("Calculate and save scores:",
self.writeScoresButton)
self.writeScoresButton.connect("clicked(bool)",
self.onSaveScoresClicked)
self.labeledAtlasVolumeSelector = slicer.qMRMLNodeComboBox()
self.labeledAtlasVolumeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.labeledAtlasVolumeSelector.selectNodeUponCreation = True
self.labeledAtlasVolumeSelector.addEnabled = False
self.labeledAtlasVolumeSelector.removeEnabled = False
self.labeledAtlasVolumeSelector.noneEnabled = True
self.labeledAtlasVolumeSelector.showHidden = False
self.labeledAtlasVolumeSelector.showChildNodeTypes = False
self.labeledAtlasVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.labeledAtlasVolumeSelector.setToolTip(
"Pick the Atlas-based Segmented Brain Volume.")
inputsFormLayout.addRow("Labeled Atlas Volume: ",
self.labeledAtlasVolumeSelector)
self.labeledAtlasVolumeSelector.connect(
"currentNodeChanged(vtkMRMLNode*)",
self.onLabeledAtlasVolumeChanged)
# Generate a rectangular Box for Score Guidance
self.Rec_Box = slicer.qMRMLNodeComboBox()
self.Rec_Box.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.Rec_Box.selectNodeUponCreation = True
self.Rec_Box.addEnabled = True
self.Rec_Box.removeEnabled = True
self.Rec_Box.noneEnabled = True
self.Rec_Box.showHidden = False
self.Rec_Box.showChildNodeTypes = False
self.Rec_Box.setMRMLScene(slicer.mrmlScene)
self.Rec_Box.setToolTip("Pick the Atlas-based Segmented Brain Volume.")
inputsFormLayout.addRow("Generate the Score Box: ", self.Rec_Box)
self.Rec_Box.connect(
"currentNodeChanged(vtkMRMLNode*)",
self.OnSelect_Rec_Box) # missing self.OnSelect_label function
self.skullMaskVolumeSelector = slicer.qMRMLNodeComboBox()
self.skullMaskVolumeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.skullMaskVolumeSelector.selectNodeUponCreation = False
self.skullMaskVolumeSelector.addEnabled = False
self.skullMaskVolumeSelector.removeEnabled = False
self.skullMaskVolumeSelector.noneEnabled = True
self.skullMaskVolumeSelector.showHidden = False
self.skullMaskVolumeSelector.showChildNodeTypes = False
self.skullMaskVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.skullMaskVolumeSelector.setToolTip("Pick the skull mask volume.")
inputsFormLayout.addRow("Skull Mask Volume: ",
self.skullMaskVolumeSelector)
self.skullMaskVolumeSelector.connect(
"currentNodeChanged(vtkMRMLNode*)", self.onSkullMaskChanged)
self.tractographyFibreBundleSelector = slicer.qMRMLNodeComboBox()
self.tractographyFibreBundleSelector.nodeTypes = [
"vtkMRMLFiberBundleNode"
]
self.tractographyFibreBundleSelector.selectNodeUponCreation = True
self.tractographyFibreBundleSelector.addEnabled = False
self.tractographyFibreBundleSelector.removeEnabled = False
self.tractographyFibreBundleSelector.noneEnabled = True
self.tractographyFibreBundleSelector.showHidden = False
self.tractographyFibreBundleSelector.showChildNodeTypes = False
self.tractographyFibreBundleSelector.setMRMLScene(slicer.mrmlScene)
self.tractographyFibreBundleSelector.setToolTip(
"Pick the full-brain Tractography file.")
inputsFormLayout.addRow("Tractography Fiber Bundle: ",
self.tractographyFibreBundleSelector)
self.tractographyFibreBundleSelector.connect(
"currentNodeChanged(vtkMRMLNode*)", self.onFiberBundleChanged)
self.roiSelector = slicer.qMRMLNodeComboBox()
self.roiSelector.nodeTypes = ["vtkMRMLAnnotationROINode"]
self.roiSelector.selectNodeUponCreation = True
self.roiSelector.addEnabled = True
self.roiSelector.removeEnabled = True
self.roiSelector.noneEnabled = True
self.roiSelector.showHidden = False
self.roiSelector.showChildNodeTypes = False
self.roiSelector.setMRMLScene(slicer.mrmlScene)
self.roiSelector.setToolTip(
"Pick the ROI to define the region for labeling of fibers.")
inputsFormLayout.addRow("Labeling ROI: ", self.roiSelector)
self.roiSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onRoiChanged)
self.saveArrayButton = qt.QPushButton("Generate and Save Arrays")
self.saveArrayButton.toolTip = "Run the algorithm!"
inputsFormLayout.addRow(self.saveArrayButton)
self.saveArrayButton.connect('clicked(bool)', self.onSaveArrayClicked)
self.loadArrayButton = qt.QPushButton("Load Saved Array")
self.loadArrayButton.toolTip = "Run the algorithm!"
inputsFormLayout.addRow(self.loadArrayButton)
self.loadArrayButton.connect('clicked(bool)', self.onLoadArrayClicked)
# output fiberbundle generator
self.fiberOutputSelector = slicer.qMRMLNodeComboBox()
self.fiberOutputSelector.nodeTypes = ["vtkMRMLFiberBundleNode"]
self.fiberOutputSelector.selectNodeUponCreation = True
self.fiberOutputSelector.addEnabled = True
self.fiberOutputSelector.removeEnabled = True
self.fiberOutputSelector.noneEnabled = True
self.fiberOutputSelector.showHidden = False
self.fiberOutputSelector.showChildNodeTypes = False
self.fiberOutputSelector.setMRMLScene(slicer.mrmlScene)
self.fiberOutputSelector.setToolTip(
"Create or pick the output fiber bundle node.")
inputsFormLayout.addRow("Output fiber bundle: ",
self.fiberOutputSelector)
self.fiberOutputSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onOutputFiberChanged)
# Input the Models Hierarchy Node
self.brainSurfaceModelSelector = slicer.qMRMLNodeComboBox()
self.brainSurfaceModelSelector.nodeTypes = [
"vtkMRMLModelHierarchyNode"
]
self.brainSurfaceModelSelector.selectNodeUponCreation = True
self.brainSurfaceModelSelector.addEnabled = False
self.brainSurfaceModelSelector.removeEnabled = False
self.brainSurfaceModelSelector.noneEnabled = True
self.brainSurfaceModelSelector.showHidden = False
self.brainSurfaceModelSelector.showChildNodeTypes = False
self.brainSurfaceModelSelector.setMRMLScene(slicer.mrmlScene)
self.brainSurfaceModelSelector.setToolTip(
"Pick the Hierarchy of Brain Surface Models.")
inputsFormLayout.addRow("Brain surface models: ",
self.brainSurfaceModelSelector)
self.brainSurfaceModelSelector.connect(
"currentNodeChanged(vtkMRMLNode*)", self.brainSurfaceModelChanged)
# Apply Button
radioLayout = qt.QHBoxLayout()
buttonGroup = qt.QButtonGroup()
self.radioButtons = []
self.radioButtons.append(qt.QRadioButton('FC_GM'))
self.radioButtons.append(qt.QRadioButton('SC_GM'))
self.radioButtons.append(qt.QRadioButton('Opacity_reset'))
buttonGroup.addButton(self.radisButtons[0], 0)
buttonGroup.addButton(self.radioButtons[1], 1)
buttonGroup.addButton(self.radioButtons[2], 2)
radioLayout.addWidget(self.radioButtons[0])
radioLayout.addWidget(self.radioButtons[1])
radioLayout.addWidget(self.radioButtons[2])
inputsFormLayout.addRow("Select the Grey Matter Score to paint: ",
radioLayout)
self.radioButtons[0].connect(
'clicked()', self.functionConnectivityGreyMatterClicked)
self.radioButtons[1].connect(
'clicked()', self.structuralConnectivityGreyMatterClicked)
self.radioButtons[2].connect('clicked()', self.resetModelOpacities)
self.runOptimizationButton = qt.QPushButton("Run the Optimization")
self.runOptimizationButton.toolTip = "Run the algorithm!"
inputsFormLayout.addRow("Run optimization: ",
self.runOptimizationButton)
self.runOptimizationButton.connect("clicked(bool)",
self.onRunOptimizationClicked)
def buildGUI(self, parent):
registrationLayout = qt.QFormLayout(parent)
# From/To Catheters
self.fromCatheterComboBox = QComboBoxCatheter()
self.fromCatheterComboBox.setCatheterCollection(self.catheters)
self.fromCatheterComboBox.currentIndexChanged.connect(self.onFromCatheterSelected)
registrationLayout.addRow("Catheter (From): ", self.fromCatheterComboBox)
self.toCatheterComboBox = QComboBoxCatheter()
self.toCatheterComboBox.setCatheterCollection(self.catheters)
self.toCatheterComboBox.currentIndexChanged.connect(self.onToCatheterSelected)
registrationLayout.addRow("Catheter (To): ", self.toCatheterComboBox)
# Registration Fiducials
self.fromFiducialsSelector = slicer.qMRMLNodeComboBox()
self.fromFiducialsSelector.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" )
self.fromFiducialsSelector.selectNodeUponCreation = False
self.fromFiducialsSelector.addEnabled = True
self.fromFiducialsSelector.removeEnabled = False
self.fromFiducialsSelector.noneEnabled = True
self.fromFiducialsSelector.showHidden = True
self.fromFiducialsSelector.showChildNodeTypes = False
self.fromFiducialsSelector.setMRMLScene( slicer.mrmlScene )
self.fromFiducialsSelector.setToolTip( "Registration fiducials obtained by the 'To' catheter." )
registrationLayout.addRow("Fiducials (From): ", self.fromFiducialsSelector)
self.toFiducialsSelector = slicer.qMRMLNodeComboBox()
self.toFiducialsSelector.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" )
self.toFiducialsSelector.selectNodeUponCreation = False
self.toFiducialsSelector.addEnabled = True
self.toFiducialsSelector.removeEnabled = False
self.toFiducialsSelector.noneEnabled = True
self.toFiducialsSelector.showHidden = True
self.toFiducialsSelector.showChildNodeTypes = False
self.toFiducialsSelector.setMRMLScene( slicer.mrmlScene )
self.toFiducialsSelector.setToolTip( "Registration fiducials obtained by the 'From' catheter." )
registrationLayout.addRow("Fiducials (To): ", self.toFiducialsSelector)
# #
# # Fiducial points used (either "tip only" or "all"
# #
#
# pointBoxLayout = qt.QHBoxLayout()
# self.pointGroup = qt.QButtonGroup()
#
# self.useTipRadioButton = qt.QRadioButton("Tip")
# self.useAllRadioButton = qt.QRadioButton("All ")
# self.useAllRadioButton.checked = 1
# pointBoxLayout.addWidget(self.useTipRadioButton)
# self.pointGroup.addButton(self.useTipRadioButton)
# pointBoxLayout.addWidget(self.useAllRadioButton)
# self.pointGroup.addButton(self.useAllRadioButton)
#
# registrationLayout.addRow("Points: ", pointBoxLayout)
#
#
# Fiducial points visibility
#
visibilityBoxLayout = qt.QHBoxLayout()
self.visibilityGroup = qt.QButtonGroup()
self.visibilityOnRadioButton = qt.QRadioButton("ON")
self.visibilityOffRadioButton = qt.QRadioButton("Off")
self.visibilityOffRadioButton.checked = 1
visibilityBoxLayout.addWidget(self.visibilityOnRadioButton)
self.visibilityGroup.addButton(self.visibilityOnRadioButton)
visibilityBoxLayout.addWidget(self.visibilityOffRadioButton)
self.visibilityGroup.addButton(self.visibilityOffRadioButton)
registrationLayout.addRow("Visibility: ", visibilityBoxLayout)
#
# Transform Type
#
transTypeBoxLayout = qt.QHBoxLayout()
self.transTypeGroup = qt.QButtonGroup()
self.rigidTypeRadioButton = qt.QRadioButton("Rigid")
self.affineTypeRadioButton = qt.QRadioButton("Affine")
self.splineTypeRadioButton = qt.QRadioButton("Thin Plate Spline")
self.rigidTypeRadioButton.checked = 1
transTypeBoxLayout.addWidget(self.rigidTypeRadioButton)
self.transTypeGroup.addButton(self.rigidTypeRadioButton)
transTypeBoxLayout.addWidget(self.affineTypeRadioButton)
self.transTypeGroup.addButton(self.affineTypeRadioButton)
transTypeBoxLayout.addWidget(self.splineTypeRadioButton)
self.transTypeGroup.addButton(self.splineTypeRadioButton)
registrationLayout.addRow("Transform Type: ", transTypeBoxLayout)
#
# Automatic Update
#
autoUpdateBoxLayout = qt.QHBoxLayout()
self.autoUpdateGroup = qt.QButtonGroup()
self.autoUpdateOnRadioButton = qt.QRadioButton("ON")
self.autoUpdateOffRadioButton = qt.QRadioButton("OFF")
self.autoUpdateOffRadioButton.checked = 1
autoUpdateBoxLayout.addWidget(self.autoUpdateOnRadioButton)
self.autoUpdateGroup.addButton(self.autoUpdateOnRadioButton)
autoUpdateBoxLayout.addWidget(self.autoUpdateOffRadioButton)
self.autoUpdateGroup.addButton(self.autoUpdateOffRadioButton)
registrationLayout.addRow("Automatic Update: ", autoUpdateBoxLayout)
#
# Overwrite Transform
#
overwriteTransformBoxLayout = qt.QHBoxLayout()
self.overwriteTransformGroup = qt.QButtonGroup()
self.overwriteTransformOnRadioButton = qt.QRadioButton("ON")
self.overwriteTransformOffRadioButton = qt.QRadioButton("OFF")
self.overwriteTransformOffRadioButton.checked = 1
overwriteTransformBoxLayout.addWidget(self.overwriteTransformOnRadioButton)
self.overwriteTransformGroup.addButton(self.overwriteTransformOnRadioButton)
overwriteTransformBoxLayout.addWidget(self.overwriteTransformOffRadioButton)
self.overwriteTransformGroup.addButton(self.overwriteTransformOffRadioButton)
registrationLayout.addRow("Overwrite Transform: ", overwriteTransformBoxLayout)
#
# Parameters for point selections
#
# Maximum time difference between the corresponding points from the two trackers.
self.maxTimeDifferenceSliderWidget = ctk.ctkSliderWidget()
self.maxTimeDifferenceSliderWidget.singleStep = 10.0
self.maxTimeDifferenceSliderWidget.minimum = 0.0
self.maxTimeDifferenceSliderWidget.maximum = 10000.0
self.maxTimeDifferenceSliderWidget.value = self.maxTimeDifference * 1000.0
#self.maxTimeDifferenceSliderWidget.setToolTip("")
registrationLayout.addRow("Max. Time Diff (ms): ", self.maxTimeDifferenceSliderWidget)
# Minimum interval between two consecutive registrations
self.minIntervalSliderWidget = ctk.ctkSliderWidget()
self.minIntervalSliderWidget.singleStep = 10.0
self.minIntervalSliderWidget.minimum = 0.0
self.minIntervalSliderWidget.maximum = 10000.0
self.minIntervalSliderWidget.value = self.minInterval * 1000.0
#self.minIntervalSliderWidget.setToolTip("")
registrationLayout.addRow("Min. Registration Interval (ms): ", self.minIntervalSliderWidget)
# Minimum interval between two consecutive registrations
self.pointExpirationSliderWidget = ctk.ctkSliderWidget()
self.pointExpirationSliderWidget.singleStep = 5.0
self.pointExpirationSliderWidget.minimum = 0.0
self.pointExpirationSliderWidget.maximum = 1000.0
self.pointExpirationSliderWidget.value = self.pointExpiration
#self.minIntervalSliderWidget.setToolTip("")
registrationLayout.addRow("Point Exp. (s): ", self.pointExpirationSliderWidget)
#
# Collect/Clear button
#
buttonBoxLayout = qt.QHBoxLayout()
self.collectButton = qt.QPushButton()
self.collectButton.setCheckable(False)
self.collectButton.text = 'Collect'
self.collectButton.setToolTip("Collect points from the catheters.")
buttonBoxLayout.addWidget(self.collectButton)
self.clearButton = qt.QPushButton()
self.clearButton.setCheckable(False)
self.clearButton.text = 'Clear'
self.clearButton.setToolTip("Clear the collected points from the list.")
buttonBoxLayout.addWidget(self.clearButton)
registrationLayout.addRow("", buttonBoxLayout)
#
# Registration button
#
#runBoxLayout = qt.QHBoxLayout()
self.runButton = qt.QPushButton()
self.runButton.setCheckable(False)
self.runButton.text = 'Run Registration'
self.runButton.setToolTip("Run fiducial registration.")
#buttonBoxLayout.addWidget(self.runButton)
registrationLayout.addRow("", self.runButton)
#
# Apply transform
#
applyTransformBoxLayout = qt.QHBoxLayout()
self.applyTransformGroup = qt.QButtonGroup()
self.applyTransformOnRadioButton = qt.QRadioButton("ON")
self.applyTransformOffRadioButton = qt.QRadioButton("Off")
self.applyTransformOffRadioButton.checked = 1
applyTransformBoxLayout.addWidget(self.applyTransformOnRadioButton)
self.applyTransformGroup.addButton(self.applyTransformOnRadioButton)
applyTransformBoxLayout.addWidget(self.applyTransformOffRadioButton)
self.applyTransformGroup.addButton(self.applyTransformOffRadioButton)
registrationLayout.addRow("Apply Transform: ", applyTransformBoxLayout)
#
# Fiducial Registration Error
#
self.freLineEdit = qt.QLineEdit()
self.freLineEdit.text = '--'
self.freLineEdit.readOnly = True
self.freLineEdit.frame = True
self.freLineEdit.styleSheet = "QLineEdit { background:transparent; }"
registrationLayout.addRow("FRE (mm): ", self.freLineEdit)
#
# Combined tracking
#
self.trackingDataSelector = slicer.qMRMLNodeComboBox()
self.trackingDataSelector.nodeTypes = ( ("vtkMRMLIGTLTrackingDataBundleNode"), "" )
self.trackingDataSelector.selectNodeUponCreation = True
self.trackingDataSelector.addEnabled = True
self.trackingDataSelector.removeEnabled = False
self.trackingDataSelector.noneEnabled = True
self.trackingDataSelector.showHidden = True
self.trackingDataSelector.showChildNodeTypes = False
self.trackingDataSelector.setMRMLScene( slicer.mrmlScene )
self.trackingDataSelector.setToolTip( "Combine tracking data from two sources. The combined data can be used to visualize them as a single catheter." )
registrationLayout.addRow("Combined Tracking: ", self.trackingDataSelector)
#
# Connect signals and slots
#
self.fromFiducialsSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onFromFiducialsSelected)
self.toFiducialsSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onToFiducialsSelected)
self.collectButton.connect(qt.SIGNAL("clicked()"), self.onCollectPoints)
self.clearButton.connect(qt.SIGNAL("clicked()"), self.onClearPoints)
self.runButton.connect(qt.SIGNAL("clicked()"), self.onRunRegistration)
self.visibilityOnRadioButton.connect("clicked(bool)", self.onVisibilityChanged)
self.visibilityOffRadioButton.connect("clicked(bool)", self.onVisibilityChanged)
self.applyTransformOnRadioButton.connect("clicked(bool)", self.onApplyTransformChanged)
self.applyTransformOffRadioButton.connect("clicked(bool)", self.onApplyTransformChanged)
self.autoUpdateOnRadioButton.connect("clicked(bool)", self.onAutoUpdateChanged)
self.autoUpdateOffRadioButton.connect("clicked(bool)", self.onAutoUpdateChanged)
self.maxTimeDifferenceSliderWidget.connect("valueChanged(double)", self.onPointSelectionParametersChanged)
self.minIntervalSliderWidget.connect("valueChanged(double)", self.onPointSelectionParametersChanged)
self.pointExpirationSliderWidget.connect("valueChanged(double)", self.onPointSelectionParametersChanged)
self.trackingDataSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onTrackingDataSelected)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Setup a logger for the extension log messages (child logger of pyradiomics)
self.logger = logging.getLogger(radiomics.logger.name + '.slicer')
# 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.selectNodeUponCreation = True
self.inputVolumeSelector.addEnabled = False
self.inputVolumeSelector.removeEnabled = False
self.inputVolumeSelector.noneEnabled = False
self.inputVolumeSelector.showHidden = False
self.inputVolumeSelector.showChildNodeTypes = False
self.inputVolumeSelector.setMRMLScene(slicer.mrmlScene)
self.inputVolumeSelector.setToolTip(
'Pick the input image for the feature calculation.')
parametersFormLayout.addRow('Input Image Volume: ',
self.inputVolumeSelector)
#
# input mask volume selector
#
self.inputMaskSelector = slicer.qMRMLNodeComboBox()
self.inputMaskSelector.nodeTypes = ['vtkMRMLLabelMapVolumeNode']
self.inputMaskSelector.selectNodeUponCreation = True
self.inputMaskSelector.addEnabled = False
self.inputMaskSelector.removeEnabled = False
self.inputMaskSelector.noneEnabled = True
self.inputMaskSelector.showHidden = False
self.inputMaskSelector.showChildNodeTypes = False
self.inputMaskSelector.setMRMLScene(slicer.mrmlScene)
self.inputMaskSelector.setToolTip(
'Pick the input mask for the feature calculation.')
parametersFormLayout.addRow('Input LabelMap: ', self.inputMaskSelector)
#
# input segmentation selector
#
self.inputSegmentationSelector = slicer.qMRMLNodeComboBox()
self.inputSegmentationSelector.nodeTypes = ['vtkMRMLSegmentationNode']
self.inputSegmentationSelector.selectNodeUponCreation = True
self.inputSegmentationSelector.addEnabled = False
self.inputSegmentationSelector.removeEnabled = False
self.inputSegmentationSelector.noneEnabled = True
self.inputSegmentationSelector.showHidden = False
self.inputSegmentationSelector.showChildNodeTypes = False
self.inputSegmentationSelector.setMRMLScene(slicer.mrmlScene)
self.inputSegmentationSelector.setToolTip(
'Pick the input segmentation for the feature calculation.')
parametersFormLayout.addRow('Input Segmentation: ',
self.inputSegmentationSelector)
#
# Feature class selection
#
self.featuresLayout = qt.QHBoxLayout()
parametersFormLayout.addRow('Features:', self.featuresLayout)
self.featuresButtonGroup = qt.QButtonGroup(self.featuresLayout)
self.featuresButtonGroup.exclusive = False
# Get the feature classes dynamically
self.features = getFeatureClasses().keys()
# Create a checkbox for each feature
featureButtons = {}
for feature in self.features:
featureButtons[feature] = qt.QCheckBox(feature)
# TODO: decide which features to enable by default
featureButtons[feature].checked = False
if feature == 'firstorder':
featureButtons[feature].checked = True
self.featuresButtonGroup.addButton(featureButtons[feature])
self.featuresLayout.layout().addWidget(featureButtons[feature])
# set the ID to be the index of this feature in the list
self.featuresButtonGroup.setId(featureButtons[feature],
self.features.index(feature))
# Add buttons to select all or none
self.buttonsLayout = qt.QHBoxLayout()
parametersFormLayout.addRow('Toggle Features:', self.buttonsLayout)
self.calculateAllFeaturesButton = qt.QPushButton('All Features')
self.calculateAllFeaturesButton.toolTip = 'Calculate all feature classes.'
self.calculateAllFeaturesButton.enabled = True
self.buttonsLayout.addWidget(self.calculateAllFeaturesButton)
self.calculateNoFeaturesButton = qt.QPushButton('No Features')
self.calculateNoFeaturesButton.toolTip = 'Calculate no feature classes.'
self.calculateNoFeaturesButton.enabled = True
self.buttonsLayout.addWidget(self.calculateNoFeaturesButton)
#
# Feature calculation options
#
optionsCollapsibleButton = ctk.ctkCollapsibleButton()
optionsCollapsibleButton.text = 'Options'
optionsCollapsibleButton.collapsed = True
self.layout.addWidget(optionsCollapsibleButton)
# Layout within the dummy collapsible button
optionsFormLayout = qt.QFormLayout(optionsCollapsibleButton)
# bin width, defaults to 25
self.binWidthSliderWidget = ctk.ctkSliderWidget()
self.binWidthSliderWidget.singleStep = 1
self.binWidthSliderWidget.decimals = 0
self.binWidthSliderWidget.minimum = 1
self.binWidthSliderWidget.maximum = 100
self.binWidthSliderWidget.value = 25
self.binWidthSliderWidget.toolTip = 'Set the bin width'
optionsFormLayout.addRow('Bin Width', self.binWidthSliderWidget)
# symmetricalGLCM flag, defaults to false
self.symmetricalGLCMCheckBox = qt.QCheckBox()
self.symmetricalGLCMCheckBox.checked = 1
self.symmetricalGLCMCheckBox.toolTip = 'Use a symmetrical GLCM matrix'
optionsFormLayout.addRow('Enforce Symmetrical GLCM',
self.symmetricalGLCMCheckBox)
# label for the mask, defaults to 1
self.labelSliderWidget = ctk.ctkSliderWidget()
self.labelSliderWidget.singleStep = 1
self.labelSliderWidget.decimals = 0
self.labelSliderWidget.minimum = 0
self.labelSliderWidget.maximum = 255
self.labelSliderWidget.value = 1
self.labelSliderWidget.toolTip = 'Set the label to use for masking the image'
# optionsFormLayout.addRow('Label', self.labelSliderWidget)
# debug logging flag, defaults to false
self.debuggingCheckBox = qt.QCheckBox()
self.debuggingCheckBox.checked = 0
self.debuggingCheckBox.toolTip = \
'If checked, PyRadiomics log messages from level DEBUG and higher will be added to the slicer log'
optionsFormLayout.addRow('Store debug log', self.debuggingCheckBox)
#
# Output table
#
outputCollapsibleButton = ctk.ctkCollapsibleButton()
outputCollapsibleButton.text = 'Output'
self.layout.addWidget(outputCollapsibleButton)
outputFormLayout = qt.QFormLayout(outputCollapsibleButton)
self.outputTableSelector = slicer.qMRMLNodeComboBox()
self.outputTableSelector.nodeTypes = ['vtkMRMLTableNode']
self.outputTableSelector.addEnabled = True
self.outputTableSelector.selectNodeUponCreation = True
self.outputTableSelector.renameEnabled = True
self.outputTableSelector.removeEnabled = True
self.outputTableSelector.noneEnabled = False
self.outputTableSelector.setMRMLScene(slicer.mrmlScene)
self.outputTableSelector.toolTip = \
'Select the table where features will be saved, resets feature values on each run.'
outputFormLayout.addRow('Output table:', self.outputTableSelector)
#
# Apply Button
#
self.applyButton = qt.QPushButton('Apply')
self.applyButton.toolTip = 'Run the algorithm.'
self.applyButton.enabled = False
self.layout.addWidget(self.applyButton)
# connections
self.calculateAllFeaturesButton.connect(
'clicked(bool)', self.onCalculateAllFeaturesButton)
self.calculateNoFeaturesButton.connect(
'clicked(bool)', self.onCalculateNoFeaturesButton)
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputVolumeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.onSelect)
self.inputMaskSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.onSelect)
self.inputSegmentationSelector.connect(
'currentNodeChanged(vtkMRMLNode*)', self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
# Refresh Apply button state
self.onSelect()
def setup(self):
"""This is called one time when the module GUI is initialized
"""
ScriptedLoadableModuleWidget.setup(self)
# Create objects that can be used anywhere in the module. Example: in most cases there should be just one
# object of the logic class
self.logic = CIP_ParenchymaSubtypeTrainingLogic()
self.currentVolumeLoaded = None
self.blockNodeEvents = False
##########
# Main area
self.mainAreaCollapsibleButton = ctk.ctkCollapsibleButton()
self.mainAreaCollapsibleButton.text = "Main area"
self.layout.addWidget(self.mainAreaCollapsibleButton,
SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.mainLayout = qt.QGridLayout(self.mainAreaCollapsibleButton)
# Node selector
volumeLabel = qt.QLabel("Active volume: ")
volumeLabel.setStyleSheet("margin-left:5px")
self.mainLayout.addWidget(volumeLabel, 0, 0)
self.volumeSelector = slicer.qMRMLNodeComboBox()
self.volumeSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "")
self.volumeSelector.selectNodeUponCreation = True
self.volumeSelector.autoFillBackground = True
self.volumeSelector.addEnabled = False
self.volumeSelector.noneEnabled = False
self.volumeSelector.removeEnabled = False
self.volumeSelector.showHidden = False
self.volumeSelector.showChildNodeTypes = False
self.volumeSelector.setMRMLScene(slicer.mrmlScene)
self.volumeSelector.setFixedWidth(250)
self.volumeSelector.setStyleSheet("margin: 15px 0")
#self.volumeSelector.selectNodeUponCreation = False
self.mainLayout.addWidget(self.volumeSelector, 0, 1, 1, 3)
labelsStyle = "font-weight: bold; margin: 0 0 5px 5px;"
# Types Radio Buttons
typesLabel = qt.QLabel("Select the type")
typesLabel.setStyleSheet(labelsStyle)
typesLabel.setFixedHeight(15)
self.mainLayout.addWidget(typesLabel, 1, 0)
self.typesFrame = qt.QFrame()
self.typesLayout = qt.QVBoxLayout(self.typesFrame)
self.mainLayout.addWidget(self.typesFrame, 2, 0,
SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.typesRadioButtonGroup = qt.QButtonGroup()
for key in self.logic.params.mainTypes.iterkeys():
rbitem = qt.QRadioButton(self.logic.params.getMainTypeLabel(key))
self.typesRadioButtonGroup.addButton(rbitem, key)
self.typesLayout.addWidget(rbitem)
self.typesRadioButtonGroup.buttons()[0].setChecked(True)
# Subtypes Radio buttons
subtypesLabel = qt.QLabel("Select the subtype")
subtypesLabel.setStyleSheet(labelsStyle)
subtypesLabel.setFixedHeight(15)
self.mainLayout.addWidget(subtypesLabel, 1, 1)
self.subtypesRadioButtonGroup = qt.QButtonGroup()
self.subtypesFrame = qt.QFrame()
self.subtypesFrame.setMinimumHeight(275)
self.subtypesLayout = qt.QVBoxLayout(self.subtypesFrame)
self.subtypesLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.subtypesLayout.setStretch(0, 0)
self.mainLayout.addWidget(
self.subtypesFrame, 2, 1,
SlicerUtil.ALIGNMENT_VERTICAL_TOP) # Put the frame in the top
# The content will be loaded dynamically every time the main type is modified
# Artifact radio buttons
self.artifactsLabel = qt.QLabel("Artifact")
self.artifactsLabel.setStyleSheet(labelsStyle)
self.artifactsLabel.setFixedHeight(15)
self.mainLayout.addWidget(self.artifactsLabel, 1, 2)
#self.mainLayout.addWidget(qt.QLabel("Select the artifact"), 1, 1)
self.artifactsRadioButtonGroup = qt.QButtonGroup()
self.artifactsFrame = qt.QFrame()
self.artifactsLayout = qt.QVBoxLayout(self.artifactsFrame)
self.mainLayout.addWidget(self.artifactsFrame, 2, 2,
SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.artifactsRadioButtonGroup = qt.QButtonGroup()
for artifactId in self.logic.params.artifacts.iterkeys():
rbitem = qt.QRadioButton(
self.logic.params.getArtifactLabel(artifactId))
self.artifactsRadioButtonGroup.addButton(rbitem, artifactId)
self.artifactsLayout.addWidget(rbitem)
self.artifactsRadioButtonGroup.buttons()[0].setChecked(True)
# Load caselist button
self.loadButton = ctk.ctkPushButton()
self.loadButton.text = "Load fiducials file"
self.loadButton.setIcon(
qt.QIcon("{0}/open_file.png".format(SlicerUtil.CIP_ICON_DIR)))
self.loadButton.setIconSize(qt.QSize(20, 20))
self.loadButton.setFixedWidth(135)
self.mainLayout.addWidget(self.loadButton, 3, 0)
# Remove fiducial button
self.removeLastFiducialButton = ctk.ctkPushButton()
self.removeLastFiducialButton.text = "Remove last fiducial"
self.removeLastFiducialButton.toolTip = "Remove the last fiducial added"
self.removeLastFiducialButton.setIcon(
qt.QIcon("{0}/delete.png".format(SlicerUtil.CIP_ICON_DIR)))
self.removeLastFiducialButton.setIconSize(qt.QSize(20, 20))
self.removeLastFiducialButton.setFixedWidth(200)
self.mainLayout.addWidget(self.removeLastFiducialButton, 3, 1)
# Save results button
self.saveResultsButton = ctk.ctkPushButton()
self.saveResultsButton.setText("Save markups")
self.saveResultsButton.toolTip = "Save the markups in the specified directory"
self.saveResultsButton.setIcon(
qt.QIcon("{0}/Save.png".format(SlicerUtil.CIP_ICON_DIR)))
self.saveResultsButton.setIconSize(qt.QSize(20, 20))
self.mainLayout.addWidget(self.saveResultsButton, 4, 0)
# Save results directory button
defaultPath = os.path.join(
SlicerUtil.getSettingsDataFolder(self.moduleName),
"results") # Assign a default path for the results
path = SlicerUtil.settingGetOrSetDefault(self.moduleName,
"SaveResultsDirectory",
defaultPath)
self.saveResultsDirectoryButton = ctk.ctkDirectoryButton()
self.saveResultsDirectoryButton.directory = path
self.saveResultsDirectoryButton.setMaximumWidth(375)
self.mainLayout.addWidget(self.saveResultsDirectoryButton, 4, 1, 1, 2)
#####
# Case navigator
self.caseNavigatorWidget = None
if SlicerUtil.isSlicerACILLoaded():
caseNavigatorAreaCollapsibleButton = ctk.ctkCollapsibleButton()
caseNavigatorAreaCollapsibleButton.text = "Case navigator"
self.layout.addWidget(caseNavigatorAreaCollapsibleButton, 0x0020)
# caseNavigatorLayout = qt.QVBoxLayout(caseNavigatorAreaCollapsibleButton)
# Add a case list navigator
from ACIL.ui import CaseNavigatorWidget
self.caseNavigatorWidget = CaseNavigatorWidget(
self.moduleName, caseNavigatorAreaCollapsibleButton)
self.caseNavigatorWidget.setup()
# Listen for the event of loading a new labelmap
self.caseNavigatorWidget.addObservable(
self.caseNavigatorWidget.EVENT_LABELMAP_LOADED,
self.__onNewILDClassificationLabelmapLoaded__)
self.layout.addStretch()
self.updateState()
# Connections
self.typesRadioButtonGroup.connect("buttonClicked (QAbstractButton*)",
self.__onTypesRadioButtonClicked__)
self.subtypesRadioButtonGroup.connect(
"buttonClicked (QAbstractButton*)",
self.__onSubtypesRadioButtonClicked__)
self.artifactsRadioButtonGroup.connect(
"buttonClicked (QAbstractButton*)",
self.__onSubtypesRadioButtonClicked__)
self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.__onCurrentNodeChanged__)
self.loadButton.connect('clicked()', self.openFiducialsFile)
self.removeLastFiducialButton.connect(
'clicked()', self.__onRemoveLastFiducialButtonClicked__)
# self.saveResultsOpenDirectoryDialogButton.connect('clicked()', self.onOpenDirectoryDialogButtonClicked)
self.saveResultsDirectoryButton.connect(
"directoryChanged (QString)",
self.__onSaveResultsDirectoryChanged__)
self.saveResultsButton.connect('clicked()',
self.__onSaveResultsButtonClicked__)
self.observers = []
self.observers.append(
slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.NodeAddedEvent,
self.__onNodeAddedObserver__))
self.observers.append(
slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.EndCloseEvent,
self.__onSceneClosed__))
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
self.logic = NeuroSegmentLogic()
uiWidget = slicer.util.loadUI(self.resourcePath('UI/NeuroSegment.ui'))
self.layout.addWidget(uiWidget)
self.ui = slicer.util.childWidgetVariables(uiWidget)
self.ui.segmentEditorWidget.connect(
"masterVolumeNodeChanged (vtkMRMLVolumeNode *)",
self.onMasterVolumeNodeChanged)
self.ui.undockSliceViewButton.connect('clicked()',
self.toggleSliceViews)
self.ui.infoExpandableWidget.setVisible(False)
self.segmentationNodeComboBox = self.ui.segmentEditorWidget.findChild(
slicer.qMRMLNodeComboBox, "SegmentationNodeComboBox")
self.segmentationNodeComboBox.nodeAddedByUser.connect(
self.onNodeAddedByUser)
self.neuroSegHistogramMethodButtonGroup = qt.QButtonGroup()
self.neuroSegHistogramMethodButtonGroup.setExclusive(True)
thresholdEffects = [
self.ui.segmentEditorWidget.effectByName("Threshold"),
self.ui.segmentEditorWidget.effectByName("LocalThreshold")
]
for thresholdEffect in thresholdEffects:
if thresholdEffect is None:
continue
lowerLayout = thresholdEffect.self(
).histogramLowerThresholdAverageButton.parentWidget().layout()
upperLayout = thresholdEffect.self(
).histogramUpperThresholdAverageButton.parentWidget().layout()
thresholdEffect.self().histogramLowerThresholdAverageButton.hide()
thresholdEffect.self().histogramLowerThresholdLowerButton.hide()
thresholdEffect.self().histogramLowerThresholdMinimumButton.hide()
thresholdEffect.self().histogramUpperThresholdAverageButton.hide()
thresholdEffect.self().histogramUpperThresholdUpperButton.hide()
thresholdEffect.self().histogramUpperThresholdMaximumButton.hide()
self.histogramMinAverageThresholdButton = qt.QPushButton()
self.histogramMinAverageThresholdButton.setText(
"Minimum to average")
self.histogramMinAverageThresholdButton.setCheckable(True)
self.histogramMinAverageThresholdButton.clicked.connect(
self.updateHistogram)
self.histogramMinAverageThresholdButton.checked = True
lowerLayout.addWidget(self.histogramMinAverageThresholdButton)
self.neuroSegHistogramMethodButtonGroup.addButton(
self.histogramMinAverageThresholdButton)
self.histogramAverageMaxThresholdButton = qt.QPushButton()
self.histogramAverageMaxThresholdButton.setText(
"Average to maximum")
self.histogramAverageMaxThresholdButton.setCheckable(True)
self.histogramAverageMaxThresholdButton.clicked.connect(
self.updateHistogram)
self.histogramMinAverageThresholdButton.checked = False
upperLayout.addWidget(self.histogramAverageMaxThresholdButton)
self.neuroSegHistogramMethodButtonGroup.addButton(
self.histogramAverageMaxThresholdButton)
self.selectSegmentEditorParameterNode()
uiWidget.setMRMLScene(slicer.mrmlScene)
self.mainViewWidget3DButton = qt.QPushButton("3D")
self.mainViewWidget3DButton.setCheckable(True)
self.mainViewWidget3DButton.connect('clicked()', self.updateMainView)
self.mainSliceViewName = "Main"
self.main3DViewName = "ViewM"
self.secondarySliceViewNames = ["Red2", "Green2", "Yellow2"]
self.allSliceViewNames = [self.mainSliceViewName
] + self.secondarySliceViewNames
self.sliceViewWidget = None
self.setupLayout()
layoutManager = slicer.app.layoutManager()
layoutManager.connect('layoutChanged(int)', self.onLayoutChanged)
self.previousLayout = layoutManager.layout
if self.previousLayout == NeuroSegmentWidget.NEURO_SEGMENT_WIDGET_LAYOUT_ID:
self.previousLayout = 0
self.addObserver(slicer.mrmlScene, slicer.mrmlScene.StartCloseEvent,
self.onSceneStartClose)
self.addObserver(slicer.mrmlScene, slicer.mrmlScene.EndCloseEvent,
self.onSceneEndClose)
self.addObserver(slicer.mrmlScene, slicer.mrmlScene.EndImportEvent,
self.onSceneEndImport)
self.clickedView = None
self.clickTimer = qt.QTimer()
self.clickTimer.setInterval(300)
self.clickTimer.setSingleShot(True)
self.clickTimer.timeout.connect(self.switchMainView)
self.clickNonResponsive = False
self.clickNonResponseTimer = qt.QTimer()
self.clickNonResponseTimer.setInterval(200)
self.clickNonResponseTimer.setSingleShot(True)
self.clickNonResponseTimer.timeout.connect(self.clickNonResponseOff)
self.sliceViewClickObservers = []
self.defaultSegmentationFileName = self.getPath(
) + "/Resources/Segmentations/DefaultSegmentation.seg.nrrd"
def setup(self):
"""Init the widget """
# self.firstLoad = True
ScriptedLoadableModuleWidget.setup(self)
self.disableEvents = False
# Create objects that can be used anywhere in the module. Example: in most cases there should be just one
# object of the logic class
self._initLogic_()
##########
# Main area
self.mainAreaCollapsibleButton = ctk.ctkCollapsibleButton()
self.mainAreaCollapsibleButton.text = "Main area"
self.layout.addWidget(self.mainAreaCollapsibleButton, SlicerUtil.ALIGNMENT_VERTICAL_TOP)
# self.layout.addWidget(self.mainAreaCollapsibleButton)
# self.mainLayout = qt.QGridLayout(self.mainAreaCollapsibleButton)
self.mainLayout = qt.QFormLayout(self.mainAreaCollapsibleButton)
row = 0
# Node selector
volumeLabel = qt.QLabel("Active volume: ")
volumeLabel.setStyleSheet("margin-left:5px")
# self.mainLayout.addWidget(volumeLabel, row, 0)
self.volumeSelector = slicer.qMRMLNodeComboBox()
self.volumeSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "")
self.volumeSelector.selectNodeUponCreation = True
self.volumeSelector.autoFillBackground = True
self.volumeSelector.addEnabled = False
self.volumeSelector.noneEnabled = False
self.volumeSelector.removeEnabled = False
self.volumeSelector.showHidden = False
self.volumeSelector.showChildNodeTypes = False
self.volumeSelector.setMRMLScene(slicer.mrmlScene)
self.volumeSelector.setMinimumWidth(150)
# self.volumeSelector.setStyleSheet("margin: 15px 0")
# self.volumeSelector.selectNodeUponCreation = False
#self.mainLayout.addWidget(self.volumeSelector, row, 1)
self.mainLayout.addRow(volumeLabel, self.volumeSelector)
self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self._onMainVolumeChanged_)
row += 1
lb = qt.QLabel("Click to select the calibration type and, if needed, modify the HU value expected for that area")
lb.setStyleSheet("margin:10px 0 10px 5px")
self.mainLayout.addRow(lb)
#self.mainLayout.addWidget(lb, row, 0, 1, 2)
self.typeRadioButtonGroup = qt.QButtonGroup()
self.typeRadioButtonGroup.connect("buttonClicked (QAbstractButton*)", self.__onTypeRadioButtonClicked__)
row += 1
self.rbAir = qt.QRadioButton("Air")
self.rbAir.setStyleSheet("margin-left:10px; margin-top: 5px")
self.typeRadioButtonGroup.addButton(self.rbAir, 1)
# self.mainLayout.addWidget(self.rbAir, row, 0)
self.txtAir = qt.QLineEdit()
self.txtAir.setText("-1000")
self.txtAir.setFixedWidth(80)
self.txtAir.setValidator(qt.QIntValidator())
self.mainLayout.addRow(self.rbAir, self.txtAir)
row += 1
self.rbBlood = qt.QRadioButton("Blood")
self.rbBlood.setStyleSheet("margin-left:10px; margin-top: 5px")
self.typeRadioButtonGroup.addButton(self.rbBlood, 2)
# self.mainLayout.addWidget(self.rbBlood, row, 0)
self.txtBlood = qt.QLineEdit()
self.txtBlood.setText("50")
self.txtBlood.setFixedWidth(80)
self.txtBlood.setValidator(qt.QIntValidator())
# self.mainLayout.addWidget(self.txtBlood, row, 1)
self.mainLayout.addRow(self.rbBlood, self.txtBlood)
row += 1
# Calibrate button
self.calibrateButton = ctk.ctkPushButton()
self.calibrateButton.setText("Calibrate")
self.calibrateButton.toolTip = "Run the calibration"
self.calibrateButton.setIcon(qt.QIcon("{0}/scale.png".format(SlicerUtil.CIP_ICON_DIR)))
self.calibrateButton.setIconSize(qt.QSize(20, 20))
self.calibrateButton.setFixedWidth(135)
self.mainLayout.addRow(None, self.calibrateButton)
self.calibrateButton.connect('clicked()', self._onCalibrateButtonClicked_)
self._createEditorWidget_()
self.setEditorValues()
def buildGUI(self, parent):
#resliceGroupBox = ctk.ctkCollapsibleGroupBox()
#resliceGroupBox.title = self.label
#parent.addWidget(resliceGroupBox)
resliceLayout = qt.QFormLayout(parent)
# Tracking node selector
self.resliceTrackingDataSelector = slicer.qMRMLNodeComboBox()
self.resliceTrackingDataSelector.nodeTypes = ((
"vtkMRMLIGTLTrackingDataBundleNode"), "")
self.resliceTrackingDataSelector.selectNodeUponCreation = True
self.resliceTrackingDataSelector.addEnabled = True
self.resliceTrackingDataSelector.removeEnabled = False
self.resliceTrackingDataSelector.noneEnabled = False
self.resliceTrackingDataSelector.showHidden = True
self.resliceTrackingDataSelector.showChildNodeTypes = False
self.resliceTrackingDataSelector.setMRMLScene(slicer.mrmlScene)
self.resliceTrackingDataSelector.setToolTip(
"Tracking Data for Reslicing")
resliceLayout.addRow("Tracking Data: ",
self.resliceTrackingDataSelector)
self.resliceCathRadioButton = [None] * self.nCath
self.resliceCathBoxLayout = qt.QHBoxLayout()
self.resliceCathGroup = qt.QButtonGroup()
for cath in range(self.nCath):
self.resliceCathRadioButton[cath] = qt.QRadioButton("Cath %d" %
cath)
if cath == self.resliceCath:
self.resliceCathRadioButton[cath].checked = 0
self.resliceCathBoxLayout.addWidget(
self.resliceCathRadioButton[cath])
self.resliceCathGroup.addButton(self.resliceCathRadioButton[cath])
resliceLayout.addRow("Catheter:", self.resliceCathBoxLayout)
self.resliceAxCheckBox = qt.QCheckBox()
self.resliceAxCheckBox.checked = 0
self.resliceAxCheckBox.text = "AX"
self.resliceSagCheckBox = qt.QCheckBox()
self.resliceSagCheckBox.checked = 0
self.resliceSagCheckBox.text = "SAG"
self.resliceCorCheckBox = qt.QCheckBox()
self.resliceCorCheckBox.checked = 0
self.resliceCorCheckBox.text = "COR"
self.resliceBoxLayout = qt.QHBoxLayout()
self.resliceBoxLayout.addWidget(self.resliceAxCheckBox)
self.resliceBoxLayout.addWidget(self.resliceSagCheckBox)
self.resliceBoxLayout.addWidget(self.resliceCorCheckBox)
resliceLayout.addRow("Plane:", self.resliceBoxLayout)
self.resliceTrackingDataSelector.connect(
"currentNodeChanged(vtkMRMLNode*)", self.onTrackingDataSelected)
self.resliceAxCheckBox.connect('toggled(bool)', self.onResliceChecked)
self.resliceSagCheckBox.connect('toggled(bool)', self.onResliceChecked)
self.resliceCorCheckBox.connect('toggled(bool)', self.onResliceChecked)
for cath in range(self.nCath):
self.resliceCathRadioButton[cath].connect('clicked(bool)',
self.onSelectResliceCath)
def buildGUI(self, parent):
registrationLayout = qt.QFormLayout(parent)
self.fromTrackingDataSelector = slicer.qMRMLNodeComboBox()
self.fromTrackingDataSelector.nodeTypes = ((
"vtkMRMLIGTLTrackingDataBundleNode"), "")
self.fromTrackingDataSelector.selectNodeUponCreation = True
self.fromTrackingDataSelector.addEnabled = True
self.fromTrackingDataSelector.removeEnabled = False
self.fromTrackingDataSelector.noneEnabled = False
self.fromTrackingDataSelector.showHidden = True
self.fromTrackingDataSelector.showChildNodeTypes = False
self.fromTrackingDataSelector.setMRMLScene(slicer.mrmlScene)
self.fromTrackingDataSelector.setToolTip("Tracking Data (From)")
registrationLayout.addRow("TrackingData (From): ",
self.fromTrackingDataSelector)
self.toTrackingDataSelector = slicer.qMRMLNodeComboBox()
self.toTrackingDataSelector.nodeTypes = ((
"vtkMRMLIGTLTrackingDataBundleNode"), "")
self.toTrackingDataSelector.selectNodeUponCreation = True
self.toTrackingDataSelector.addEnabled = True
self.toTrackingDataSelector.removeEnabled = False
self.toTrackingDataSelector.noneEnabled = False
self.toTrackingDataSelector.showHidden = True
self.toTrackingDataSelector.showChildNodeTypes = False
self.toTrackingDataSelector.setMRMLScene(slicer.mrmlScene)
self.toTrackingDataSelector.setToolTip("Tracking data (To)")
registrationLayout.addRow("TrackingData (To): ",
self.toTrackingDataSelector)
pointBoxLayout = qt.QHBoxLayout()
self.pointGroup = qt.QButtonGroup()
self.useTipRadioButton = qt.QRadioButton("Tip")
self.useAllRadioButton = qt.QRadioButton("All ")
self.useTipRadioButton.checked = 1
pointBoxLayout.addWidget(self.useTipRadioButton)
self.pointGroup.addButton(self.useTipRadioButton)
pointBoxLayout.addWidget(self.useAllRadioButton)
self.pointGroup.addButton(self.useAllRadioButton)
registrationLayout.addRow("Points: ", pointBoxLayout)
#
# Fiducial points visibility
#
visibilityBoxLayout = qt.QHBoxLayout()
self.visibilityGroup = qt.QButtonGroup()
self.visibilityOnRadioButton = qt.QRadioButton("ON")
self.visibilityOffRadioButton = qt.QRadioButton("Off")
self.visibilityOnRadioButton.checked = 1
visibilityBoxLayout.addWidget(self.visibilityOnRadioButton)
self.visibilityGroup.addButton(self.visibilityOnRadioButton)
visibilityBoxLayout.addWidget(self.visibilityOffRadioButton)
self.visibilityGroup.addButton(self.visibilityOffRadioButton)
registrationLayout.addRow("Visibility: ", visibilityBoxLayout)
#
# Collect/Clear button
#
buttonBoxLayout = qt.QHBoxLayout()
self.collectButton = qt.QPushButton()
self.collectButton.setCheckable(False)
self.collectButton.text = 'Collect'
self.collectButton.setToolTip("Collect points from the catheters.")
buttonBoxLayout.addWidget(self.collectButton)
self.clearButton = qt.QPushButton()
self.clearButton.setCheckable(False)
self.clearButton.text = 'Clear'
self.clearButton.setToolTip(
"Clear the collected points from the list.")
buttonBoxLayout.addWidget(self.clearButton)
registrationLayout.addRow("", buttonBoxLayout)
#
# Registration button
#
#runBoxLayout = qt.QHBoxLayout()
self.runButton = qt.QPushButton()
self.runButton.setCheckable(False)
self.runButton.text = 'Run Registration'
self.runButton.setToolTip("Run fiducial registration.")
#buttonBoxLayout.addWidget(self.runButton)
registrationLayout.addRow("", self.runButton)
#
# Connect signals and slots
#
self.fromTrackingDataSelector.connect(
"currentNodeChanged(vtkMRMLNode*)",
self.onTrackingDataFromSelected)
self.toTrackingDataSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onTrackingDataToSelected)
self.collectButton.connect(qt.SIGNAL("clicked()"),
self.onCollectPoints)
self.clearButton.connect(qt.SIGNAL("clicked()"), self.onClearPoints)
self.runButton.connect(qt.SIGNAL("clicked()"), self.onRunRegistration)
self.visibilityOnRadioButton.connect("clicked(bool)",
self.onVisibilityChanged)
self.visibilityOffRadioButton.connect("clicked(bool)",
self.onVisibilityChanged)
def __init__(self, ctrl, argv=None):
QtInterface.__init__(self, ctrl, argv)
self._changeset = None
self._window = qt.QMainWindow()
self._window.setCaption("Smart Package Manager %s" % VERSION)
centerWindow(self._window)
self._window.setMinimumSize(640, 480)
app.connect(app, qt.SIGNAL('lastWindowClosed()'), app, qt.SLOT('quit()'))
self._undo = []
self._redo = []
globals = {"self": self, "qt": qt}
group = qt.QActionGroup(self._window, "Actions")
self._actions = compileActions(group, ACTIONS, globals)
class ToggleAction(qt.QAction):
def __init__(self, group, name, label):
qt.QAction.__init__(self, group, name)
self.setToggleAction(True)
self.setMenuText(label.replace("&","&&"))
self._name = name
def connect(self, signal, callback, userdata):
self._callback = callback
self._userdata = userdata
qt.QObject.connect(self, qt.SIGNAL(signal), self.slot)
def slot(self):
self._callback(self._userdata)
self._filters = {}
for name, label in [("hide-non-upgrades", _("Hide Non-upgrades")),
("hide-installed", _("Hide Installed")),
("hide-uninstalled", _("Hide Uninstalled")),
("hide-unmarked", _("Hide Unmarked")),
("hide-unlocked", _("Hide Unlocked")),
("hide-requested", _("Hide Requested")),
("hide-old", _("Hide Old"))]:
act = ToggleAction(None, name, label)
act.connect("activated()", self.toggleFilter, name)
self._actions[name] = act
treestyle = sysconf.get("package-tree")
for name, label in [("groups", _("Groups")),
("channels", _("Channels")),
("channels-groups", _("Channels & Groups")),
("none", _("None"))]:
act = ToggleAction(group, "tree-style-"+name, label)
if name == treestyle:
act.setOn(True)
act.connect("activated()", self.setTreeStyle, name)
self._actions["tree-style-"+name] = act
self._menubar = self._window.menuBar()
for MENU in MENUBAR:
def insertmenu(menubar, menu):
item = menu[0]
action = self._actions[item]
m = qt.QPopupMenu(menubar)
text = action.menuText()
menubar.insertItem(text, m)
for item in menu[1]:
if isinstance(item, tuple):
insertmenu(m, item)
elif item:
action = self._actions[item]
#i = qt.QPopupMenu(m)
#text = action.menuText()
#m.insertItem(text, i)
action.addTo(m)
else:
m.insertSeparator()
insertmenu(self._menubar, MENU)
self._toolbar = qt.QToolBar(self._window)
for TOOL in TOOLBAR:
def inserttool(toolbar, tool):
if tool:
action = self._actions[tool]
#b = qt.QToolButton(toolbar, TOOL)
#b.setTextLabel(action.toolTip())
pixmap = getPixmap(TOOLBARICONS[tool])
#b.setIconSet(qt.QIconSet(pixmap))
action.setIconSet(qt.QIconSet(pixmap))
action.addTo(toolbar)
else:
toolbar.addSeparator()
inserttool(self._toolbar, TOOL)
#self._window.add_accel_group(self._ui.get_accel_group())
self._actions["exec-changes"].setAccel(qt.QKeySequence("Ctrl+C"))
self._actions["find"].setAccel(qt.QKeySequence("Ctrl+F"))
self._actions["expand-all"].setAccel(qt.QKeySequence("Ctrl+O"))
self._actions["collapse-all"].setAccel(qt.QKeySequence("Ctrl+W"))
self._actions["summary-window"].setAccel(qt.QKeySequence("Ctrl+S"))
self._actions["exec-changes"].setEnabled(False)
self._actions["clear-changes"].setEnabled(False)
self._actions["undo"].setEnabled(False)
self._actions["redo"].setEnabled(False)
# Search bar
self._searchbar = qt.QToolBar(self._window)
self._searchbar.hide()
label = qt.QLabel(_("Search:"), self._searchbar)
label.show()
self._searchentry = qt.QLineEdit(self._searchbar)
qt.QObject.connect(self._searchentry, qt.SIGNAL("returnPressed()"), self.refreshPackages)
self._searchentry.show()
button = qt.QPushButton(self._searchbar)
qt.QObject.connect(button, qt.SIGNAL("clicked()"), self.refreshPackages)
pixmap = getPixmap("crystal-search")
button.setIconSet(qt.QIconSet(pixmap))
button.show()
buttongroup = qt.QButtonGroup(self._searchbar)
buttongroup.hide()
self._searchname = qt.QRadioButton(_("Automatic"), self._searchbar)
self._searchname.setChecked(True)
qt.QObject.connect(self._searchname, qt.SIGNAL("clicked()"), self.refreshPackages)
buttongroup.insert(self._searchname)
self._searchname.show()
self._searchdesc = qt.QRadioButton(_("Description"), self._searchbar)
self._searchdesc.setChecked(False)
qt.QObject.connect(self._searchdesc, qt.SIGNAL("clicked()"), self.refreshPackages)
self._searchdesc.show()
buttongroup.insert(self._searchdesc)
# Packages and information
self._splitter = qt.QSplitter(qt.Qt.Vertical, self._window)
self._window.setCentralWidget(self._splitter)
self._pv = QtPackageView(self._splitter)
self._pv.show()
self._pi = QtPackageInfo(self._splitter)
self._pi.show()
qt.QObject.connect(self._pv, qt.PYSIGNAL("packageSelected"), self._pi.setPackage)
qt.QObject.connect(self._pv, qt.PYSIGNAL("packageActivated"), self.actOnPackages)
qt.QObject.connect(self._pv, qt.PYSIGNAL("packagePopup"), self.packagePopup)
self._status = self._window.statusBar()
self._status.show()
self._legend = QtLegend(self._window)
def setup(self):
"""This is called one time when the module GUI is initialized
"""
CIP_PointsLabellingWidget.setup(self)
# Part of the GUI will be inherited. We just fill the radio buttons area
# Radio buttons frame
self.radioButtonsLayout = qt.QHBoxLayout(self.radioButtonsFrame)
self.typesFrame = qt.QFrame()
self.radioButtonsLayout.addWidget(self.typesFrame)
self.typesLayout = qt.QVBoxLayout(self.typesFrame)
labelsStyle = "font-weight: bold; margin: 0 0 10px 0px;"
# Types Radio Buttons
typesLabel = qt.QLabel("Select type")
typesLabel.setStyleSheet(labelsStyle)
self.typesLayout.addWidget(typesLabel)
self.typesRadioButtonGroup = qt.QButtonGroup()
for key in self.logic.params.mainTypes.iterkeys():
rbitem = qt.QRadioButton(self.logic.params.getMainTypeLabel(key))
self.typesRadioButtonGroup.addButton(rbitem, key)
self.typesLayout.addWidget(rbitem)
self.typesRadioButtonGroup.buttons()[0].setChecked(True)
# Subtypes Radio buttons
# The content will be loaded dynamically every time the main type is modified
self.subtypesFrame = qt.QFrame()
self.radioButtonsLayout.addWidget(self.subtypesFrame)
self.subtypesLayout = qt.QVBoxLayout(self.subtypesFrame)
subtypesLabel = qt.QLabel("Select subtype")
subtypesLabel.setStyleSheet(labelsStyle)
self.subtypesLayout.addWidget(subtypesLabel)
self.subtypesLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.subtypesRadioButtonGroup = qt.QButtonGroup()
# Add all the subtypes (we will filter later in "updateState" function)
for key in self.logic.params.subtypes.iterkeys():
# Build the description
rbitem = qt.QRadioButton(self.logic.params.getSubtypeLabel(key))
self.subtypesRadioButtonGroup.addButton(rbitem, key)
self.subtypesLayout.addWidget(rbitem, SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.subtypesLayout.addStretch()
# Region radio buttons
self.regionsFrame = qt.QFrame()
self.radioButtonsLayout.addWidget(self.regionsFrame)
self.regionsLayout = qt.QVBoxLayout(self.regionsFrame)
regionsLabel = qt.QLabel("Select region")
regionsLabel.setStyleSheet(labelsStyle)
self.regionsLayout.addWidget(regionsLabel)
self.regionsLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.regionsLayout.setStretch(0, 0)
self.regionsRadioButtonGroup = qt.QButtonGroup()
self.regionsFrame = qt.QFrame()
# Add all the regions
for key in self.logic.params.regions.iterkeys():
# Build the description
rbitem = qt.QRadioButton(self.logic.params.getRegionLabel(key))
self.regionsRadioButtonGroup.addButton(rbitem, key)
self.regionsLayout.addWidget(rbitem, SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.regionsLayout.addStretch()
self.regionsRadioButtonGroup.buttons()[0].setChecked(True)
# Artifact radio buttons (Add them to the same layout as the type)
self.separatorLabel = qt.QLabel("------------")
labelsStyle = "margin: 5px 0 5px 0;"
self.separatorLabel.setStyleSheet(labelsStyle)
self.typesLayout.addWidget(self.separatorLabel)
self.artifactsLabel = qt.QLabel("Select artifact")
labelsStyle = "font-weight: bold; margin: 15px 0 10px 0;"
self.artifactsLabel.setStyleSheet(labelsStyle)
self.typesLayout.addWidget(self.artifactsLabel)
self.artifactsRadioButtonGroup = qt.QButtonGroup()
for artifactId in self.logic.params.artifacts.iterkeys():
rbitem = qt.QRadioButton(self.logic.params.getArtifactLabel(artifactId))
self.artifactsRadioButtonGroup.addButton(rbitem, artifactId)
self.typesLayout.addWidget(rbitem)
self.artifactsRadioButtonGroup.buttons()[0].setChecked(True)
self.typesLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
self.typesLayout.addStretch()
# Connections
self.typesRadioButtonGroup.connect("buttonClicked (QAbstractButton*)", self.__onTypesRadioButtonClicked__)
self.subtypesRadioButtonGroup.connect("buttonClicked (QAbstractButton*)",
self.__onSecondaryRadioButtonClicked__)
self.regionsRadioButtonGroup.connect("buttonClicked (QAbstractButton*)", self.__onSecondaryRadioButtonClicked__)
self.artifactsRadioButtonGroup.connect("buttonClicked (QAbstractButton*)",
self.__onSecondaryRadioButtonClicked__)
self.updateState()
def create(self):
super(TraceAndSelectOptions, self).create()
## Custom threshold box
# Note: This is needed because other tools can disable, hide, or manipulate the default threshold box
# We need one unique to our tool
self.threshLabel = qt.QLabel("Threshold", self.frame)
self.threshLabel.setToolTip(
"In threshold mode, the label will only be set if the background value is within this range."
)
self.frame.layout().addWidget(self.threshLabel)
self.widgets.append(self.threshLabel)
self.thresh = ctk.ctkRangeWidget(self.frame)
self.thresh.spinBoxAlignment = 0xff # put enties on top
self.thresh.singleStep = 0.01
self.setRangeWidgetToBackgroundRange(self.thresh)
self.frame.layout().addWidget(self.thresh)
self.widgets.append(self.thresh)
## End custom threshold box
## Preview checkbox
self.preview = qt.QCheckBox("Preview outlines", self.frame)
self.preview.setToolTip(
"Preview the outline of a selection with right-click.")
self.frame.layout().addWidget(self.preview)
## End preview checkbox
self.modeButtons = qt.QButtonGroup(self.frame)
self.tissueRadioButton = qt.QRadioButton("Tissue Mode", self.frame)
self.boneRadioButton = qt.QRadioButton("Bone/Nerve Mode", self.frame)
self.hbox = qt.QHBoxLayout()
self.hbox.addWidget(self.boneRadioButton)
self.hbox.addWidget(self.tissueRadioButton)
self.frame.layout().addLayout(self.hbox)
self.modeButtons.addButton(self.boneRadioButton)
self.modeButtons.addButton(self.tissueRadioButton)
self.widgets.append(self.tissueRadioButton)
self.widgets.append(self.boneRadioButton)
## ERROR MESSAGE FRAME
self.errorMessageFrame = qt.QTextEdit(self.frame)
self.frame.layout().addWidget(self.errorMessageFrame)
#self.errorMessageFrame.setLayout(qt.QHBoxLayout)
self.errorMessageFrame.setFixedWidth(280)
self.errorMessageFrame.setReadOnly(True)
self.errorMessageFrame.setText('No Error Detected')
self.errorMessageFrame.setStyleSheet("QTextEdit {color:green}")
self.widgets.append(self.errorMessageFrame)
## END ERROR MESSAGE FRAME
## For the offset value selection process
self.offsetvalueFrame = qt.QFrame(self.frame)
self.offsetvalueFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.offsetvalueFrame)
self.widgets.append(self.offsetvalueFrame)
self.offsetvalueLabel = qt.QLabel("Offset Value:",
self.offsetvalueFrame)
self.offsetvalueLabel.setToolTip(
"Set the offset value shift upon an action")
self.offsetvalueFrame.layout().addWidget(self.offsetvalueLabel)
self.widgets.append(self.offsetvalueLabel)
self.offsetvalueSpinBox = qt.QDoubleSpinBox(self.offsetvalueFrame)
self.offsetvalueSpinBox.setToolTip(
"Set the offset value shift upon an action")
self.offsetvalueSpinBox.minimum = -1000
self.offsetvalueSpinBox.maximum = 1000
self.offsetvalueSpinBox.suffix = ""
self.offsetvalueFrame.layout().addWidget(self.offsetvalueSpinBox)
self.widgets.append(self.offsetvalueSpinBox)
## End offset value selection
self.maxPixelsFrame = qt.QFrame(self.frame)
self.maxPixelsFrame.setLayout(qt.QHBoxLayout())
self.frame.layout().addWidget(self.maxPixelsFrame)
self.widgets.append(self.maxPixelsFrame)
self.maxPixelsLabel = qt.QLabel("Max Pixels per click:",
self.maxPixelsFrame)
self.maxPixelsLabel.setToolTip("Set the maxPixels for each click")
self.maxPixelsFrame.layout().addWidget(self.maxPixelsLabel)
self.widgets.append(self.maxPixelsLabel)
self.maxPixelsSpinBox = qt.QDoubleSpinBox(self.maxPixelsFrame)
self.maxPixelsSpinBox.setToolTip("Set the maxPixels for each click")
self.maxPixelsSpinBox.minimum = 1
self.maxPixelsSpinBox.maximum = 100000
self.maxPixelsSpinBox.suffix = ""
self.maxPixelsFrame.layout().addWidget(self.maxPixelsSpinBox)
self.widgets.append(self.maxPixelsSpinBox)
# Help Browser
self.helpBrowser = qt.QPushButton("Visit the Webpage")
# End Help Browser
self.frame.layout().addWidget(self.helpBrowser)
HelpButton(
self.frame,
"Use this tool to help you label all voxels enclosed in an area bounded by the the largest path of pixels within the specified threshold."
)
# don't connect the signals and slots directly - instead, add these
# to the list of connections so that gui callbacks can be cleanly
# disabled while the gui is being updated. This allows several gui
# elements to be interlinked with signal/slots but still get updated
# as a unit to the new value of the mrml node.
# self.thresholdPaint.hide()
self.connections.append((self.maxPixelsSpinBox, 'valueChanged(double)',
self.onMaxPixelsSpinBoxChanged))
self.connections.append(
(self.preview, "clicked()", self.onPreviewChanged))
self.connections.append(
(self.tissueRadioButton, "clicked()", self.onTissueButtonChanged))
self.connections.append(
(self.boneRadioButton, "clicked()", self.onBoneButtonChanged))
self.connections.append(
(self.offsetvalueSpinBox, 'valueChanged(double)',
self.onOffsetValueSpinBoxChanged))
self.connections.append((self.thresh, "valuesChanged(double,double)",
self.onThreshValuesChange))
self.connections.append(
(self.helpBrowser, "clicked()", self.onHelpBrowserPressed))
# Add vertical spacer
self.frame.layout().addStretch(1)
