def updateLandmarkArray(self): """Rebuild the list of buttons based on current landmarks""" # reset the widget if self.landmarkGroupBox: self.landmarkGroupBox.setParent(None) self.landmarkGroupBox = qt.QGroupBox("Landmarks") self.landmarkGroupBox.setLayout(qt.QFormLayout()) # add the action buttons at the top actionButtons = qt.QHBoxLayout() # add button - http://www.clipartbest.com/clipart-jTxpEM8Bc self.addButton = qt.QPushButton("Add") self.addButton.setIcon( qt.QIcon( os.path.join( os.path.dirname(slicer.modules.landmarkregistration.path), 'Resources/Icons/', "icon_Add.png"))) self.addButton.connect('clicked()', self.addLandmark) actionButtons.addWidget(self.addButton) self.renameButton = qt.QPushButton("Rename") self.renameButton.connect('clicked()', self.renameLandmark) self.renameButton.enabled = False actionButtons.addWidget(self.renameButton) self.landmarkGroupBox.layout().addRow(actionButtons) # for now, hide self.renameButton.hide() # make a button for each current landmark self.labels = {} landmarks = self.logic.landmarksForVolumes(self.volumeNodes) keys = sorted(landmarks.keys()) for landmarkName in keys: row = qt.QWidget() rowLayout = qt.QHBoxLayout() rowLayout.setMargin(0) label = qt.QLabel(landmarkName) rowLayout.addWidget(label, 8) # active button - https://thenounproject.com/term/crosshair/4434/ activeButton = qt.QPushButton() activeButton.setIcon( qt.QIcon( os.path.join( os.path.dirname( slicer.modules.landmarkregistration.path), 'Resources/Icons/', "icon_Active.png"))) activeButton.connect('clicked()', lambda l=landmarkName: self.pickLandmark(l)) rowLayout.addWidget(activeButton, 1) if landmarkName == self.selectedLandmark: label.setStyleSheet("QWidget{font-weight: bold;}") activeButton.setEnabled(False) # remove button - http://findicons.com/icon/158288/trash_recyclebin_empty_closed_w removeButton = qt.QPushButton() removeButton.setIcon( qt.QIcon( os.path.join( os.path.dirname( slicer.modules.landmarkregistration.path), 'Resources/Icons/', "icon_Trash.png"))) removeButton.connect('clicked()', lambda l=landmarkName: self.removeLandmark(l)) rowLayout.addWidget(removeButton, 1) row.setLayout(rowLayout) self.landmarkGroupBox.layout().addRow(row) self.labels[landmarkName] = [label, activeButton] self.landmarkArrayHolder.layout().addWidget(self.landmarkGroupBox) # observe manipulation of the landmarks self.addLandmarkObservers()
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # input volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = False self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputSelector.setToolTip( "Pick the input to the algorithm." ) parametersFormLayout.addRow("Input Volume: ", self.inputSelector) # # output volume selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.outputSelector.selectNodeUponCreation = True self.outputSelector.addEnabled = True self.outputSelector.renameEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.noneEnabled = False self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputSelector.setToolTip( "Pick the output to the algorithm." ) parametersFormLayout.addRow("Output Volume: ", self.outputSelector) # # brain mask label selector # self.brainMaskSelector = slicer.qMRMLNodeComboBox() self.brainMaskSelector.nodeTypes = ["vtkMRMLLabelMapVolumeNode"] self.brainMaskSelector.selectNodeUponCreation = True self.brainMaskSelector.addEnabled = True self.brainMaskSelector.renameEnabled = True self.brainMaskSelector.removeEnabled = True self.brainMaskSelector.noneEnabled = True self.brainMaskSelector.showHidden = False self.brainMaskSelector.showChildNodeTypes = False self.brainMaskSelector.setMRMLScene(slicer.mrmlScene) self.brainMaskSelector.setToolTip( "Output the brain extraction binary mask.") parametersFormLayout.addRow("Brain Mask ", self.brainMaskSelector) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1) # Refresh Apply button state self.onSelect()
def setup(self): ScriptedLoadableModuleWidget.setup(self) self.logic = SegmentMesherLogic() self.logic.logCallback = self.addLog self.modelGenerationInProgress = False # Instantiate and connect widgets ... # Parameter sets defaultinputParametersCollapsibleButton = ctk.ctkCollapsibleButton() defaultinputParametersCollapsibleButton.text = "Parameter set" defaultinputParametersCollapsibleButton.collapsed = True self.layout.addWidget(defaultinputParametersCollapsibleButton) defaultParametersLayout = qt.QFormLayout( defaultinputParametersCollapsibleButton) self.parameterNodeSelector = slicer.qMRMLNodeComboBox() self.parameterNodeSelector.nodeTypes = ["vtkMRMLScriptedModuleNode"] self.parameterNodeSelector.addAttribute("vtkMRMLScriptedModuleNode", "ModuleName", "SegmentMesher") self.parameterNodeSelector.selectNodeUponCreation = True self.parameterNodeSelector.addEnabled = True self.parameterNodeSelector.renameEnabled = True self.parameterNodeSelector.removeEnabled = True self.parameterNodeSelector.noneEnabled = False self.parameterNodeSelector.showHidden = True self.parameterNodeSelector.showChildNodeTypes = False self.parameterNodeSelector.baseName = "SegmentMesher" self.parameterNodeSelector.setMRMLScene(slicer.mrmlScene) self.parameterNodeSelector.setToolTip("Pick parameter set") defaultParametersLayout.addRow("Parameter set: ", self.parameterNodeSelector) # # Inputs # inputParametersCollapsibleButton = ctk.ctkCollapsibleButton() inputParametersCollapsibleButton.text = "Inputs" self.layout.addWidget(inputParametersCollapsibleButton) # Layout within the dummy collapsible button inputParametersFormLayout = qt.QFormLayout( inputParametersCollapsibleButton) self.inputModelSelector = slicer.qMRMLNodeComboBox() self.inputModelSelector.nodeTypes = ["vtkMRMLSegmentationNode"] self.inputModelSelector.selectNodeUponCreation = True self.inputModelSelector.addEnabled = False self.inputModelSelector.removeEnabled = False self.inputModelSelector.noneEnabled = False self.inputModelSelector.showHidden = False self.inputModelSelector.showChildNodeTypes = False self.inputModelSelector.setMRMLScene(slicer.mrmlScene) self.inputModelSelector.setToolTip( "Volumetric mesh will be generated for all visible segments in this segmentation node." ) inputParametersFormLayout.addRow("Input segmentation: ", self.inputModelSelector) self.methodSelectorComboBox = qt.QComboBox() self.methodSelectorComboBox.addItem("Cleaver", METHOD_CLEAVER) self.methodSelectorComboBox.addItem("TetGen", METHOD_TETGEN) inputParametersFormLayout.addRow("Meshing method: ", self.methodSelectorComboBox) # # Outputs # outputParametersCollapsibleButton = ctk.ctkCollapsibleButton() outputParametersCollapsibleButton.text = "Outputs" self.layout.addWidget(outputParametersCollapsibleButton) outputParametersFormLayout = qt.QFormLayout( outputParametersCollapsibleButton) # # output volume selector # self.outputModelSelector = slicer.qMRMLNodeComboBox() self.outputModelSelector.nodeTypes = ["vtkMRMLModelNode"] self.outputModelSelector.selectNodeUponCreation = True self.outputModelSelector.addEnabled = True self.outputModelSelector.renameEnabled = True self.outputModelSelector.removeEnabled = True self.outputModelSelector.noneEnabled = False self.outputModelSelector.showHidden = False self.outputModelSelector.showChildNodeTypes = False self.outputModelSelector.setMRMLScene(slicer.mrmlScene) self.outputModelSelector.setToolTip("Created volumetric mesh") outputParametersFormLayout.addRow("Output model: ", self.outputModelSelector) # # Advanced area # self.advancedCollapsibleButton = ctk.ctkCollapsibleButton() self.advancedCollapsibleButton.text = "Advanced" self.advancedCollapsibleButton.collapsed = True self.layout.addWidget(self.advancedCollapsibleButton) advancedFormLayout = qt.QFormLayout(self.advancedCollapsibleButton) self.cleaverAdditionalParametersWidget = qt.QLineEdit() self.cleaverAdditionalParametersWidget.setToolTip( 'See description of parameters in module documentation ') advancedFormLayout.addRow("Cleaver meshing options:", self.cleaverAdditionalParametersWidget) self.cleaverAdditionalParametersWidget.text = "--scale 0.2 --multiplier 2 --grading 5" self.tetGenAdditionalParametersWidget = qt.QLineEdit() self.tetGenAdditionalParametersWidget.setToolTip( 'See description of parameters in module documentation ') advancedFormLayout.addRow("TetGen meshing options:", self.tetGenAdditionalParametersWidget) self.tetGenAdditionalParametersWidget.text = "" self.showDetailedLogDuringExecutionCheckBox = qt.QCheckBox(" ") self.showDetailedLogDuringExecutionCheckBox.checked = False self.showDetailedLogDuringExecutionCheckBox.setToolTip( "Show detailed log during model generation.") advancedFormLayout.addRow("Show detailed log:", self.showDetailedLogDuringExecutionCheckBox) self.keepTemporaryFilesCheckBox = qt.QCheckBox(" ") self.keepTemporaryFilesCheckBox.checked = False self.keepTemporaryFilesCheckBox.setToolTip( "Keep temporary files (inputs, computed outputs, logs) after the model generation is completed." ) self.showTemporaryFilesFolderButton = qt.QPushButton( "Show temp folder") self.showTemporaryFilesFolderButton.toolTip = "Open the folder where temporary files are stored." self.showTemporaryFilesFolderButton.setSizePolicy( qt.QSizePolicy.MinimumExpanding, qt.QSizePolicy.Preferred) hbox = qt.QHBoxLayout() hbox.addWidget(self.keepTemporaryFilesCheckBox) hbox.addWidget(self.showTemporaryFilesFolderButton) advancedFormLayout.addRow("Keep temporary files:", hbox) customCleaverPath = self.logic.getCustomCleaverPath() self.customCleaverPathSelector = ctk.ctkPathLineEdit() self.customCleaverPathSelector.setCurrentPath(customCleaverPath) self.customCleaverPathSelector.nameFilters = [ self.logic.cleaverFilename ] self.customCleaverPathSelector.setSizePolicy( qt.QSizePolicy.MinimumExpanding, qt.QSizePolicy.Preferred) self.customCleaverPathSelector.setToolTip( "Set cleaver-cli executable path. " "If value is empty then cleaver-cli bundled with this extension will be used." ) advancedFormLayout.addRow("Custom Cleaver executable path:", self.customCleaverPathSelector) customTetGenPath = self.logic.getCustomTetGenPath() self.customTetGenPathSelector = ctk.ctkPathLineEdit() self.customTetGenPathSelector.setCurrentPath(customTetGenPath) self.customTetGenPathSelector.nameFilters = [self.logic.tetGenFilename] self.customTetGenPathSelector.setSizePolicy( qt.QSizePolicy.MinimumExpanding, qt.QSizePolicy.Preferred) self.customTetGenPathSelector.setToolTip( "Set tetgen executable path. " "If value is empty then tetgen bundled with this extension will be used." ) advancedFormLayout.addRow("Custom TetGen executable path:", self.customTetGenPathSelector) # # Display # displayParametersCollapsibleButton = ctk.ctkCollapsibleButton() displayParametersCollapsibleButton.text = "Display" displayParametersCollapsibleButton.collapsed = True self.layout.addWidget(displayParametersCollapsibleButton) displayParametersFormLayout = qt.QFormLayout( displayParametersCollapsibleButton) self.clipNodeWidget = slicer.qMRMLClipNodeWidget() clipNode = slicer.mrmlScene.GetFirstNodeByClass( "vtkMRMLClipModelsNode") self.clipNodeWidget.setMRMLClipNode(clipNode) displayParametersFormLayout.addRow(self.clipNodeWidget) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False self.layout.addWidget(self.applyButton) self.statusLabel = qt.QPlainTextEdit() self.statusLabel.setTextInteractionFlags(qt.Qt.TextSelectableByMouse) self.statusLabel.setCenterOnScroll(True) self.layout.addWidget(self.statusLabel) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.showTemporaryFilesFolderButton.connect( 'clicked(bool)', self.onShowTemporaryFilesFolder) self.inputModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.updateMRMLFromGUI) self.outputModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.updateMRMLFromGUI) self.methodSelectorComboBox.connect("currentIndexChanged(int)", self.updateMRMLFromGUI) # Immediately update deleteTemporaryFiles in the logic to make it possible to decide to # keep the temporary file while the model generation is running self.keepTemporaryFilesCheckBox.connect( "toggled(bool)", self.onKeepTemporaryFilesToggled) # Add vertical spacer self.layout.addStretch(1) # Refresh Apply button state self.updateMRMLFromGUI()
def setup(self): ScriptedLoadableModuleWidget.setup(self) slicer.app.layoutManager().setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutOneUpRedSliceView) l = slicer.modules.createmodels.logic() self.needleModel = l.CreateNeedle(150, 0.4, 0, False) #This code block creates a collapsible button #This defines which type of button you are using self.usContainer = ctk.ctkCollapsibleButton() #This is what the button will say self.usContainer.text = "Connection Information" #Thiss actually creates that button #This creates a variable that describes layout within this collapsible button self.usLayout = qt.QFormLayout(self.usContainer) if slicer.mrmlScene.GetNodesByClass("vtkMRMLSequenceNode").GetNumberOfItems() == 0: #This is a push button self.connectButton = qt.QPushButton() self.connectButton.setDefault(False) #This button says connect self.connectButton.text = "Connect" #help tooltip that explains the funciton self.connectButton.toolTip = "Connects to Ultrasound" #adds the widget to the layout self.usLayout.addWidget(self.connectButton) # self.normalImageButton = qt.QCheckBox() # self.normalImageButton.text = "Select if performing a 2D Calibration" # self.usLayout.addRow(self.normalImageButton) self.imageSelector = slicer.qMRMLNodeComboBox() self.imageSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.imageSelector.selectNodeUponCreation = True self.imageSelector.addEnabled = False self.imageSelector.removeEnabled = False self.imageSelector.noneEnabled = True self.imageSelector.showHidden = False self.imageSelector.showChildNodeTypes = False self.imageSelector.setMRMLScene( slicer.mrmlScene ) self.imageSelector.setToolTip( "Pick the image to be used." ) self.usLayout.addRow("US Volume: ", self.imageSelector) #add combo box for linear transform node self.TransformSelector = slicer.qMRMLNodeComboBox() self.TransformSelector.nodeTypes = ["vtkMRMLLinearTransformNode"] self.TransformSelector.selectNodeUponCreation = True self.TransformSelector.addEnabled = False self.TransformSelector.removeEnabled = False self.TransformSelector.noneEnabled = True self.TransformSelector.showHidden = False self.TransformSelector.showChildNodeTypes = False self.TransformSelector.setMRMLScene( slicer.mrmlScene ) self.TransformSelector.setToolTip( "Pick the transform representing the straw line." ) self.usLayout.addRow("Tip to Probe: ", self.TransformSelector) self.recordContainer = ctk.ctkCollapsibleButton() #This is what the button will say self.recordContainer.text = "Recording Options" #Thiss actually creates that button #This creates a variable that describes layout within this collapsible button self.recordLayout = qt.QFormLayout(self.recordContainer) self.RecordButton = qt.QPushButton() self.RecordButton.text = "Start Recording" self.recordLayout.addWidget(self.RecordButton) self.StopRecordButton = qt.QPushButton() self.StopRecordButton.text = "Stop Recording" self.recordLayout.addWidget(self.StopRecordButton) self.pathInput = qt.QLineEdit() self.pathInput.setPlaceholderText("Enter the path to save files to") self.pathText = qt.QLabel("File Path:") self.recordLayout.addRow(self.pathText, self.pathInput) self.SaveRecordButton = qt.QPushButton() self.SaveRecordButton.text = "Save Recording" self.recordLayout.addWidget(self.SaveRecordButton) # This creates another collapsible button self.fiducialContainer = ctk.ctkCollapsibleButton() self.fiducialContainer.text = "Registration" self.fiducialLayout = qt.QFormLayout(self.fiducialContainer) self.freezeButton = qt.QPushButton() if slicer.mrmlScene.GetNodesByClass("vtkMRMLSequenceNode").GetNumberOfItems() == 0: self.freezeButton.text = "Freeze" else: self.freezeButton.text = "Place Fiducial" self.freezeButton.toolTip = "Freeze the ultrasound image for fiducial placement" self.fiducialLayout.addRow(self.freezeButton) self.shortcut = qt.QShortcut(qt.QKeySequence('f'), slicer.util.mainWindow()) self.numFidLabel = qt.QLabel() self.fiducialLayout.addRow(qt.QLabel("Fiducials collected:"), self.numFidLabel) self.transformTable = qt.QTableWidget() self.transTableItem = qt.QTableWidgetItem() self.fidError = qt.QLabel() self.transformTable.setRowCount(4) self.transformTable.setColumnCount(4) self.transformTable.horizontalHeader().hide() self.transformTable.verticalHeader().hide() self.transformTable.setItem(0,0, qt.QTableWidgetItem("1")) self.transformTable.setItem(0,1, qt.QTableWidgetItem("0")) self.transformTable.setItem(0,2, qt.QTableWidgetItem("0")) self.transformTable.setItem(0,3, qt.QTableWidgetItem("0")) self.transformTable.setItem(1,0, qt.QTableWidgetItem("0")) self.transformTable.setItem(1,1, qt.QTableWidgetItem("1")) self.transformTable.setItem(1,2, qt.QTableWidgetItem("0")) self.transformTable.setItem(1,3, qt.QTableWidgetItem("0")) self.transformTable.setItem(2,0, qt.QTableWidgetItem("0")) self.transformTable.setItem(2,1, qt.QTableWidgetItem("0")) self.transformTable.setItem(2,2, qt.QTableWidgetItem("1")) self.transformTable.setItem(2,3, qt.QTableWidgetItem("0")) self.transformTable.setItem(3,0, qt.QTableWidgetItem("0")) self.transformTable.setItem(3,1, qt.QTableWidgetItem("0")) self.transformTable.setItem(3,2, qt.QTableWidgetItem("0")) self.transformTable.setItem(3,3, qt.QTableWidgetItem("1")) self.transformTable.setSizePolicy(qt.QSizePolicy.Minimum, qt.QSizePolicy.MinimumExpanding) self.copyIcon =qt.QIcon(":Icons/Medium/SlicerEditCopy.png") self.copyButton = qt.QPushButton() self.copyButton.setIcon(self.copyIcon) self.copyButton.setMaximumWidth(64) self.copyButton.enabled = False if self.numFidLabel >= 2: self.copyButton.enabled = True self.fiducialLayout.addRow(qt.QLabel("Image to probe transform:")) self.fiducialLayout.addRow(self.transformTable) self.fiducialLayout.addRow("Copy:", self.copyButton) self.validationContainer = ctk.ctkCollapsibleButton() self.validationContainer.text = "Validation" self.validationLayout = qt.QFormLayout(self.validationContainer) self.visualizeButton = qt.QPushButton('Show 3D Scene') self.visualizeButton.toolTip = "This button enables the 3D view for visual validation" self.validationLayout.addRow(self.visualizeButton) # Add the containers to the parent self.layout.addWidget(self.usContainer) if slicer.mrmlScene.GetNodesByClass("vtkMRMLSequenceNode").GetNumberOfItems() == 0: self.layout.addWidget(self.recordContainer) self.layout.addWidget(self.fiducialContainer) self.layout.addWidget(self.validationContainer) # Add vertical spacer self.layout.addStretch(1) #connections if slicer.mrmlScene.GetNodesByClass("vtkMRMLSequenceNode").GetNumberOfItems() == 0: self.connectButton.connect('clicked(bool)', self.onConnectButtonClicked) self.freezeButton.connect('clicked(bool)', self.onConnectButtonClicked) self.shortcut.connect('activated()', self.onConnectButtonClicked) else: self.shortcut.connect('activated()', self.onFiducialClicked) self.freezeButton.connect('clicked(bool)', self.onFiducialClicked) self.imageSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onImageChanged) self.TransformSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onTransformChanged) self.RecordButton.connect('clicked(bool)', self.onRecordButtonClicked) self.StopRecordButton.connect('clicked(bool)', self.onStopRecordButtonClicked) self.SaveRecordButton.connect('clicked(bool)', self.onSaveRecordButtonClicked) self.copyButton.connect('clicked(bool)', self.onCopyButtonClicked) self.visualizeButton.connect('clicked(bool)', self.onVisualizeButtonClicked) self.StopRecordButton.setEnabled(False) self.sceneObserverTag = slicer.mrmlScene.AddObserver(slicer.mrmlScene.NodeAddedEvent, self.onNodeAdded)
def setup_atlas_registration_area(self): """ Setup atlas registration area and connect functions. """ atlas_registration_collapsible_button = ctk.ctkCollapsibleButton() atlas_registration_collapsible_button.text = "Register Atlas to Scan" atlas_registration_collapsible_button.setDisabled(False) self.layout.addWidget(atlas_registration_collapsible_button) # Layout within the dummy collapsible button atlas_registration_form_layout = qt.QFormLayout( atlas_registration_collapsible_button) self.atlas_fiducials = slicer.qMRMLNodeComboBox() self.atlas_fiducials.nodeTypes = ["vtkMRMLMarkupsFiducialNode"] self.atlas_fiducials.selectNodeUponCreation = True self.atlas_fiducials.addEnabled = True self.atlas_fiducials.removeEnabled = True self.atlas_fiducials.noneEnabled = True self.atlas_fiducials.showHidden = True self.atlas_fiducials.showChildNodeTypes = True self.atlas_fiducials.setMRMLScene(slicer.mrmlScene) self.atlas_fiducials.setToolTip("Pick the input to the algorithm.") atlas_registration_form_layout.addRow( "Atlas AC/PC/Sup1/Sup2 Fiducials", self.atlas_fiducials) self.scan_fiducials = slicer.qMRMLNodeComboBox() self.scan_fiducials.nodeTypes = ["vtkMRMLMarkupsFiducialNode"] self.scan_fiducials.selectNodeUponCreation = True self.scan_fiducials.addEnabled = True self.scan_fiducials.removeEnabled = True self.scan_fiducials.noneEnabled = True self.scan_fiducials.showHidden = True self.scan_fiducials.showChildNodeTypes = True self.scan_fiducials.setMRMLScene(slicer.mrmlScene) self.scan_fiducials.setToolTip("Pick the input to the algorithm.") atlas_registration_form_layout.addRow("Scan AC/PC/Sup1/Sup2 Fiducials", self.scan_fiducials) # atlas volume selector # self.atlas_volume_selector.nodeTypes = (("vtkMRMLLabelMapVolumeNode"), "") self.atlas_volume_selector.selectNodeUponCreation = False self.atlas_volume_selector.addEnabled = False self.atlas_volume_selector.removeEnabled = False self.atlas_volume_selector.noneEnabled = True self.atlas_volume_selector.showHidden = False self.atlas_volume_selector.showChildNodeTypes = False self.atlas_volume_selector.setMRMLScene(slicer.mrmlScene) self.atlas_volume_selector.setToolTip( "Pick the input volume for the algorithm.") atlas_registration_form_layout.addRow("Atlas Volume: ", self.atlas_volume_selector) # # Register Button # self.atlas_register_button = qt.QPushButton("Register Atlas to Frame") self.atlas_register_button.toolTip = "Run the algorithm." self.atlas_register_button.enabled = False atlas_registration_form_layout.addRow(self.atlas_register_button) # Connect Procedures self.atlas_fiducials.connect("currentNodeChanged(vtkMRMLNode*)", self.on_atlas_registration_select) self.scan_fiducials.connect("currentNodeChanged(vtkMRMLNode*)", self.on_atlas_registration_select) self.atlas_volume_selector.connect("currentNodeChanged(vtkMRMLNode*)", self.on_atlas_registration_select) # Atlas to Frame Registration self.atlas_register_button.connect("clicked(bool)", self.register_ac_pc)
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 add_widgets(self, instructions): if self.processingCollapsibleButton is not None: self.processingCollapsibleButton.deleteLater() self.processingCollapsibleButton = ctk.ctkCollapsibleButton() self.processingCollapsibleButton.text = "Processing" self.layout.addWidget(self.processingCollapsibleButton) self.processingFormLayout = qt.QFormLayout( self.processingCollapsibleButton) # Add vertical spacer self.layout.addStretch(1) self.widgets = [] for instruction in instructions: if instruction['type'] == 'volume': volume = ScalarVolumeWidget( destination=instruction['destination']) self.widgets.append(volume) self.processingFormLayout.addRow( '{} Volume: '.format(instruction['destination']), volume) if instruction['type'] == 'fiducials': fiducial = MarkupsFiducialWidget( destination=instruction['destination']) self.widgets.append(fiducial) self.processingFormLayout.addRow( '{} Fiducials: '.format(instruction['destination']), fiducial) if instruction['type'] == 'transform': transform = TransformWidget( destination=instruction['destination']) self.widgets.append(transform) self.processingFormLayout.addRow( '{} Transform: '.format(instruction['destination']), transform) if instruction['type'] == 'slider': slider = SliderWidget(destination=instruction['destination'], minimum=instruction['minimum'], maximum=instruction['maximum']) self.widgets.append(slider) self.processingFormLayout.addRow( '{} Slider: '.format(instruction['destination']), slider) if instruction['type'] == 'checkbox': checkbox = CheckboxWidget( destination=instruction['destination'], text=instruction['text']) self.widgets.append(checkbox) self.processingFormLayout.addRow( '{} Checkbox: '.format(instruction['destination']), checkbox) if instruction['type'] == 'radiobutton': radiobox = RadioButtonWidget( destination=instruction['destination'], options=instruction['options']) self.widgets.append(radiobox) self.processingFormLayout.addRow( '{} Options: '.format(instruction['text']), radiobox) self.applyButton = add_button('Process', 'Run the algorithm', enabled=True) self.processingFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton)
def setup( self ): ScriptedLoadableModuleWidget.setup(self) # # Logic # self.ptcLogic = PerkTutorCouchDBLogic() # # Save Area # saveCollapsibleButton = ctk.ctkCollapsibleButton() saveCollapsibleButton.text = "Save Session" self.layout.addWidget( saveCollapsibleButton ) # Layout within the collapsible button saveFormLayout = qt.QFormLayout( saveCollapsibleButton ) # User ID input self.saveUserIDLineEdit = qt.QLineEdit() saveFormLayout.addRow( "User ID", self.saveUserIDLineEdit ) # Study ID input self.saveStudyIDLineEdit = qt.QLineEdit() saveFormLayout.addRow("Study ID", self.saveStudyIDLineEdit ) # Trial ID input self.saveTrialIDLineEdit = qt.QLineEdit() saveFormLayout.addRow( "Trial ID", self.saveTrialIDLineEdit ) # skill level selector self.saveSkillSelector = qt.QComboBox() self.saveSkillSelector.addItems( SKILL_LEVEL_SELECTIONS ) saveFormLayout.addRow( "Skill level", self.saveSkillSelector ) # session completed selector self.saveSessionCompletionSelector = qt.QComboBox() self.saveSessionCompletionSelector.addItems( SESSION_COMPLETION_SELECTIONS ) saveFormLayout.addRow( "Status", self.saveSessionCompletionSelector ) # Node to save selector self.saveNodeSelector = slicer.qMRMLNodeComboBox() self.saveNodeSelector.noneEnabled = True self.saveNodeSelector.removeEnabled = False self.saveNodeSelector.addEnabled = False self.saveNodeSelector.renameEnabled = False self.saveNodeSelector.setMRMLScene( slicer.mrmlScene ) saveFormLayout.addRow( "Data", self.saveNodeSelector ) # Save Button self.saveButton = qt.QPushButton( "Save" ) self.saveButton.enabled = True saveFormLayout.addRow( self.saveButton ) # # Search Area # searchCollapsibleButton = ctk.ctkCollapsibleButton() searchCollapsibleButton.text = "Search For Session" self.layout.addWidget( searchCollapsibleButton ) # Layout within the collapsible button searchFormLayout = qt.QFormLayout( searchCollapsibleButton ) # Search user ID field self.searchUserIDLineEdit = qt.QLineEdit() searchFormLayout.addRow( "User ID", self.searchUserIDLineEdit ) # Search study ID field self.searchStudyIDLineEdit = qt.QLineEdit() searchFormLayout.addRow( "Study ID", self.searchStudyIDLineEdit ) # Search trial ID field self.searchTrialIDLineEdit = qt.QLineEdit() searchFormLayout.addRow( "Trial ID", self.searchTrialIDLineEdit ) # Search skill level field self.searchSkillSelector = qt.QComboBox() self.searchSkillSelector.addItems( ( "", ) + SKILL_LEVEL_SELECTIONS ) searchFormLayout.addRow( "Skill level", self.searchSkillSelector ) # Search Button self.searchButton = qt.QPushButton( "Search" ) self.searchButton.enabled = True searchFormLayout.addRow( self.searchButton ) # # Configuration # configurationCollapsibleButton = ctk.ctkCollapsibleButton() configurationCollapsibleButton.text = "Configuration" configurationCollapsibleButton.collapsed = True self.layout.addWidget( configurationCollapsibleButton ) # Layout within the collapsible button configurationVBoxLayout = qt.QVBoxLayout( configurationCollapsibleButton ) settings = slicer.app.userSettings() # # Database # databaseCollapsibleGroupBox = ctk.ctkCollapsibleGroupBox() databaseCollapsibleGroupBox.setTitle( "Remote Database" ) databaseCollapsibleGroupBox.collapsed = True configurationVBoxLayout.addWidget( databaseCollapsibleGroupBox ) # Layout within the group box databaseFormLayout = qt.QFormLayout( databaseCollapsibleGroupBox ) # Database username field self.databaseUsernameLineEdit = qt.QLineEdit() self.databaseUsernameLineEdit.setText( settings.value( self.moduleName + "/DatabaseUsername" ) ) databaseFormLayout.addRow( "Username", self.databaseUsernameLineEdit ) # Database password field self.databasePasswordLineEdit = qt.QLineEdit() self.databasePasswordLineEdit.setEchoMode( qt.QLineEdit.Password ) self.databasePasswordLineEdit.setText( settings.value( self.moduleName + "/DatabasePassword" ) ) databaseFormLayout.addRow( "Password", self.databasePasswordLineEdit ) # Remote database address self.databaseAddressLineEdit = qt.QLineEdit() self.databaseAddressLineEdit.setText( settings.value( self.moduleName + "/DatabaseAddress" ) ) databaseFormLayout.addRow( "Address", self.databaseAddressLineEdit ) # # File Server # fileServerCollapsibleGroupBox = ctk.ctkCollapsibleGroupBox() fileServerCollapsibleGroupBox.setTitle( "File Server" ) fileServerCollapsibleGroupBox.collapsed = True configurationVBoxLayout.addWidget( fileServerCollapsibleGroupBox ) # Layout within the group box fileServerFormLayout = qt.QFormLayout( fileServerCollapsibleGroupBox ) # File server session field self.fileServerSessionLineEdit = qt.QLineEdit() self.fileServerSessionLineEdit.setText( settings.value( self.moduleName + "/FileServerSession" ) ) fileServerFormLayout.addRow( "Session", self.fileServerSessionLineEdit ) # Local storage directory self.fileServerLocalDirectoryLineEdit = qt.QLineEdit() self.fileServerLocalDirectoryLineEdit.setText( settings.value( self.moduleName + "/FileServerLocalDirectory" ) ) fileServerFormLayout.addRow( "Local path", self.fileServerLocalDirectoryLineEdit ) # FTP client self.ftpClientDirectoryLineEdit = qt.QLineEdit() self.ftpClientDirectoryLineEdit.setText( settings.value( self.moduleName + "/FileServerClient" ) ) fileServerFormLayout.addRow( "FTP client", self.ftpClientDirectoryLineEdit ) # Update Button self.updateButton = qt.QPushButton( "Update" ) self.updateButton.enabled = True configurationVBoxLayout.addWidget( self.updateButton ) # # Stretcher # self.layout.addStretch( 1 ) # # Initialize the remote database from the settings at outset (if the settings are already specified) # try: self.ptcLogic.updateDatabase( PERK_TUTOR_DATABASE_NAME ) except Exception as e: logging.warning( e ) # # Connections # self.saveButton.connect( "clicked(bool)", self.onSaveButton ) self.searchButton.connect( "clicked(bool)", self.onSearchButton ) self.updateButton.connect( "clicked(bool)", self.onUpdateButton )
def setup(self): ScriptedLoadableModuleWidget.setup(self) self.stage = None # 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) #Parameters self.firstLandMarkSelected = False self.secondLandMarkSelected = False self.currentVisitingLandMark = 0 self.passCount = 0 # # input volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = False self.inputSelector.setMRMLScene(slicer.mrmlScene) self.inputSelector.setToolTip("Pick the input to the algorithm.") parametersFormLayout.addRow("Input Volume: ", self.inputSelector) # # output volume selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.outputSelector.selectNodeUponCreation = True self.outputSelector.addEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.noneEnabled = True self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.setMRMLScene(slicer.mrmlScene) self.outputSelector.setToolTip("Pick the output to the algorithm.") parametersFormLayout.addRow("Output Volume: ", self.outputSelector) # # threshold value # self.imageThresholdSliderWidget = ctk.ctkSliderWidget() self.imageThresholdSliderWidget.singleStep = 0.1 self.imageThresholdSliderWidget.minimum = -100 self.imageThresholdSliderWidget.maximum = 100 self.imageThresholdSliderWidget.value = 0.5 self.imageThresholdSliderWidget.setToolTip( "Set threshold value for computing the output image. Voxels that have intensities lower than this value will set to zero." ) parametersFormLayout.addRow("Image threshold", self.imageThresholdSliderWidget) # # check box to trigger taking screen shots for later use in tutorials # self.enableScreenshotsFlagCheckBox = qt.QCheckBox() self.enableScreenshotsFlagCheckBox.checked = 0 self.enableScreenshotsFlagCheckBox.setToolTip( "If checked, take screen shots for tutorials. Use Save Data to write them to disk." ) parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox) # # Connect to Positioner # ConnectionWarningLabel = qt.QLabel("Connect to the Stage") ConnectionWarningLabel.setWordWrap(True) parametersFormLayout.addRow(ConnectionWarningLabel) self.connectStageButton = qt.QPushButton("Connect To the Stage") self.connectStageButton.toolTip = "Connect to Stage" self.connectStageButton.enabled = True parametersFormLayout.addRow(self.connectStageButton) # # input fiducial list selector # fiducialWarningLabel = qt.QLabel( "Note: Parent transforms of fiducials are not used. Fiducials should be defined in the coordinate system that is being registered." ) fiducialWarningLabel.setWordWrap(True) parametersFormLayout.addRow(fiducialWarningLabel) self.inputFiducialSelector = slicer.qMRMLNodeComboBox() self.inputFiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "") self.inputFiducialSelector.selectNodeUponCreation = True self.inputFiducialSelector.addEnabled = False self.inputFiducialSelector.removeEnabled = False self.inputFiducialSelector.noneEnabled = False self.inputFiducialSelector.showHidden = False self.inputFiducialSelector.showChildNodeTypes = False self.inputFiducialSelector.setMRMLScene(slicer.mrmlScene) self.inputFiducialSelector.setToolTip( "Pick the input fiducial list for the algorithm.") parametersFormLayout.addRow("Input fiducials: ", self.inputFiducialSelector) # # First Landmark Button # self.set1stLandMarkButton = qt.QPushButton("Reset") self.set1stLandMarkButton.toolTip = "Reset" self.set1stLandMarkButton.enabled = True parametersFormLayout.addRow(self.set1stLandMarkButton) self.set2ndLandMarkButton = qt.QPushButton("Done") self.set2ndLandMarkButton.toolTip = "Set n-st Landmark" self.set2ndLandMarkButton.enabled = False parametersFormLayout.addRow(self.set2ndLandMarkButton) # # Target # self.targetFiducialSelector = slicer.qMRMLNodeComboBox() self.targetFiducialSelector.nodeTypes = (( "vtkMRMLMarkupsFiducialNode"), "") self.targetFiducialSelector.selectNodeUponCreation = True self.targetFiducialSelector.addEnabled = False self.targetFiducialSelector.removeEnabled = False self.targetFiducialSelector.noneEnabled = False self.targetFiducialSelector.showHidden = False self.targetFiducialSelector.showChildNodeTypes = False self.targetFiducialSelector.setMRMLScene(slicer.mrmlScene) self.targetFiducialSelector.setToolTip( "Pick the target fiducial list for the algorithm.") parametersFormLayout.addRow( "Target fiducials: 1st Target, 2ed Entrance", self.targetFiducialSelector) # # Second Landmark Button # self.applyButton = qt.QPushButton("Cacluate the Target") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.set1stLandMarkButton.connect('clicked(bool)', self.onSet1stLandMarkButton) self.set2ndLandMarkButton.connect('clicked(bool)', self.onSet2ndLandMarkButton) self.applyButton.connect('clicked(bool)', self.onApplyButton) self.connectStageButton.connect('clicked(bool)', self.onConnectStageButton) self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.inputFiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.targetFiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1) # Refresh Apply button state self.onSelect()
def setup(self): ScriptedLoadableModuleWidget.setup(self) self.layout.setContentsMargins(6, 6, 6, 6) # Init Button self.initButton = qt.QPushButton("Initialize") self.initButton.toolTip = "Initialize VR system, controllers, and room." self.layout.addWidget(self.initButton) # Calibration buttons self.calibrateGroupBox = qt.QGroupBox("Calibrations") self.calibrateGroupBox.enabled = False layout = qt.QHBoxLayout(self.calibrateGroupBox) layout.setContentsMargins(0, 0, 0, 0) self.floorButton = qt.QPushButton("Floor") self.floorButton.toolTip = "Calibrate the floor." self.faceButton = qt.QPushButton("Face") self.faceButton.toolTip = "Calibrate the face." layout.addWidget(self.floorButton) layout.addWidget(self.faceButton) self.layout.addWidget(self.calibrateGroupBox) # Inputs Area self.inputsGroupBox = qt.QGroupBox("Inputs") self.inputsGroupBox.enabled = False layout = qt.QFormLayout(self.inputsGroupBox) layout.setContentsMargins(0, 0, 0, 0) self.participantIdLineEdit = qt.QLineEdit() self.participantIdLineEdit.text = "000" self.conditionComboBox = qt.QComboBox() self.conditionComboBox.addItem("Motion") self.conditionComboBox.addItem("No motion") self.conditionComboBox.addItem("Replay") self.trialNumberSpinBox = qt.QSpinBox() self.trialNumberSpinBox.setValue(1) self.trialNumberSpinBox.setSingleStep(1) self.trialNumberSpinBox.setMinimum(1) layout.addRow("Participant ID:", self.participantIdLineEdit) layout.addRow("Condition:", self.conditionComboBox) layout.addRow("Trial Number:", self.trialNumberSpinBox) self.layout.addWidget(self.inputsGroupBox) # Sequences loading self.sequenceGroupBox = qt.QGroupBox("Target Sequences") layout = qt.QHBoxLayout(self.sequenceGroupBox) self.motionSequenceButton = qt.QPushButton("Load Motion") self.nomotionSequenceButton = qt.QPushButton("Load No-motion") self.replaySequenceButton = qt.QPushButton("Load Replay") layout.addWidget(self.motionSequenceButton) layout.addWidget(self.nomotionSequenceButton) layout.addWidget(self.replaySequenceButton) self.layout.addWidget(self.sequenceGroupBox) # Control UI self.controlGroupBox = qt.QGroupBox("Controls") layout = qt.QFormLayout(self.controlGroupBox) self.showControllerCheckBox = qt.QCheckBox() self.showNeedleCheckBox = qt.QCheckBox() self.showSphereCheckBox = qt.QCheckBox() layout.addRow("Show controller: ", self.showControllerCheckBox) layout.addRow("Show needle: ", self.showNeedleCheckBox) layout.addRow("Show sphere: ", self.showSphereCheckBox) self.layout.addWidget(self.controlGroupBox) # Capture related buttons widget = qt.QWidget() layout = qt.QHBoxLayout(widget) layout.setContentsMargins(0, 0, 0, 0) self.startButton = qt.QPushButton("Start") self.startButton.toolTip = "Start the capture sequence." self.startButton.enabled = False self.previousButton = qt.QPushButton("Previous") self.previousButton.toolTip = "Capture previous point." self.previousButton.enabled = False self.nextButton = qt.QPushButton("Next") self.nextButton.toolTip = "Capture next point." self.nextButton.enabled = False self.captureButton = qt.QPushButton("Go!") self.captureButton.toolTip = "Capture a data point." self.captureButton.enabled = False self.saveButton = qt.QPushButton("Save") self.saveButton.toolTip = "Save the current data set to file." self.saveButton.enabled = False self.resetButton = qt.QPushButton("Reset") self.resetButton.toolTip = "Reset the capture." self.resetButton.enabled = False layout.addWidget(self.startButton) layout.addWidget(self.previousButton) layout.addWidget(self.nextButton) layout.addWidget(self.captureButton) layout.addWidget(self.saveButton) layout.addWidget(self.resetButton) self.layout.addWidget(widget) # Results box self.resultGroupBox = qt.QGroupBox("Results") layout = qt.QHBoxLayout(self.resultGroupBox) self.resultLabel = qt.QLabel("") layout.addWidget(self.resultLabel) self.layout.addWidget(self.resultGroupBox) self.doConnect() # Add vertical spacer self.layout.addStretch(1)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # directory selection self.inputDirectoryButton = qt.QPushButton("Select a Directory") self.inputDirectory = None parametersFormLayout.addRow("DICOM Input:", self.inputDirectoryButton) # phantom type selection self.phantomModelSelector = qt.QGroupBox() vbox = qt.QVBoxLayout() self.phantom_radios = [] for name in sorted(phantom_definitions.PHANTOM_CATALOG.keys()): rb = qt.QRadioButton(name) self.phantom_radios.append(rb) vbox.addWidget(rb) self.phantomModelSelector.setLayout(vbox) parametersFormLayout.addRow("Select phantom model: ", self.phantomModelSelector) # # output DWI volume selector # self.outputDWISelector = slicer.qMRMLNodeComboBox() self.outputDWISelector.nodeTypes = [ "vtkMRMLDiffusionWeightedVolumeNode" ] self.outputDWISelector.selectNodeUponCreation = True self.outputDWISelector.addEnabled = True self.outputDWISelector.removeEnabled = True self.outputDWISelector.renameEnabled = True self.outputDWISelector.noneEnabled = False self.outputDWISelector.showHidden = False self.outputDWISelector.showChildNodeTypes = False self.outputDWISelector.setMRMLScene(slicer.mrmlScene) self.outputDWISelector.setToolTip("Pick the output to the algorithm.") parametersFormLayout.addRow("Output DWI Volume: ", self.outputDWISelector) # # output scalar volume selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.outputSelector.selectNodeUponCreation = True self.outputSelector.addEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.renameEnabled = True self.outputSelector.noneEnabled = False self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.setMRMLScene(slicer.mrmlScene) self.outputSelector.setToolTip("Pick the output to the algorithm.") parametersFormLayout.addRow("Output Scalar Volume: ", self.outputSelector) # # output VOI selector # self.outputVOISelector = slicer.qMRMLNodeComboBox() self.outputVOISelector.nodeTypes = ["vtkMRMLLabelMapVolumeNode"] self.outputVOISelector.selectNodeUponCreation = True self.outputVOISelector.addEnabled = True self.outputVOISelector.removeEnabled = True self.outputVOISelector.renameEnabled = True self.outputVOISelector.noneEnabled = False self.outputVOISelector.showHidden = False self.outputVOISelector.showChildNodeTypes = False self.outputVOISelector.setMRMLScene(slicer.mrmlScene) self.outputVOISelector.setToolTip( "Pick the output VOI to the algorithm.") parametersFormLayout.addRow("Output VOI: ", self.outputVOISelector) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputDirectoryButton.connect('clicked(bool)', self.onInputDirectory) self.phantomModelSelector.connect('clicked(bool)', self.onSelect) self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputDWISelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputVOISelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Refresh Apply button state self.onSelect() # Add space to display feedback from program self.statusLabel = qt.QPlainTextEdit() self.statusLabel.setTextInteractionFlags(qt.Qt.TextSelectableByMouse) parametersFormLayout.addRow(self.statusLabel) # Add vertical spacer self.layout.addStretch(1)
def setup(self): self.setLayout(qt.QFormLayout(self)) self._addDeviceLabel() self._addPresetsCombo() self._addSliders()
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # Parameters Area parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parametros" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # input volume selector self.baseSelector = slicer.qMRMLNodeComboBox() self.baseSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.baseSelector.selectNodeUponCreation = False self.baseSelector.addEnabled = False self.baseSelector.removeEnabled = False self.baseSelector.noneEnabled = False self.baseSelector.showHidden = False self.baseSelector.showChildNodeTypes = False self.baseSelector.setMRMLScene(slicer.mrmlScene) self.baseSelector.setToolTip("Volume base para comparacao") parametersFormLayout.addRow("Volume Base: ", self.baseSelector) # label 1 volume selector self.label1Selector = slicer.qMRMLNodeComboBox() self.label1Selector.nodeTypes = ["vtkMRMLLabelMapVolumeNode"] self.label1Selector.selectNodeUponCreation = True self.label1Selector.addEnabled = False self.label1Selector.removeEnabled = False self.label1Selector.noneEnabled = True self.label1Selector.showHidden = False self.label1Selector.showChildNodeTypes = False self.label1Selector.setMRMLScene(slicer.mrmlScene) parametersFormLayout.addRow("Label Map 1: ", self.label1Selector) self.label1Model = qt.QLabel() self.label1Model.enabled = False parametersFormLayout.addRow("Model:", self.label1Model) # label 2 volume selector self.label2Selector = slicer.qMRMLNodeComboBox() self.label2Selector.nodeTypes = ["vtkMRMLLabelMapVolumeNode"] self.label2Selector.selectNodeUponCreation = True self.label2Selector.addEnabled = False self.label2Selector.removeEnabled = False self.label2Selector.noneEnabled = True self.label2Selector.showHidden = False self.label2Selector.showChildNodeTypes = False self.label2Selector.setMRMLScene(slicer.mrmlScene) parametersFormLayout.addRow("Label Map 2: ", self.label2Selector) self.label2Model = qt.QLabel() self.label2Model.enabled = False parametersFormLayout.addRow("Model:", self.label2Model) # threshold value self.sliderWidget = ctk.ctkSliderWidget() self.sliderWidget.singleStep = 0.1 self.sliderWidget.minimum = 0 self.sliderWidget.maximum = 1 self.sliderWidget.value = 0.5 self.sliderWidget.enabled = False parametersFormLayout.addRow("label 2 <-> Label 1", self.sliderWidget) # Add vertical spacer self.layout.addStretch(1) # connections self.sliderWidget.connect("valueChanged(double)", self.onValueChanged) self.baseSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.baseSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.transparencyOnSelect) self.baseSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.setBackground) self.label1Selector.connect("currentNodeChanged(vtkMRMLNode*)", self.transparencyOnSelect) self.label1Selector.connect("currentNodeChanged(vtkMRMLNode*)", self.setLabel1) self.label2Selector.connect("currentNodeChanged(vtkMRMLNode*)", self.transparencyOnSelect) self.label2Selector.connect("currentNodeChanged(vtkMRMLNode*)", self.setLabel2) # Refresh Apply button state self.onSelect()
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # input/output collapsible area # inputOutputCollapsibleButton = ctk.ctkCollapsibleButton() inputOutputCollapsibleButton.text = "Input/Output" self.layout.addWidget(inputOutputCollapsibleButton) # Layout within the i/o collapsible button ioFormLayout = qt.QFormLayout(inputOutputCollapsibleButton) # # input volume selector # self.inputSelector = ctk.ctkPathLineEdit() self.inputSelector.filters = ctk.ctkPathLineEdit.Files self.inputSelector.setToolTip("Specify the input dwi") ioFormLayout.addRow("Input Volume: ", self.inputSelector) # # input mask selector # self.maskSelector = ctk.ctkPathLineEdit() self.maskSelector.filters = ctk.ctkPathLineEdit.Files self.maskSelector.setToolTip("Specify the mask of input dwi") ioFormLayout.addRow("Input Volume Mask: ", self.maskSelector) # # Create Mask # self.createMaskCheckBox = qt.QCheckBox('Create the mask') self.createMaskCheckBox.toolTip = "Check if you don't have a mask or would like to create one" self.createMaskCheckBox.enabled = True self.createMaskCheckBox.checked = False ioFormLayout.addWidget(self.createMaskCheckBox) self.createMask = False # # output directory selector # self.outputDirSelector = ctk.ctkPathLineEdit() self.outputDirSelector.filters = ctk.ctkPathLineEdit.Dirs self.outputDirSelector.setToolTip( "Specify the output directory, default: same as input dwi directory" ) ioFormLayout.addRow("Output Directory:", self.outputDirSelector) # # processing collapsible area # processCollapsibleButton = ctk.ctkCollapsibleButton() processCollapsibleButton.text = "Processing" self.layout.addWidget(processCollapsibleButton) # Layout within the processing collapsible button processFormLayout = qt.QFormLayout(processCollapsibleButton) processFormLayout.setSpacing(10) # # Visual Mode # self.visualMode = qt.QCheckBox('Slicer Visual Mode') self.visualMode.toolTip = '''Uncheck for auto processing w/o Slicer visualization and user interaction''' self.visualMode.enabled = True self.visualMode.checked = True processFormLayout.addWidget(self.visualMode) self.autoMode = True # Default initialization, used to trigger Slicer GUI # # Process Button # self.applyButton = qt.QPushButton("Process") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False processFormLayout.addRow(self.applyButton) # # Progress Bar # self.progressBar = slicer.qSlicerCLIProgressBar() self.progressBar.setToolTip("Progress of the algorithm") processFormLayout.addWidget(self.progressBar) # # Decision Labelling # self.decisionLabel = qt.QLabel("Gradient information") self.decisionLabel.setToolTip( "Machine learning decision for current gradient on display") self.decisionLabel.setStyleSheet("font: bold") processFormLayout.addWidget(self.decisionLabel) # # Summary Labelling # self.summaryLabel = qt.QLabel("QC summary") self.summaryLabel.setToolTip("Quality check summary") self.summaryLabel.setStyleSheet("font: bold") processFormLayout.addWidget(self.summaryLabel) # # Reset Result Button # self.resetResultsButton = qt.QPushButton("Reset Results") self.resetResultsButton.toolTip = "Reset to machine learning results." self.resetResultsButton.enabled = True processFormLayout.addRow(self.resetResultsButton) # # Decision collapsible area # processCollapsibleButton = ctk.ctkCollapsibleButton() processCollapsibleButton.text = "Decision" self.layout.addWidget(processCollapsibleButton) # Layout within the processing collapsible button decisionFormLayout = qt.QFormLayout(processCollapsibleButton) decisionFormLayout.setSpacing(10) # ------------------------------------------------------------------------- qualityPanel = qt.QHBoxLayout() # # Keep Gradient Button # self.keepButton = qt.QPushButton("Keep") self.keepButton.toolTip = "Keep the current gradient." self.keepButton.enabled = True qualityPanel.addWidget(self.keepButton) # # Discard Gradient Button # self.discardButton = qt.QPushButton("Discard") self.discardButton.toolTip = "Discard the current gradient." self.discardButton.enabled = True self.discardButton.setStyleSheet("background-color: red") qualityPanel.addWidget(self.discardButton) decisionFormLayout.addRow(qualityPanel) # ------------------------------------------------------------------------- # ------------------------------------------------------------------------- confidencePanel = qt.QHBoxLayout() # # Make it sure Button # self.sureButton = qt.QPushButton("Sure") self.sureButton.toolTip = "Make it sure." self.sureButton.enabled = True confidencePanel.addWidget(self.sureButton) # Make it unsure Button # self.unsureButton = qt.QPushButton("Unsure") self.unsureButton.toolTip = "Make it unsure." self.unsureButton.enabled = True self.unsureButton.setStyleSheet("background-color: yellow") confidencePanel.addWidget(self.unsureButton) decisionFormLayout.addRow(confidencePanel) # ------------------------------------------------------------------------- # # Next Review Button # self.nextReviewButton = qt.QPushButton("Next Review") self.nextReviewButton.toolTip = "Pull up the next gradient for review." self.nextReviewButton.enabled = True decisionFormLayout.addRow(self.nextReviewButton) # # Finish collapsible area # processCollapsibleButton = ctk.ctkCollapsibleButton() processCollapsibleButton.text = "Finish" self.layout.addWidget(processCollapsibleButton) # Layout within the processing collapsible button finishFormLayout = qt.QFormLayout(processCollapsibleButton) # # Save Result Button # self.saveResultsButton = qt.QPushButton("Save") self.saveResultsButton.toolTip = "Save the results." self.saveResultsButton.enabled = True finishFormLayout.addRow(self.saveResultsButton) # Add vertical spacer self.layout.addStretch(1) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputSelector.connect("currentPathChanged(QString)", self.onSelectInput) self.maskSelector.connect("currentPathChanged(QString)", self.onSelectMask) self.outputDirSelector.connect("currentPathChanged(QString)", self.onSelectOutput) self.visualMode.connect('toggled(bool)', self.onVisualMode) self.createMaskCheckBox.connect('toggled(bool)', self.withoutMask)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # parameters area parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # transform of interest selector self.transformOfInterestSelectorLabel = qt.QLabel() self.transformOfInterestSelectorLabel.setText( "Transform of Interest: " ) self.transformOfInterestSelector = slicer.qMRMLNodeComboBox() self.transformOfInterestSelector.nodeTypes = ( ["vtkMRMLTransformNode"] ) self.transformOfInterestSelector.noneEnabled = False self.transformOfInterestSelector.addEnabled = False self.transformOfInterestSelector.removeEnabled = True self.transformOfInterestSelector.setMRMLScene( slicer.mrmlScene ) self.transformOfInterestSelector.setToolTip( "Pick transform of interest (e.g., optical tracker)" ) parametersFormLayout.addRow(self.transformOfInterestSelectorLabel, self.transformOfInterestSelector) # num points selector self.numPointsSliderWidget = ctk.ctkSliderWidget() self.numPointsSliderWidget.singleStep = 1 self.numPointsSliderWidget.minimum = 10 self.numPointsSliderWidget.maximum = 300 self.numPointsSliderWidget.value = 5 self.numPointsSliderWidget.setToolTip("Set the number of points to monitor the transform for.") parametersFormLayout.addRow("Num Points:", self.numPointsSliderWidget) # results form resultsCollapsibleButton = ctk.ctkCollapsibleButton() resultsCollapsibleButton.text = "Median 3DOF positions of most recent trial" self.layout.addWidget(resultsCollapsibleButton) resultsFormLayout = qt.QFormLayout(resultsCollapsibleButton) self.medianPosXLabel = qt.QLabel("Pos x (mm): ") self.medianPosXValueLabel = qt.QLabel() self.medianPosYLabel = qt.QLabel("Pos y (mm): ") self.medianPosYValueLabel = qt.QLabel() self.medianPosZLabel = qt.QLabel("Pos z (mm): ") self.medianPosZValueLabel = qt.QLabel() resultsFormLayout.addRow(self.medianPosXLabel, self.medianPosXValueLabel) resultsFormLayout.addRow(self.medianPosYLabel, self.medianPosYValueLabel) resultsFormLayout.addRow(self.medianPosZLabel, self.medianPosZValueLabel) # write data and results form writeDataCollapsibleButton = ctk.ctkCollapsibleButton() writeDataCollapsibleButton.text = "Write data from most recent trial to csv" self.layout.addWidget(writeDataCollapsibleButton) writeDataFormLayout = qt.QFormLayout(writeDataCollapsibleButton) # field of view and positions text boxes self.fileDirLabel = "Output Dir:" self.fileDirTextBox = qt.QLineEdit() self.trackerLabel = "Tracker:" self.trackerTextBox = qt.QLineEdit() self.fovLabel = "FOV Region:" self.fovTextBox = qt.QLineEdit() self.posLabel = "Position (#):" self.posTextBox = qt.QLineEdit() writeDataFormLayout.addRow(self.fileDirLabel, self.fileDirTextBox) writeDataFormLayout.addRow(self.trackerLabel, self.trackerTextBox) writeDataFormLayout.addRow(self.fovLabel, self.fovTextBox) writeDataFormLayout.addRow(self.posLabel, self.posTextBox) # start button self.startButton = qt.QPushButton("Start Sample Collection") self.startButton.toolTip = "Collect a sample." self.startButton.enabled = True self.layout.addWidget(self.startButton) # stop button self.stopButton = qt.QPushButton("Stop Sample Collection") self.stopButton.toolTip = "Collect a sample." self.stopButton.enabled = True self.layout.addWidget(self.stopButton) # start endless button self.startEndlessButton = qt.QPushButton("Start Endless Sample Collection") self.startEndlessButton.toolTip = "Collect samples until stop button is pressed (or 20,000 samples is reached)." self.startEndlessButton.enabled = True self.layout.addWidget(self.startEndlessButton) # stop endless button self.stopEndlessButton = qt.QPushButton("Stop Endless Sample Collection") self.stopEndlessButton.toolTip = "Stop collecting endless samples." self.stopEndlessButton.enabled = True self.layout.addWidget(self.stopEndlessButton) # connections self.startButton.connect('clicked(bool)', self.onStart) self.stopButton.connect('clicked(bool)', self.onStop) self.startEndlessButton.connect('clicked(bool)', self.onStartEndless) self.stopEndlessButton.connect('clicked(bool)', self.onStopEndless) # Add vertical spacer self.layout.addStretch(1)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # File area # filesCollapsibleButton = ctk.ctkCollapsibleButton() filesCollapsibleButton.text = "Input files" filesCollapsibleButton.collapsed = False self.layout.addWidget(filesCollapsibleButton) # Layout within the files collapsible button filesFormLayout = qt.QFormLayout(filesCollapsibleButton) # select one file buttonLayout = qt.QHBoxLayout() self.archetypeText = qt.QLineEdit() buttonLayout.addWidget(self.archetypeText) self.addFromArchetype = qt.QPushButton("Browse...") buttonLayout.addWidget(self.addFromArchetype) self.archetypeStartNumber = 0 filesFormLayout.addRow("Filename pattern: ", buttonLayout) # file list group fileListGroupBox = ctk.ctkCollapsibleGroupBox() fileListGroupBox.title = "File list" fileListLayout = qt.QVBoxLayout() fileListGroupBox.setLayout(fileListLayout) filesFormLayout.addRow("", fileListGroupBox) self.addByBrowsingButton = qt.QPushButton("Select files...") fileListLayout.addWidget(self.addByBrowsingButton) self.fileTable = qt.QTextBrowser() fileListLayout.addWidget(self.fileTable) fileListGroupBox.collapsed = True # original volume size self.originalVolumeSizeLabel = qt.QLabel() filesFormLayout.addRow("Size: ", self.originalVolumeSizeLabel) # reverse slice order self.reverseCheckBox = qt.QCheckBox() self.reverseCheckBox.toolTip = "Read the images in reverse order (flips loaded volume along IS axis)" filesFormLayout.addRow("Reverse: ", self.reverseCheckBox) # original spacing self.spacingWidget = slicer.qMRMLCoordinatesWidget() self.spacingWidget.setMRMLScene(slicer.mrmlScene) self.spacingWidget.decimalsOption = ctk.ctkDoubleSpinBox.DecimalsByKey | ctk.ctkDoubleSpinBox.DecimalsByShortcuts | ctk.ctkDoubleSpinBox.DecimalsByValue self.spacingWidget.minimum = 0.0 self.spacingWidget.maximum = 1000000000.0 self.spacingWidget.quantity = "length" self.spacingWidget.unitAwareProperties = slicer.qMRMLCoordinatesWidget.Precision | slicer.qMRMLCoordinatesWidget.Prefix | slicer.qMRMLCoordinatesWidget.Scaling | slicer.qMRMLCoordinatesWidget.Suffix self.spacingWidget.coordinates = "1,1,1" self.spacingWidget.toolTip = "Set the colunm, row, slice spacing; original spacing not including downsample" filesFormLayout.addRow("Spacing: ", self.spacingWidget) # # output area # outputCollapsibleButton = ctk.ctkCollapsibleButton() outputCollapsibleButton.text = "Output" outputCollapsibleButton.collapsed = False self.layout.addWidget(outputCollapsibleButton) outputFormLayout = qt.QFormLayout(outputCollapsibleButton) # # output volume selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.outputSelector.showChildNodeTypes = False self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.selectNodeUponCreation = True self.outputSelector.noneEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.renameEnabled = True self.outputSelector.addEnabled = True self.outputSelector.noneDisplay = "(Create new volume)" self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputSelector.setToolTip( "Pick the output volume to populate or None to autogenerate." ) outputFormLayout.addRow("Output Volume: ", self.outputSelector) # # output ROI selector # self.outputROISelector = slicer.qMRMLNodeComboBox() self.outputROISelector.nodeTypes = ["vtkMRMLAnnotationROINode", "vtkMRMLMarkupsROINode"] self.outputROISelector.showChildNodeTypes = False self.outputROISelector.showHidden = False self.outputROISelector.showChildNodeTypes = False self.outputROISelector.noneEnabled = True self.outputROISelector.removeEnabled = True self.outputROISelector.renameEnabled = True self.outputROISelector.addEnabled = False self.outputROISelector.noneDisplay = "(Full volume)" self.outputROISelector.setMRMLScene( slicer.mrmlScene ) self.outputROISelector.setToolTip( "Set the region of the volume that will be loaded") outputFormLayout.addRow("Region of interest: ", self.outputROISelector) # # Quality selector # qualityLayout = qt.QVBoxLayout() self.qualityPreviewRadioButton = qt.QRadioButton("preview") self.qualityHalfRadioButton = qt.QRadioButton("half resolution") self.qualityFullRadioButton = qt.QRadioButton("full resolution") qualityLayout.addWidget(self.qualityPreviewRadioButton) qualityLayout.addWidget(self.qualityHalfRadioButton) qualityLayout.addWidget(self.qualityFullRadioButton) self.qualityPreviewRadioButton.setChecked(True) outputFormLayout.addRow("Quality: ", qualityLayout) self.sliceSkipSpinBox = qt.QSpinBox() self.sliceSkipSpinBox.toolTip = "Skips the selected number of slices between each pair of output volume slices (use, for example, on long thin samples with more slices than in-plane resolution)" outputFormLayout.addRow("Slice skip: ", self.sliceSkipSpinBox) # output volume size self.outputVolumeSizeLabel = qt.QLabel() outputFormLayout.addRow("Output size: ", self.outputVolumeSizeLabel) # output volume spacing self.outputSpacingWidget = slicer.qMRMLCoordinatesWidget() self.outputSpacingWidget.setMRMLScene(slicer.mrmlScene) self.outputSpacingWidget.readOnly = True self.outputSpacingWidget.frame = False self.outputSpacingWidget.decimalsOption = ctk.ctkDoubleSpinBox.DecimalsByKey | ctk.ctkDoubleSpinBox.DecimalsByShortcuts | ctk.ctkDoubleSpinBox.DecimalsByValue self.outputSpacingWidget.minimum = 0.0 self.outputSpacingWidget.maximum = 1000000000.0 self.outputSpacingWidget.quantity = "length" self.outputSpacingWidget.unitAwareProperties = slicer.qMRMLCoordinatesWidget.Precision | slicer.qMRMLCoordinatesWidget.Prefix | slicer.qMRMLCoordinatesWidget.Scaling | slicer.qMRMLCoordinatesWidget.Suffix self.outputSpacingWidget.coordinates = "1,1,1" self.outputSpacingWidget.toolTip = "Slice spacing of the volume that will be loaded" outputFormLayout.addRow("Output spacing: ", self.outputSpacingWidget) self.loadButton = qt.QPushButton("Load files") self.loadButton.toolTip = "Load files as a 3D volume" self.loadButton.enabled = False outputFormLayout.addRow(self.loadButton) # connections self.reverseCheckBox.connect('toggled(bool)', self.updateLogicFromWidget) self.sliceSkipSpinBox.connect("valueChanged(int)", self.updateLogicFromWidget) self.spacingWidget.connect("coordinatesChanged(double*)", self.updateLogicFromWidget) self.qualityPreviewRadioButton.connect("toggled(bool)", lambda toggled, widget=self.qualityPreviewRadioButton: self.onQualityToggled(toggled, widget)) self.qualityHalfRadioButton.connect("toggled(bool)", lambda toggled, widget=self.qualityHalfRadioButton: self.onQualityToggled(toggled, widget)) self.qualityFullRadioButton.connect("toggled(bool)", lambda toggled, widget=self.qualityFullRadioButton: self.onQualityToggled(toggled, widget)) self.outputROISelector.connect("currentNodeChanged(vtkMRMLNode*)", self.setOutputROINode) self.addByBrowsingButton.connect('clicked()', self.addByBrowsing) self.addFromArchetype.connect('clicked()', self.selectArchetype) self.archetypeText.connect('textChanged(const QString &)', self.populateFromArchetype) self.loadButton.connect('clicked()', self.onLoadButton) # Add vertical spacer self.layout.addStretch(1) self.loadButton.enabled = False
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Input Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # Select base mesh # self.modelSelector = slicer.qMRMLNodeComboBox() self.modelSelector.nodeTypes = (("vtkMRMLModelNode"), "") self.modelSelector.selectNodeUponCreation = False self.modelSelector.addEnabled = False self.modelSelector.removeEnabled = False self.modelSelector.noneEnabled = True self.modelSelector.showHidden = False self.modelSelector.setMRMLScene(slicer.mrmlScene) parametersFormLayout.addRow("Base mesh: ", self.modelSelector) # # Set spacing tolerance # self.spacingTolerance = ctk.ctkSliderWidget() self.spacingTolerance.singleStep = .1 self.spacingTolerance.minimum = 0 self.spacingTolerance.maximum = 10 self.spacingTolerance.value = 4 self.spacingTolerance.setToolTip( "Set tolerance of spacing as a percentage of the image diagonal") parametersFormLayout.addRow("Spacing tolerance: ", self.spacingTolerance) # # Parameters Area # templateCollapsibleButton = ctk.ctkCollapsibleButton() templateCollapsibleButton.text = "Template Geometry" self.layout.addWidget(templateCollapsibleButton) # Layout within the dummy collapsible button templateFormLayout = qt.QFormLayout(templateCollapsibleButton) # # Select geometry of template # self.OriginalType = qt.QRadioButton() self.OriginalType.setChecked(True) self.EllipseType = qt.QRadioButton() self.SphereType = qt.QRadioButton() templateFormLayout.addRow("Original Geometry", self.OriginalType) templateFormLayout.addRow("Ellipse", self.EllipseType) templateFormLayout.addRow("Sphere", self.SphereType) # # Specify plane of symmetry # self.planeSelector = slicer.qMRMLNodeComboBox() self.planeSelector.nodeTypes = (("vtkMRMLMarkupsPlaneNode"), "") self.planeSelector.enabled = True self.planeSelector.selectNodeUponCreation = False self.planeSelector.addEnabled = False self.planeSelector.removeEnabled = False self.planeSelector.noneEnabled = True self.planeSelector.showHidden = False self.planeSelector.setMRMLScene(slicer.mrmlScene) templateFormLayout.addRow("Symmetry plane: ", self.planeSelector) # # Set template scale factor # self.scaleFactor = ctk.ctkSliderWidget() self.scaleFactor.enabled = False self.scaleFactor.singleStep = 1 self.scaleFactor.minimum = 75 self.scaleFactor.maximum = 150 self.scaleFactor.value = 110 self.scaleFactor.setToolTip( "Set template scale factor as a percentage of the image diagonal") templateFormLayout.addRow("Template scale factor : ", self.scaleFactor) # # Set max projection factor # self.projectionFactor = ctk.ctkSliderWidget() self.projectionFactor.enabled = False self.projectionFactor.singleStep = 1 self.projectionFactor.minimum = 1 self.projectionFactor.maximum = 200 self.projectionFactor.value = 200 self.projectionFactor.setToolTip( "Set maximum projection as a percentage of the image diagonal") templateFormLayout.addRow("Maximum projection factor : ", self.projectionFactor) # # Run Area # samplingCollapsibleButton = ctk.ctkCollapsibleButton() samplingCollapsibleButton.text = "Run Sampling" self.layout.addWidget(samplingCollapsibleButton) # Layout within the dummy collapsible button samplingFormLayout = qt.QFormLayout(samplingCollapsibleButton) # # Get Subsample Rate Button # self.getPointNumberButton = qt.QPushButton("Get subsample number") self.getPointNumberButton.toolTip = "Output the number of points sampled on the template shape." self.getPointNumberButton.enabled = False samplingFormLayout.addRow(self.getPointNumberButton) # # Subsample Information # self.subsampleInfo = qt.QPlainTextEdit() self.subsampleInfo.setPlaceholderText("Subsampling information") self.subsampleInfo.setReadOnly(True) samplingFormLayout.addRow(self.subsampleInfo) # # Apply sphere button # self.applySphereButton = qt.QPushButton("Generate template") self.applySphereButton.toolTip = "Generate sampled template shape." self.applySphereButton.enabled = False samplingFormLayout.addRow(self.applySphereButton) # # Project Points button # self.projectPointsButton = qt.QPushButton("Project points to surface") self.projectPointsButton.toolTip = "Project the points from the sampled template to the model surface." self.projectPointsButton.enabled = False samplingFormLayout.addRow(self.projectPointsButton) # # Clean Points button # self.cleanButton = qt.QPushButton("Enforce spatial sampling rate") self.cleanButton.toolTip = "Remove points spaced closer than the user-specified tolerance." self.cleanButton.enabled = False samplingFormLayout.addRow(self.cleanButton) # connections self.modelSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onSelect) self.OriginalType.connect('toggled(bool)', self.onToggleModel) self.getPointNumberButton.connect('clicked(bool)', self.onGetPointNumberButton) self.applySphereButton.connect('clicked(bool)', self.onApplySphereButton) self.projectPointsButton.connect('clicked(bool)', self.onProjectPointsButton) self.cleanButton.connect('clicked(bool)', self.onCleanButton) # Add vertical spacer self.layout.addStretch(1)
def setup(self): # Instantiate and connect widgets ... ScriptedLoadableModuleWidget.setup(self) #self.logic = CIP_CalciumScoringLogic() # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # target volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = False self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputSelector.setToolTip( "Pick the input to the algorithm." ) parametersFormLayout.addRow("Target Volume: ", self.inputSelector) self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onVolumeChanged) self.volumeNode = self.inputSelector.currentNode() # # calcification type # # self.calcificationTypeBox = qt.QComboBox() # self.calcificationTypeBox.addItem("Heart") # self.calcificationTypeBox.addItem("Aorta") # parametersFormLayout.addRow("Region", self.calcificationTypeBox) # self.calcificationTypeBox.connect("currentIndexChanged(int)", self.onTypeChanged) self.ThresholdRange = ctk.ctkRangeWidget() self.ThresholdRange.minimum = 0 self.ThresholdRange.maximum = 2000 self.ThresholdRange.setMinimumValue(self.ThresholdMin) self.ThresholdRange.setMaximumValue(self.ThresholdMax) self.ThresholdRange.connect("minimumValueChanged(double)", self.onThresholdMinChanged) self.ThresholdRange.connect("maximumValueChanged(double)", self.onThresholdMaxChanged) parametersFormLayout.addRow("Threshold Value", self.ThresholdRange) self.ThresholdRange.setMinimumValue(self.ThresholdMin) self.ThresholdRange.setMaximumValue(self.ThresholdMax) self.LesionSizeRange= ctk.ctkRangeWidget() self.LesionSizeRange.minimum = 0.5 self.LesionSizeRange.maximum = 1000 self.LesionSizeRange.setMinimumValue(self.MinimumLesionSize) self.LesionSizeRange.setMaximumValue(self.MaximumLesionSize) self.LesionSizeRange.connect("minimumValueChanged(double)", self.onMinSizeChanged) self.LesionSizeRange.connect("maximumValueChanged(double)", self.onMaxSizeChanged) parametersFormLayout.addRow("Lesion Size (mm^3)", self.LesionSizeRange) self.LesionSizeRange.setMinimumValue(self.MinimumLesionSize) self.LesionSizeRange.setMaximumValue(self.MaximumLesionSize) self.scoreField=dict() for sr in self.summary_reports: self.scoreField[sr] = qt.QLineEdit() self.scoreField[sr].setText(0) parametersFormLayout.addRow("Total "+sr, self.scoreField[sr]) # # Update button and Select Table # self.updateButton = qt.QPushButton("Update") self.updateButton.toolTip = "Update calcium score computation" self.updateButton.enabled = True self.updateButton.setFixedSize(100, 50) #parametersFormLayout.addRow("", self.updateButton) self.updateButton.connect('clicked()', self.onUpdate) # # Select table # self.selectLabels = qt.QTableWidget() #self.selectLabels.horizontalHeader().hide() self.selectLabels.verticalHeader().hide() self.selectLabels.setColumnCount(6) self.selectLabels.itemClicked.connect(self.handleItemClicked) #Add row with columns name col_names=["","Agatston Score","Mass Score","Volume (mm^3)","Mean HU","Max HU"] self.selectLabels.setHorizontalHeaderLabels(col_names) parametersFormLayout.addRow(self.updateButton, self.selectLabels) # # Save Widget Area # #self.saveCollapsibleButton = ctk.ctkCollapsibleButton() #self.saveCollapsibleButton.text = "Saving" #self.layout.addWidget(self.saveCollapsibleButton) self.reportsWidget = CaseReportsWidget(self.moduleName, self.columnsDict, parentWidget=self.parent) self.reportsWidget.setup() self.reportsWidget.showPrintButton(False) self.reportsWidget.addObservable(self.reportsWidget.EVENT_SAVE_BUTTON_CLICKED, self.onSaveReport) # # ROI Area # self.roiCollapsibleButton = ctk.ctkCollapsibleButton() self.roiCollapsibleButton.text = "ROI" self.roiCollapsibleButton.setChecked(False) self.layout.addWidget(self.roiCollapsibleButton) # Layout within the dummy collapsible button roiFormLayout = qt.QFormLayout(self.roiCollapsibleButton) # # ROI # self.ROIWidget = slicer.qMRMLAnnotationROIWidget() self.roiNode = slicer.vtkMRMLAnnotationROINode() slicer.mrmlScene.AddNode(self.roiNode) self.ROIWidget.setMRMLAnnotationROINode(self.roiNode) roiFormLayout.addRow("", self.ROIWidget) #self.roiNode.AddObserver("ModifiedEvent", self.onROIChangedEvent, 1) # Add vertical spacer self.layout.addStretch(1) # Add temp nodes self.croppedNode=slicer.vtkMRMLScalarVolumeNode() self.croppedNode.SetHideFromEditors(1) slicer.mrmlScene.AddNode(self.croppedNode) self.labelsNode=slicer.vtkMRMLLabelMapVolumeNode() slicer.mrmlScene.AddNode(self.labelsNode) if self.inputSelector.currentNode(): self.onVolumeChanged(self.inputSelector.currentNode())
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # input volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = False self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputSelector.setToolTip( "Pick the input to the algorithm." ) parametersFormLayout.addRow("Input Volume: ", self.inputSelector) # # output volume selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.outputSelector.selectNodeUponCreation = True self.outputSelector.addEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.noneEnabled = True self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputSelector.setToolTip( "Pick the output to the algorithm." ) parametersFormLayout.addRow("Output Volume: ", self.outputSelector) # # threshold value # self.imageThresholdSliderWidget = ctk.ctkSliderWidget() self.imageThresholdSliderWidget.singleStep = 0.1 self.imageThresholdSliderWidget.minimum = -100 self.imageThresholdSliderWidget.maximum = 100 self.imageThresholdSliderWidget.value = 0.5 self.imageThresholdSliderWidget.setToolTip("Set threshold value for computing the output image. Voxels that have intensities lower than this value will set to zero.") parametersFormLayout.addRow("Image threshold", self.imageThresholdSliderWidget) # # check box to trigger taking screen shots for later use in tutorials # self.enableScreenshotsFlagCheckBox = qt.QCheckBox() self.enableScreenshotsFlagCheckBox.checked = 0 self.enableScreenshotsFlagCheckBox.setToolTip("If checked, take screen shots for tutorials. Use Save Data to write them to disk.") parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1) # 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._initLogic_() self.currentVolumeLoaded = None self.blockNodeEvents = False ########## # Volume selection self.volumeSelectionCollapsibleButton = ctk.ctkCollapsibleButton() self.volumeSelectionCollapsibleButton.text = "Volume selection" self.layout.addWidget(self.volumeSelectionCollapsibleButton) self.volumeSelectionLayout = qt.QFormLayout( self.volumeSelectionCollapsibleButton) # 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.volumeSelectionLayout.addWidget(self.volumeSelector, 0, 1, 1, 3) self.volumeSelectionLayout.addRow("Active volume:", self.volumeSelector) self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.__onCurrentNodeChanged__) ########## # 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) # Radio buttons frame. This will be filled by every child module self.radioButtonsFrame = qt.QFrame() self.mainLayout.addWidget(self.radioButtonsFrame, 2, 0, 1, 3, SlicerUtil.ALIGNMENT_VERTICAL_TOP) # 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) self.loadButton.connect('clicked()', self.openFiducialsFile) # 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) self.removeLastFiducialButton.connect( 'clicked()', self.__onRemoveLastFiducialButtonClicked__) # 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.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(375) self.mainLayout.addWidget(self.saveResultsDirectoryButton, 4, 1, 1, 2) self.saveResultsDirectoryButton.connect( "directoryChanged (QString)", self.__onSaveResultsDirectoryChanged__) ##### # 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) for key, value in self.additionalFileTypes.iteritems(): self.caseNavigatorWidget.additionalFileTypes[key] = value self.caseNavigatorWidget.setup() # Listen for the event of loading a new labelmap # self.caseNavigatorWidget.addObservable(self.caseNavigatorWidget.EVENT_LABELMAP_LOADED, self.__onNewILDClassificationLabelmapLoaded__) self.caseNavigatorWidget.addObservable( self.caseNavigatorWidget.EVENT_BUNDLE_CASE_FINISHED, self._onFinishCaseBundleLoad_) self.layout.addStretch() # Extra Connections self._createSceneObservers_()
def setup(self): ScriptedLoadableModuleWidget.setup(self) self.predictionUrl = '' self.interfaceUrl = '' self.clearToSendMsg = False # Instantiate and connect widgets ... # # LOGO area # logoCollapsibleButton = collapsible_button('Info') self.layout.addWidget(logoCollapsibleButton) self.logolayout = qt.QFormLayout(logoCollapsibleButton) self.logolabel, _ = \ add_image(os.path.join(os.path.split(os.path.realpath(__file__))[0], "Resources/Icons/TOMAAT_INFO.png")) self.logolayout.addRow(self.logolabel) # # Direct Connection area # directConnectionCollapsibleButton = collapsible_button( 'Direct Connection') self.layout.addWidget(directConnectionCollapsibleButton) self.directConnectionLayout = qt.QFormLayout( directConnectionCollapsibleButton) self.urlBoxDirectConnection = add_textbox("http://localhost:9000") self.urlBoxButton = add_button(text='Confirm', tooltip_text='Confirm entry', click_function=self.select_from_textbox, enabled=True) self.directConnectionLayout.addRow("Server URL: ", self.urlBoxDirectConnection) self.directConnectionLayout.addRow(self.urlBoxButton) directConnectionCollapsibleButton.collapsed = True # # Managed Connection area # managedConenctionCollapsibleButton = collapsible_button( 'Public Server List') self.layout.addWidget(managedConenctionCollapsibleButton) self.managedConnectionLayout = qt.QFormLayout( managedConenctionCollapsibleButton) self.urlBoxManagedConnection = add_textbox( "http://tomaat.cloud:8001/discover") self.managedConnectionLayout.addRow("Discovery Server URL: ", self.urlBoxManagedConnection) self.serviceTree = qt.QTreeWidget() self.serviceTree.setHeaderLabel('Available services') self.serviceTree.itemSelectionChanged.connect(self.select_from_tree) self.discoverServicesButton = add_button( "Discover Services", "Discover available segmentation services on the net.", self.onDiscoverButton, True) self.serviceDescription = add_label('') self.managedConnectionLayout.addRow(self.discoverServicesButton) self.managedConnectionLayout.addRow(self.serviceTree) self.managedConnectionLayout.addRow(self.serviceDescription) self.processingCollapsibleButton = None
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # input volume selector # with It(slicer.qMRMLNodeComboBox()) as w: self.inputSelector = w w.nodeTypes = ["vtkMRMLFiberBundleNode"] w.selectNodeUponCreation = True w.addEnabled = False w.removeEnabled = False w.noneEnabled = False w.showHidden = False w.showChildNodeTypes = False w.setMRMLScene(slicer.mrmlScene) w.setToolTip("Pick the fiber bundle to export.") parametersFormLayout.addRow("Input FiberBundleNode: ", self.inputSelector) # # tube radius controller # with It(ctk.ctkSliderWidget()) as w: self.radiusSelector = w w.minimum = 0.1 w.maximum = 20.0 w.singleStep = 0.1 w.setToolTip("Select radius for output tubes") parametersFormLayout.addRow("Tube radius: ", self.radiusSelector) with It(ctk.ctkSliderWidget()) as w: self.numSidesSelector = w w.value = 6 w.decimals = 0 w.minimum = 3 w.maximum = 20 w.singleStep = 1 w.pageStep = 1 w.setToolTip( "Select number of sides for output tube: higher number will look nicer, but will take more memory and time to export." ) parametersFormLayout.addRow("Number of sides: ", self.numSidesSelector) # # use native scalar range # with It(qt.QCheckBox()) as w: self.nativeRangeCheckbox = w w.checked = True w.setToolTip( "Checked: set the scalar range of the exported color table to match the scalar range of the selected node. Otherwise, the range will be set to [0,1]." ) parametersFormLayout.addRow("Restrict scalar range", w) # # output file selector, export button, and status frame # with It(ctk.ctkPathLineEdit()) as w: self.outputFileSelector = w # make a file-only, save dialog w.filters = ctk.ctkPathLineEdit.Files | ctk.ctkPathLineEdit.Writable w.connect('currentPathChanged(const QString&)', self.reset) parametersFormLayout.addRow("Output File: ", self.outputFileSelector) with It(qt.QPushButton("Export")) as w: self.exportButton = w w.toolTip = "Run Export" w.styleSheet = "background: lightgray" w.connect('clicked(bool)', self.onExport) parametersFormLayout.addRow("", w) with It(qt.QStatusBar()) as w: self.statusLabel = w w.setToolTip("CLI status") w.styleSheet = "background: lightgray" parametersFormLayout.addRow("Status: ", w) # Add vertical spacer self.layout.addStretch(1)
def setup_registration_area(self): """ Setup image registration area and connect functions. """ registration_collapsible_button = ctk.ctkCollapsibleButton() registration_collapsible_button.text = "Register Image to Frame" registration_collapsible_button.setDisabled(False) registration_collapsible_button.collapsed = False self.layout.addWidget(registration_collapsible_button) # Layout within the dummy collapsible button registration_form_layout = qt.QFormLayout( registration_collapsible_button) # # input fiducial list selector # fiducial_warning_label = qt.QLabel( "Note: Parent transforms of fiducials are not used. " "Fiducials should be defined in the coordinate system " "that is being registered.") fiducial_warning_label.setWordWrap(True) registration_form_layout.addRow(fiducial_warning_label) self.input_fiducial_selector = slicer.qMRMLNodeComboBox() self.input_fiducial_selector.nodeTypes = (( "vtkMRMLMarkupsFiducialNode"), "") self.input_fiducial_selector.selectNodeUponCreation = False self.input_fiducial_selector.addEnabled = False self.input_fiducial_selector.removeEnabled = False self.input_fiducial_selector.noneEnabled = True self.input_fiducial_selector.showHidden = False self.input_fiducial_selector.showChildNodeTypes = False self.input_fiducial_selector.setMRMLScene(slicer.mrmlScene) self.input_fiducial_selector.setToolTip( "Pick the input fiducial list for the algorithm.") registration_form_layout.addRow("Input fiducials: ", self.input_fiducial_selector) # # input volume selector # self.input_volume_selector = slicer.qMRMLNodeComboBox() self.input_volume_selector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.input_volume_selector.selectNodeUponCreation = False self.input_volume_selector.addEnabled = False self.input_volume_selector.removeEnabled = False self.input_volume_selector.noneEnabled = True self.input_volume_selector.showHidden = False self.input_volume_selector.showChildNodeTypes = False self.input_volume_selector.setMRMLScene(slicer.mrmlScene) self.input_volume_selector.setToolTip( "Pick the input volume for the algorithm.") registration_form_layout.addRow("Input Volume: ", self.input_volume_selector) # Register Button self.apply_reg_button = qt.QPushButton("Apply") self.apply_reg_button.toolTip = "Run the algorithm." self.apply_reg_button.enabled = False registration_form_layout.addRow(self.apply_reg_button) # Connect Procedures # Image to Frame Registration self.apply_reg_button.connect("clicked(bool)", self.onapply_reg_button) self.input_volume_selector.connect("currentNodeChanged(vtkMRMLNode*)", self.on_registration_select) self.input_fiducial_selector.connect( "currentNodeChanged(vtkMRMLNode*)", self.on_registration_select)
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_targeting_area(self): """ Setup target and trajectory area and connect functions. """ parameters_collapsible_button = ctk.ctkCollapsibleButton() parameters_collapsible_button.text = "Target and Trajectory" self.layout.addWidget(parameters_collapsible_button) # Layout within the dummy collapsible button parameters_form_layout = qt.QFormLayout(parameters_collapsible_button) # input model selector self.input_selector = slicer.qMRMLNodeComboBox() self.input_selector.nodeTypes = ["vtkMRMLModelNode"] self.input_selector.selectNodeUponCreation = False self.input_selector.addEnabled = False self.input_selector.removeEnabled = False self.input_selector.noneEnabled = False self.input_selector.showHidden = False self.input_selector.showChildNodeTypes = False self.input_selector.setMRMLScene(slicer.mrmlScene) self.input_selector.setToolTip("Pick the Electrode to Target") parameters_form_layout.addRow("Target Electrode: ", self.input_selector) # Arc Angle value self.arc_angle_widget = self.default_angle_component() parameters_form_layout.addRow("Arc", self.arc_angle_widget) # Collar Angle value self.collar_angle_widget = ctk.ctkSliderWidget() self.collar_angle_widget.singleStep = 0.1 self.collar_angle_widget.minimum = 0 self.collar_angle_widget.maximum = 180 self.collar_angle_widget.value = 90 self.collar_angle_widget.setToolTip("Set Collar angle of approach.") parameters_form_layout.addRow("Collar", self.collar_angle_widget) # X-origin self.x_origin_widget = self.default_origin_component() parameters_form_layout.addRow("X0", self.x_origin_widget) # Y-origin self.y_origin_widget = self.default_origin_component() parameters_form_layout.addRow("Y0", self.y_origin_widget) # Z-origin self.z_origin_widget = self.default_origin_component() parameters_form_layout.addRow("Z0", self.z_origin_widget) # Apply Button self.new_electrode_button = qt.QPushButton("New Electrode") self.new_electrode_button.toolTip = "Generate New Electrode" self.new_electrode_button.enabled = False parameters_form_layout.addRow(self.new_electrode_button) # Connect Procedures # Target and Trajectory self.new_electrode_button.connect("clicked(bool)", self.new_electrode) self.input_selector.connect("currentNodeChanged(vtkMRMLNode*)", self.on_electrode_select) self.arc_angle_widget.connect("valueChanged(double)", self.on_changes) self.collar_angle_widget.connect("valueChanged(double)", self.on_changes) self.x_origin_widget.connect("valueChanged(double)", self.on_changes) self.y_origin_widget.connect("valueChanged(double)", self.on_changes) self.z_origin_widget.connect("valueChanged(double)", self.on_changes)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # Select landmark file to import # self.inputFileSelector = ctk.ctkPathLineEdit() self.inputFileSelector.setToolTip( "Select Morphologika landmark file for conversion") parametersFormLayout.addRow( "Select file containing landmark names and coordinates to load:", self.inputFileSelector) # # output directory selector # self.outputDirectory = ctk.ctkDirectoryButton() self.outputDirectory.directory = qt.QDir.homePath() parametersFormLayout.addRow("Output Directory:", self.outputDirectory) # # check box to trigger taking screen shots for later use in tutorials # self.enableScreenshotsFlagCheckBox = qt.QCheckBox() self.enableScreenshotsFlagCheckBox.checked = 0 self.enableScreenshotsFlagCheckBox.setToolTip( "If checked, take screen shots for tutorials. Use Save Data to write them to disk." ) parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the conversion." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputFileSelector.connect('validInputChanged(bool)', self.onSelectInput) # Add vertical spacer self.layout.addStretch(1) # Refresh Apply button state self.onSelectInput()
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # first input volume selector # self.inputSelector1 = slicer.qMRMLNodeComboBox() self.inputSelector1.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.inputSelector1.selectNodeUponCreation = True self.inputSelector1.addEnabled = False self.inputSelector1.removeEnabled = False self.inputSelector1.noneEnabled = False self.inputSelector1.showHidden = False self.inputSelector1.showChildNodeTypes = False self.inputSelector1.setMRMLScene( slicer.mrmlScene ) self.inputSelector1.setToolTip( "Pick the first input." ) parametersFormLayout.addRow(" First input Volume: ", self.inputSelector1) # # second input volume selector # self.inputSelector2 = slicer.qMRMLNodeComboBox() self.inputSelector2.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.inputSelector2.selectNodeUponCreation = True self.inputSelector2.addEnabled = False self.inputSelector2.removeEnabled = False self.inputSelector2.noneEnabled = False self.inputSelector2.showHidden = False self.inputSelector2.showChildNodeTypes = False self.inputSelector2.setMRMLScene( slicer.mrmlScene ) self.inputSelector2.setToolTip( "Pick the second input." ) parametersFormLayout.addRow(" Second input Volume: ", self.inputSelector2) self.rulerSelector = slicer.qMRMLNodeComboBox() self.rulerSelector.nodeTypes = ["vtkMRMLAnnotationRulerNode"] self.rulerSelector.selectNodeUponCreation = True self.rulerSelector.addEnabled = False self.rulerSelector.removeEnabled = False self.rulerSelector.noneEnabled = False self.rulerSelector.showHidden = False self.rulerSelector.showChildNodeTypes = False self.rulerSelector.setMRMLScene( slicer.mrmlScene ) self.rulerSelector.setToolTip( "Pick the ruler." ) parametersFormLayout.addRow("Ruler: ", self.rulerSelector) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = True parametersFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) # Add vertical spacer self.layout.addStretch(1)
def setup(self): ScriptedLoadableModuleWidget.setup(self) self.logic = SegmentStatisticsLogic() self.grayscaleNode = None self.labelNode = None self.parameterNode = None self.parameterNodeObserver = None # Instantiate and connect widgets ... # # Inputs inputsCollapsibleButton = ctk.ctkCollapsibleButton() inputsCollapsibleButton.text = "Inputs" self.layout.addWidget(inputsCollapsibleButton) inputsFormLayout = qt.QFormLayout(inputsCollapsibleButton) # Segmentation selector self.segmentationSelector = slicer.qMRMLNodeComboBox() self.segmentationSelector.nodeTypes = ["vtkMRMLSegmentationNode"] self.segmentationSelector.addEnabled = False self.segmentationSelector.removeEnabled = True self.segmentationSelector.renameEnabled = True self.segmentationSelector.setMRMLScene( slicer.mrmlScene ) self.segmentationSelector.setToolTip( "Pick the segmentation to compute statistics for" ) inputsFormLayout.addRow("Segmentation:", self.segmentationSelector) # Scalar volume selector self.scalarSelector = slicer.qMRMLNodeComboBox() self.scalarSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.scalarSelector.addEnabled = False self.scalarSelector.removeEnabled = True self.scalarSelector.renameEnabled = True self.scalarSelector.noneEnabled = True self.scalarSelector.showChildNodeTypes = False self.scalarSelector.setMRMLScene( slicer.mrmlScene ) self.scalarSelector.setToolTip( "Select the scalar volume for intensity statistics calculations") inputsFormLayout.addRow("Scalar volume:", self.scalarSelector) # Output table selector 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.setToolTip( "Select the table where statistics will be saved into") outputFormLayout.addRow("Output table:", self.outputTableSelector) # Apply Button self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Calculate Statistics." self.applyButton.enabled = False self.parent.layout().addWidget(self.applyButton) # Parameter set parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" #parametersCollapsibleButton.collapsed = True self.layout.addWidget(parametersCollapsibleButton) self.parametersLayout = qt.QFormLayout(parametersCollapsibleButton) # Parameter set selector self.parameterNodeSelector = slicer.qMRMLNodeComboBox() self.parameterNodeSelector.nodeTypes = ( ("vtkMRMLScriptedModuleNode"), "" ) self.parameterNodeSelector.addAttribute( "vtkMRMLScriptedModuleNode", "ModuleName", "SegmentStatistics" ) self.parameterNodeSelector.selectNodeUponCreation = True self.parameterNodeSelector.addEnabled = True self.parameterNodeSelector.renameEnabled = True self.parameterNodeSelector.removeEnabled = True self.parameterNodeSelector.noneEnabled = False self.parameterNodeSelector.showHidden = True self.parameterNodeSelector.showChildNodeTypes = False self.parameterNodeSelector.baseName = "SegmentStatistics" self.parameterNodeSelector.setMRMLScene( slicer.mrmlScene ) self.parameterNodeSelector.setToolTip( "Pick parameter set" ) self.parametersLayout.addRow("Parameter set: ", self.parameterNodeSelector) # Edit parameter set button to open SegmentStatisticsParameterEditorDialog # Note: we add the plugins' option widgets to the module widget instead of using the editor dialog #self.editParametersButton = qt.QPushButton("Edit Parameter Set") #self.editParametersButton.toolTip = "Editor Statistics Plugin Parameter Set." #self.parametersLayout.addRow(self.editParametersButton) #self.editParametersButton.connect('clicked()', self.onEditParameters) # add caclulator's option widgets self.addPluginOptionWidgets() # Add vertical spacer self.parent.layout().addStretch(1) # connections self.applyButton.connect('clicked()', self.onApply) self.scalarSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onNodeSelectionChanged) self.segmentationSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onNodeSelectionChanged) self.outputTableSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onNodeSelectionChanged) self.parameterNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onNodeSelectionChanged) self.parameterNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onParameterSetSelected) self.parameterNodeSelector.setCurrentNode(self.logic.getParameterNode()) self.onNodeSelectionChanged() self.onParameterSetSelected()
def setup(self): ScriptedLoadableModuleWidget.setup(self) self.logic = VectorToScalarVolumeLogic() # This will use createParameterNode with the provided default options self.setParameterNode(self.logic.getParameterNode()) self.parameterSetSelectionCollapsibleButton = ctk.ctkCollapsibleButton( ) self.parameterSetSelectionCollapsibleButton.text = "Parameter set" self.layout.addWidget(self.parameterSetSelectionCollapsibleButton) # Layout within the "Selection" collapsible button parameterSetSelectionFormLayout = qt.QFormLayout( self.parameterSetSelectionCollapsibleButton) # Parameter set selector (inspired by SegmentStatistics.py) self.parameterNodeSelector = slicer.qMRMLNodeComboBox() self.parameterNodeSelector.nodeTypes = (("vtkMRMLScriptedModuleNode"), "") self.parameterNodeSelector.addAttribute("vtkMRMLScriptedModuleNode", "ModuleName", "VectorToScalarVolume") self.parameterNodeSelector.selectNodeUponCreation = True self.parameterNodeSelector.addEnabled = True self.parameterNodeSelector.renameEnabled = True self.parameterNodeSelector.removeEnabled = True self.parameterNodeSelector.noneEnabled = False self.parameterNodeSelector.showHidden = True self.parameterNodeSelector.showChildNodeTypes = False self.parameterNodeSelector.baseName = "VectorToScalarVolume" self.parameterNodeSelector.setMRMLScene(slicer.mrmlScene) self.parameterNodeSelector.toolTip = "Pick parameter set" parameterSetSelectionFormLayout.addRow("Parameter set: ", self.parameterNodeSelector) # Parameters self.selectionCollapsibleButton = ctk.ctkCollapsibleButton() self.selectionCollapsibleButton.text = "Conversion settings" self.layout.addWidget(self.selectionCollapsibleButton) # Layout within the "Selection" collapsible button parametersFormLayout = qt.QFormLayout(self.selectionCollapsibleButton) # # the volume selectors # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = ["vtkMRMLVectorVolumeNode"] self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.setMRMLScene(slicer.mrmlScene) parametersFormLayout.addRow("Input Vector Volume: ", self.inputSelector) self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.outputSelector.hideChildNodeTypes = ["vtkMRMLVectorVolumeNode"] self.outputSelector.setMRMLScene(slicer.mrmlScene) self.outputSelector.addEnabled = True self.outputSelector.renameEnabled = True self.outputSelector.baseName = "Scalar Volume" parametersFormLayout.addRow("Output Scalar Volume: ", self.outputSelector) # # Options to extract single components # self.conversionMethodWidget = VectorToScalarVolumeConversionMethodWidget( ) parametersFormLayout.addRow("Conversion Method: ", self.conversionMethodWidget) # Apply button self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run Convert the vector to scalar." parametersFormLayout.addRow(self.applyButton) # Add vertical spacer self.layout.addStretch(1) # Connections self.parameterNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.setParameterNode) self.parameterNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.updateGuiFromMRML) # updateParameterNodeFromGui self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.updateParameterNodeFromGui) self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.updateParameterNodeFromGui) self.applyButton.connect('clicked(bool)', self.onApply) # conversion widget self.conversionMethodWidget.methodSelectorComboBox.connect( 'currentIndexChanged(int)', self.updateParameterNodeFromGui) self.conversionMethodWidget.componentsComboBox.connect( 'currentIndexChanged(int)', self.updateParameterNodeFromGui) # The parameter node had defaults at creation, propagate them to the GUI. self.updateGuiFromMRML()
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) self.inputDirectory = ctk.ctkPathLineEdit() self.inputDirectory.filters = ctk.ctkPathLineEdit.Dirs self.inputDirectory.setToolTip("Select directory containing volumes") parametersFormLayout.addRow("Input directory: ", self.inputDirectory) # Select output directory self.outputDirectory = ctk.ctkPathLineEdit() self.outputDirectory.filters = ctk.ctkPathLineEdit.Dirs self.outputDirectory.setToolTip("Select directory for output models: ") parametersFormLayout.addRow("Output directory: ", self.outputDirectory) # # Select the extension type # self.extensionOptionGZ = qt.QRadioButton(".nii.gz") self.extensionOptionGZ.setChecked(True) parametersFormLayout.addRow("Select extension type: ", self.extensionOptionGZ) # # set threshold value # self.threshold = ctk.ctkDoubleSpinBox() self.threshold.singleStep = 1 self.threshold.minimum = 0 self.threshold.maximum = 100000 self.threshold.setDecimals(0) self.threshold.value = 500 self.threshold.setToolTip( "Select threshold for segmentation of volume") parametersFormLayout.addRow("Threshold for segmentation:", self.threshold) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Generate VolumeToMeshs." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # # check box to trigger taking screen shots for later use in tutorials # self.enableScreenshotsFlagCheckBox = qt.QCheckBox() self.enableScreenshotsFlagCheckBox.checked = 0 self.enableScreenshotsFlagCheckBox.setToolTip( "If checked, take screen shots for tutorials. Use Save Data to write them to disk." ) parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox) # connections self.inputDirectory.connect('validInputChanged(bool)', self.onSelectInput) self.outputDirectory.connect('validInputChanged(bool)', self.onSelectOutput) self.applyButton.connect('clicked(bool)', self.onApplyButton) # Add vertical spacer self.layout.addStretch(1)