def createUserInterface(self): """ This method uses qt to create a user interface. qMRMLNodeComboBox is a drop down menu for picking MRML files. MRML files are collected in a scene, hence .setMRMLscene. """ self.__layout = self.__parent.createUserInterface() baselineScanLabel = qt.QLabel( 'Pre-contrast scan:' ) self.__baselineVolumeSelector = slicer.qMRMLNodeComboBox() self.__baselineVolumeSelector.toolTip = "Choose the pre-contrast scan" self.__baselineVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__baselineVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__baselineVolumeSelector.addEnabled = 0 followupScanLabel = qt.QLabel( 'Post-contrast scan:' ) self.__followupVolumeSelector = slicer.qMRMLNodeComboBox() self.__followupVolumeSelector.toolTip = "Choose the post-contrast scan" self.__followupVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__followupVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__followupVolumeSelector.addEnabled = 0 self.__layout.addRow( baselineScanLabel, self.__baselineVolumeSelector ) self.__layout.addRow( followupScanLabel, self.__followupVolumeSelector ) self.updateWidgetFromParameters(self.parameterNode()) qt.QTimer.singleShot(0, self.killButton)
def onMethodChanged(self): methodIndex = self.__methodsComboBox.currentIndex if methodIndex == 4: # Fiducial registration # Only create the box if it doesn't exist if self.__regGroupBox == None: self.__regGroupBox = qt.QGroupBox() self.__regGroupBox.setTitle('Registration method specific settings') self.__layout.addRow(self.__regGroupBox) regGroupLayout = qt.QFormLayout(self.__regGroupBox) # TODO needs to be a class att? baseFiducialsLabel = qt.QLabel('Fixed landmarks:') self.__baseFiducialsSelector = slicer.qMRMLNodeComboBox() self.__baseFiducialsSelector.toolTip = "Ordered list of landmarks in the fixed image" self.__baseFiducialsSelector.nodeTypes = ['vtkMRMLAnnotationHierarchyNode'] self.__baseFiducialsSelector.setMRMLScene(slicer.mrmlScene) self.__baseFiducialsSelector.addEnabled = 0 # The list must be created already regGroupLayout.addRow(baseFiducialsLabel, self.__baseFiducialsSelector) followFiducialsLabel = qt.QLabel('Moving landmarks:') self.__followFiducialsSelector = slicer.qMRMLNodeComboBox() self.__followFiducialsSelector.toolTip = "Ordered list of landmarks in the moving image" self.__followFiducialsSelector.nodeTypes = ['vtkMRMLAnnotationHierarchyNode'] self.__followFiducialsSelector.setMRMLScene(slicer.mrmlScene) self.__followFiducialsSelector.addEnabled = 0 # The list must be created already regGroupLayout.addRow(followFiducialsLabel, self.__followFiducialsSelector) else: self.__regGroupBox.setVisible(True) else: # Make fiducial box invisible (if it exists) if self.__regGroupBox != None: self.__regGroupBox.setVisible(False)
def createUserInterface(self): """ """ self.skip = 0 pNode = self.parameterNode() self.__layout = self.__parent.createUserInterface() groupbox = qt.QGroupBox() groupboxLayout = qt.QFormLayout(groupbox) groupboxLayout.addRow(slicer.modules.editor.widgetRepresentation()) self.__layout.addRow(groupbox) needleLabel = qt.QLabel("Needle Label:") self.__needleLabelSelector = slicer.qMRMLNodeComboBox() self.__needleLabelSelector.toolTip = "Choose the needle-label image" self.__needleLabelSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.__needleLabelSelector.setMRMLScene(slicer.mrmlScene) self.__needleLabelSelector.addEnabled = 1 self.__layout.addRow(needleLabel, self.__needleLabelSelector) if Helper.getNodeByID(pNode.GetParameter("baselineVolumeID")) == None: volumeLabel = qt.QLabel("Volume:") self.__volumeSelector = slicer.qMRMLNodeComboBox() self.__volumeSelector.toolTip = "Choose the Volume" self.__volumeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.__volumeSelector.setMRMLScene(slicer.mrmlScene) self.__volumeSelector.addEnabled = 1 self.__layout.addRow(volumeLabel, self.__volumeSelector) # Segment Needle Button self.needleButton = qt.QPushButton("Segment Needles") self.__layout.addRow(self.needleButton) self.needleButton.connect("clicked()", self.needleSegmentation) self.updateWidgetFromParameters(self.parameterNode())
def createUserInterface(self): ''' The interface allows choosing two volumes. ''' self.__layout = self.__parent.createUserInterface() baselineScanLabel = qt.QLabel('Baseline volume:') self.__baselineVolumeSelector = slicer.qMRMLNodeComboBox() self.__baselineVolumeSelector.toolTip = "Choose the baseline volume" self.__baselineVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__baselineVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__baselineVolumeSelector.addEnabled = 0 followupScanLabel = qt.QLabel('Followup volume:') self.__followupVolumeSelector = slicer.qMRMLNodeComboBox() self.__followupVolumeSelector.toolTip = "Choose the followup volume" self.__followupVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__followupVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__followupVolumeSelector.addEnabled = 0 loadDataButton = qt.QPushButton('Load test data') self.__layout.addRow(loadDataButton) loadDataButton.connect('clicked()', self.loadTestData) self.__layout.addRow(baselineScanLabel, self.__baselineVolumeSelector) self.__layout.addRow(followupScanLabel, self.__followupVolumeSelector) self.updateWidgetFromParameters(self.parameterNode()) qt.QTimer.singleShot(0, self.killButton)
def setup(self): # Instantiate and connect widgets ... # Collapsible button dummyCollapsibleButton = ctk.ctkCollapsibleButton() dummyCollapsibleButton.text = "IO" self.layout.addWidget(dummyCollapsibleButton) # Layout within the dummy collapsible button dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton) # Input label node label = qt.QLabel('Input label: ') self.segmentationSelector = slicer.qMRMLNodeComboBox() self.segmentationSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.segmentationSelector.setMRMLScene(slicer.mrmlScene) self.segmentationSelector.addEnabled = 0 self.segmentationSelector.noneEnabled = 1 self.segmentationSelector.removeEnabled = 0 self.segmentationSelector.showHidden = 0 self.segmentationSelector.showChildNodeTypes = 0 self.segmentationSelector.selectNodeUponCreation = 1 self.segmentationSelector.addAttribute('vtkMRMLScalarVolumeNode','LabelMap',1) self.segmentationSelector.connect('currentNodeChanged(vtkMRMLNode*)',self.onInputChanged) dummyFormLayout.addRow(label, self.segmentationSelector) # Input volume node label = qt.QLabel('Input volume: ') self.volumeSelector = slicer.qMRMLNodeComboBox() self.volumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.volumeSelector.setMRMLScene(slicer.mrmlScene) self.volumeSelector.addEnabled = 0 self.volumeSelector.noneEnabled = 1 self.volumeSelector.removeEnabled = 0 self.volumeSelector.showHidden = 0 self.volumeSelector.showChildNodeTypes = 0 self.volumeSelector.selectNodeUponCreation = 0 self.volumeSelector.addAttribute('vtkMRMLScalarVolumeNode','DICOM.instanceUIDs') self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)',self.onInputChanged) dummyFormLayout.addRow(label, self.volumeSelector) # Buttons to save/load report using AIM XML serialization label = qt.QLabel('Export folder') self.__exportFolderPicker = ctk.ctkDirectoryButton() self.__exportFolderPicker.connect('directoryChanged(const QString&)', self.onOutputDirChanged) self.exportButton = qt.QPushButton('Export') dummyFormLayout.addRow(label, self.__exportFolderPicker) dummyFormLayout.addRow(self.exportButton) self.exportButton.connect('clicked()', self.onLabelExport) self.exportButton.enabled = 1 # Input hint self.__helpLabel = qt.QLabel('Select a label associated with a DICOM volume') dummyFormLayout.addRow(self.__helpLabel) # Add vertical spacer self.layout.addStretch(1) self.outputDir = self.__exportFolderPicker.directory
def setup(self): # Instantiate and connect widgets ... # Collapsible button __collapsibleButton = ctk.ctkCollapsibleButton() __collapsibleButton.text = "A collapsible tab" self.layout.addWidget(__collapsibleButton) # Layout within the collapsible button __formLayout = qt.QFormLayout(__collapsibleButton) # Fixed Volume Selector __fixedVolumeSelector = slicer.qMRMLNodeComboBox() __fixedVolumeSelector.objectName = 'fixedVolumeSelector' __fixedVolumeSelector.toolTip = "The fixed image for registration." __fixedVolumeSelector.nodeTypes = ['vtkMRMLVolumeNode'] __fixedVolumeSelector.noneEnabled = True __fixedVolumeSelector.addEnabled = False __fixedVolumeSelector.removeEnabled = False __formLayout.addRow("Fixed Volume:", __fixedVolumeSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', __fixedVolumeSelector, 'setMRMLScene(vtkMRMLScene*)') # Moving Volume Selector __movingVolumeSelector = slicer.qMRMLNodeComboBox() __movingVolumeSelector.objectName = 'movingVolumeSelector' __movingVolumeSelector.toolTip = "The moving image for registration." __movingVolumeSelector.nodeTypes = ['vtkMRMLVolumeNode'] __movingVolumeSelector.noneEnabled = True __movingVolumeSelector.addEnabled = False __movingVolumeSelector.removeEnabled = False __formLayout.addRow("Moving Volume:", __movingVolumeSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', __movingVolumeSelector, 'setMRMLScene(vtkMRMLScene*)') # Register button __registerButton = qt.QPushButton("Register volumes") __registerButton.toolTip = "Register the volumes." __registerStatus = qt.QLabel('Register volumes') __formLayout.addRow(__registerStatus, __registerButton) __registerButton.connect('clicked(bool)', self.onRegisterButtonClicked) # Subtract button __subtractButton = qt.QPushButton("Subtract volumes") __subtractButton.toolTip = "Subtract the volumes." __subtractStatus = qt.QLabel('Subtract volumes') __formLayout.addRow(__subtractStatus, __subtractButton) __subtractButton.connect('clicked(bool)', self.onSubtractButtonClicked) # Add vertical spacer self.layout.addStretch(1) # Set local var as instance attribute self.__fixedVolumeSelector = __fixedVolumeSelector self.__movingVolumeSelector = __movingVolumeSelector self.__registerButton = __registerButton self.__registerStatus = __registerStatus self.__subtractButton = __subtractButton self.__subtractStatus = __subtractStatus
def createUserInterface(self): ''' The interface allows choosing a registration method and applying it on the already chosen volumes. Alternatively the user can choose an already registered volume. ''' self.__layout = self.__parent.createUserInterface() registrationMethodLabel = qt.QLabel( 'DF Smoothing Sigma:' ) # Create the possible registration method labels smooth = [1.0, 1.5, 2.0, 2.5] # Registration Methods Combo box self.__smoothComboBox = qt.QComboBox() self.__smoothComboBox.toolTip = "Choose the Deformation Field Smoothing Sigma" for i,m in enumerate(smooth): self.__smoothComboBox.insertItem(i, m) # If the smoothing parameter changes we may have to add more things to the layout self.__smoothComboBox.connect('currentIndexChanged(int)', self.onSmoothChanged) # Registration button self.__registrationButton = qt.QPushButton("Run registration") self.__registrationButton.toolTip = "Register the volumes with DEMONS Brain Registration." self.__registrationStatus = qt.QLabel('Registration Status: N/A') # Selector for the registered volume to use resultLabel = qt.QLabel('Choose registered volume or deformation field to use during quantification:') self.__resultVolumeSelector = slicer.qMRMLNodeComboBox() self.__resultVolumeSelector.toolTip = "Choose the registered volume to use during quantification (optional)." self.__resultVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__resultVolumeSelector.setCurrentNodeIndex(0) # Empty in the beginning self.__resultVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__resultVolumeSelector.addEnabled = 0 self.__resultTransformSelector = slicer.qMRMLNodeComboBox() self.__resultTransformSelector.toolTip = "Choose the Deformation Field to use during quantification (required)." #self.__resultTransformSelector.nodeTypes = ['vtkMRMLGridTransformNode'] self.__resultVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__resultVolumeSelector.setCurrentNodeIndex(0) # Empty in the beginning self.__resultTransformSelector.setMRMLScene(slicer.mrmlScene) self.__resultTransformSelector.addEnabled = 0 self.__layout.addRow(registrationMethodLabel, self.__smoothComboBox) self.__layout.addRow(self.__registrationButton) self.__layout.addRow("", qt.QWidget()) # empty row self.__layout.addRow(self.__registrationStatus) self.__layout.addRow("", qt.QWidget()) # empty row self.__registrationButton.connect('clicked()', self.onRegistrationRequest) self.__layout.addRow(resultLabel) self.__layout.addRow("", qt.QWidget()) # empty row self.__layout.addRow(self.__resultVolumeSelector) self.__layout.addRow(self.__resultTransformSelector) self.__layout.addRow("", qt.QWidget()) # empty row qt.QTimer.singleShot(0, self.killButton)
def createUserInterface(self): ''' The interface allows choosing a registration method and applying it on the already chosen volumes. Alternatively the user can choose an already registered volume. ''' self.__layout = self.__parent.createUserInterface() registrationMethodLabel = qt.QLabel( 'Registration method:' ) # Create the possible registration method labels methods = ['Choose a method', 'Affine Registration', 'BSpline deformable registration', 'Demon Registration (BRAINS)'] # Registration Methods Combo box self.__methodsComboBox = qt.QComboBox() self.__methodsComboBox.toolTip = "Choose the preferred registration method" for i,m in enumerate(methods): self.__methodsComboBox.insertItem(i, m) # If the method changes we may have to add more things to the layout self.__methodsComboBox.connect('currentIndexChanged(int)', self.onMethodChanged) # Registration button self.__registrationButton = qt.QPushButton("Run registration") self.__registrationButton.toolTip = "Register the volumes." self.__registrationStatus = qt.QLabel('Registration Status: N/A') # Selector for the registered volume to use resultLabel = qt.QLabel('Choose registered volume or transform to use during quantification:') self.__resultVolumeSelector = slicer.qMRMLNodeComboBox() self.__resultVolumeSelector.toolTip = "Choose the registered volume to use during quantification." self.__resultVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__resultVolumeSelector.setCurrentNodeIndex(0) # Empty in the beginning self.__resultVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__resultVolumeSelector.addEnabled = 0 self.__resultTransformSelector = slicer.qMRMLNodeComboBox() self.__resultTransformSelector.toolTip = "Choose the registered transform to use during quantification." self.__resultTransformSelector.nodeTypes = ['vtkMRMLLinearTransformNode'] # TODO maybe the transform is not always linear self.__resultVolumeSelector.setCurrentNodeIndex(0) # Empty in the beginning self.__resultTransformSelector.setMRMLScene(slicer.mrmlScene) self.__resultTransformSelector.addEnabled = 0 self.__layout.addRow(registrationMethodLabel, self.__methodsComboBox) self.__layout.addRow(self.__registrationButton) self.__layout.addRow("", qt.QWidget()) # empty row self.__layout.addRow(self.__registrationStatus) self.__layout.addRow("", qt.QWidget()) # empty row self.__registrationButton.connect('clicked()', self.onRegistrationRequest) self.__layout.addRow(resultLabel) self.__layout.addRow("", qt.QWidget()) # empty row self.__layout.addRow(self.__resultVolumeSelector) self.__layout.addRow(self.__resultTransformSelector) self.__layout.addRow("", qt.QWidget()) # empty row qt.QTimer.singleShot(0, self.killButton)
def setup(self): # Instantiate and connect widgets ... # Collapsible button parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the parameters collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # fiber self.fiberSelector = slicer.qMRMLNodeComboBox(parametersCollapsibleButton) self.fiberSelector.nodeTypes = (("vtkMRMLFiberBundleNode"), "") self.fiberSelector.selectNodeUponCreation = False self.fiberSelector.addEnabled = False self.fiberSelector.removeEnabled = False self.fiberSelector.noneEnabled = True self.fiberSelector.showHidden = False self.fiberSelector.showChildNodeTypes = False self.fiberSelector.setMRMLScene(slicer.mrmlScene) self.fiberSelector.setToolTip("Pick the fiber bundle to be converted.") parametersFormLayout.addRow("Fiber Bundle", self.fiberSelector) # label map self.labelSelector = slicer.qMRMLNodeComboBox(parametersCollapsibleButton) self.labelSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.labelSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", 1) self.labelSelector.selectNodeUponCreation = False self.labelSelector.addEnabled = False self.labelSelector.removeEnabled = False self.labelSelector.noneEnabled = True self.labelSelector.showHidden = False self.labelSelector.showChildNodeTypes = False self.labelSelector.setMRMLScene(slicer.mrmlScene) self.labelSelector.setToolTip( "Pick the target label volume. Must already exists in order to define sampling grid. If needed, create one in the Editor module based on template volume." ) parametersFormLayout.addRow("Target LabelMap", self.labelSelector) # label value self.labelValue = qt.QSpinBox(parametersCollapsibleButton) self.labelValue.setToolTip("The numerical value for the rasterized fiber label.") self.labelValue.setValue(1) parametersFormLayout.addRow("Label Value", self.labelValue) # apply self.applyButton = qt.QPushButton(parametersCollapsibleButton) self.applyButton.text = "Apply" parametersFormLayout.addWidget(self.applyButton) self.applyButton.connect("clicked()", self.onApply) # Add vertical spacer self.layout.addStretch(1)
def setup(self): # Instantiate and connect widgets ... # Collapsible button parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the parameters collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # fiber self.fiberSelector = slicer.qMRMLNodeComboBox(parametersCollapsibleButton) self.fiberSelector.nodeTypes = ( ("vtkMRMLFiberBundleNode"), "" ) self.fiberSelector.selectNodeUponCreation = False self.fiberSelector.addEnabled = False self.fiberSelector.removeEnabled = False self.fiberSelector.noneEnabled = True self.fiberSelector.showHidden = False self.fiberSelector.showChildNodeTypes = False self.fiberSelector.setMRMLScene( slicer.mrmlScene ) self.fiberSelector.setToolTip( "Pick the full-brain tractography in VTK format: It must be a vtkPolyData object where all the cells are lines." ) parametersFormLayout.addRow("Fiber Bundle", self.fiberSelector) # label map self.labelSelector = slicer.qMRMLNodeComboBox(parametersCollapsibleButton) self.labelSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) #self.labelSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 1 ) self.labelSelector.selectNodeUponCreation = False self.labelSelector.addEnabled = False self.labelSelector.removeEnabled = False self.labelSelector.noneEnabled = True self.labelSelector.showHidden = False self.labelSelector.showChildNodeTypes = False self.labelSelector.setMRMLScene( slicer.mrmlScene ) self.labelSelector.setToolTip( "Pick A brain parcellation, obtained from freesurfer in the same space as the full-brain tractography." ) parametersFormLayout.addRow("Brain Parcellation ", self.labelSelector) # query script self.queryScript = qt.QTextEdit() self.queryScript.setToolTip( "WMQL query text." ) #self.labelValue.setValue(1) parametersFormLayout.addWidget(self.queryScript) # apply self.applyButton = qt.QPushButton(parametersCollapsibleButton) self.applyButton.text = "Apply" parametersFormLayout.addWidget(self.applyButton) self.applyButton.connect('clicked()', self.onApply) # Add vertical spacer self.layout.addStretch(1)
def setup(self): # Collapsible button self.laplaceCollapsibleButton = ctk.ctkCollapsibleButton() self.laplaceCollapsibleButton.text = "Sharpen Operator" self.layout.addWidget(self.laplaceCollapsibleButton) # Layout within the laplace collapsible button self.laplaceFormLayout = qt.QFormLayout(self.laplaceCollapsibleButton) # # the volume selectors # self.inputFrame = qt.QFrame(self.laplaceCollapsibleButton) self.inputFrame.setLayout(qt.QHBoxLayout()) self.laplaceFormLayout.addWidget(self.inputFrame) self.inputSelector = qt.QLabel("Input Volume: ", self.inputFrame) self.inputFrame.layout().addWidget(self.inputSelector) self.inputSelector = slicer.qMRMLNodeComboBox(self.inputFrame) self.inputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputFrame.layout().addWidget(self.inputSelector) self.outputFrame = qt.QFrame(self.laplaceCollapsibleButton) self.outputFrame.setLayout(qt.QHBoxLayout()) self.laplaceFormLayout.addWidget(self.outputFrame) self.outputSelector = qt.QLabel("Output Volume: ", self.outputFrame) self.outputFrame.layout().addWidget(self.outputSelector) self.outputSelector = slicer.qMRMLNodeComboBox(self.outputFrame) self.outputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputFrame.layout().addWidget(self.outputSelector) # Section A - add code here # (be sure to match indentation) self.sharpen = qt.QCheckBox("Sharpen", self.laplaceCollapsibleButton) self.sharpen.toolTip = "When checked, subtract laplacian from input volume" self.sharpen.checked = True self.laplaceFormLayout.addWidget(self.sharpen) # Apply button laplaceButton = qt.QPushButton("Apply") laplaceButton.toolTip = "Run the Laplace or Sharpen Operator." self.laplaceFormLayout.addWidget(laplaceButton) laplaceButton.connect('clicked(bool)', self.onApply) # Add vertical spacer self.layout.addStretch(1) # Set local var as instance attribute self.laplaceButton = laplaceButton
def createUserInterface( self ): from Editor import EditorWidget self.__layout = self.__parent.createUserInterface() #TODO: Create label map and set it for editing by user? #volumesLogic = slicer.modules.volumes.logic() #headLabel = volumesLogic.CreateLabelVolume( slicer.mrmlScene, head, head.GetName() + '-segmentation' ) #selectionNode = slicer.app.applicationLogic().GetSelectionNode() #selectionNode.SetReferenceActiveVolumeID( head.GetID() ) #selectionNode.SetReferenceActiveLabelVolumeID( headLabel.GetID() ) #slicer.app.applicationLogic().PropagateVolumeSelection(0) editorFrame = qt.QFrame() editorFrame.setLayout(qt.QVBoxLayout()) palette = editorFrame.palette bgColor = 230 palette.setColor(qt.QPalette.Background, qt.QColor(bgColor, bgColor, bgColor)) editorFrame.setPalette(palette) editorFrame.setAutoFillBackground(True); self.__layout.addRow(editorFrame) self.editorFrame = editorFrame global editorWidget self.editorWidget = EditorWidget(parent=self.editorFrame, showVolumesFrame=True) self.editorWidget.setup() self.editorWidget.enter() endoSegLabel = qt.QLabel( 'Endo Segmentation Image:' ) self.__endoSegSelector = slicer.qMRMLNodeComboBox() self.__endoSegSelector.toolTip = "Choose the endo segmentation label image." self.__endoSegSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__endoSegSelector.setMRMLScene(slicer.mrmlScene) self.__endoSegSelector.addEnabled = 0 self.__layout.addRow( endoSegLabel, self.__endoSegSelector )
def setup(self): frame = qt.QFrame() layout = qt.QFormLayout() frame.setLayout( layout ) self.parent.layout().addWidget( frame ) # Markup selector self.markupSelectorLabel = qt.QLabel() self.markupSelectorLabel.setText( "Markup list: " ) self.markupSelector = slicer.qMRMLNodeComboBox() self.markupSelector.nodeTypes = ( "vtkMRMLMarkupsFiducialNode", "" ) self.markupSelector.noneEnabled = False self.markupSelector.selectNodeUponCreation = True self.markupSelector.setMRMLScene( slicer.mrmlScene ) self.markupSelector.setToolTip( "Pick the markup list to be filled" ) layout.addRow(self.markupSelectorLabel, self.markupSelector) # Apply button self.computeButton = qt.QPushButton("Compute") self.computeButton.toolTip = "Compute information for the selected markup" layout.addWidget(self.computeButton) self.UpdatecomputeButtonState() # connections self.computeButton.connect('clicked()', self.onCompute) self.markupSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onMarkupSelect)
def setupFileExporter(self): self.fileExporterCB = ctk.ctkCollapsibleButton() self.fileExporterCB.text = "Step 6 : Export Fiducials" self.layout.addWidget(self.fileExporterCB) fileExporterLayout= qt.QFormLayout(self.fileExporterCB) self.fidsSelectorSplit = slicer.qMRMLNodeComboBox() self.fidsSelectorSplit.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" ) self.fidsSelectorSplit.selectNodeUponCreation = False self.fidsSelectorSplit.addEnabled = False self.fidsSelectorSplit.removeEnabled = False self.fidsSelectorSplit.noneEnabled = True self.fidsSelectorSplit.setMRMLScene( slicer.mrmlScene ) self.fidsSelectorSplit.setToolTip("Select a fiducial list") fileExporterLayout.addRow("Fiducial : ", self.fidsSelectorSplit) splitButton = qt.QPushButton("Split") splitButton.setFixedWidth(60) splitButton.toolTip = " Separate fiducials in different files " splitButton.enabled = True fileExporterLayout.addRow(" Split? ",splitButton) # connections splitButton.connect('clicked(bool)',self.onSplitButtonClick) # Add vertical spacer self.layout.addStretch(1)
def setupSegmentation(self): self.segmentationCB = ctk.ctkCollapsibleButton() self.segmentationCB.text = "Step 4 : Segmentation" self.layout.addWidget(self.segmentationCB) # Layout within the dummy collapsible button segmentationCBLayout = qt.QFormLayout(self.segmentationCB) # input volume selector self.volumeCT = slicer.qMRMLNodeComboBox() self.volumeCT.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.volumeCT.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 0 ) self.volumeCT.selectNodeUponCreation = True self.volumeCT.addEnabled = False self.volumeCT.removeEnabled = False self.volumeCT.noneEnabled = True self.volumeCT.showHidden = False self.volumeCT.showChildNodeTypes = False self.volumeCT.setMRMLScene( slicer.mrmlScene ) self.volumeCT.setToolTip( "Pick the input to the algorithm." ) segmentationCBLayout.addRow("Input Volume: ", self.volumeCT) # # Centered self.isFiducialCentered = qt.QRadioButton() self.segmentationButton = qt.QPushButton("Apply") self.segmentationButton.toolTip = "Run the algorithm." self.segmentationButton.enabled = True segmentationCBLayout.addRow(self.segmentationButton) # connections self.segmentationButton.connect('clicked(bool)', self.onSegmentationButton)
def setupLoadFiducials(self): self.loadfidsCB = ctk.ctkCollapsibleButton() self.loadfidsCB.text = "Step 2 : Load Fiducials" #### Creo un layout per questa parte self.loadFidsLayout = qt.QFormLayout(self.loadfidsCB) self.innerLayout = qt.QHBoxLayout() #### Select box a tendina fidsSelector self.fidsSelector = slicer.qMRMLNodeComboBox() self.fidsSelector.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" ) self.fidsSelector.selectNodeUponCreation = False self.fidsSelector.addEnabled = False self.fidsSelector.removeEnabled = False self.fidsSelector.noneEnabled = True self.fidsSelector.setMRMLScene( slicer.mrmlScene ) self.fidsSelector.setToolTip("Select a fiducial list") self.loadButton = qt.QPushButton("Load") self.loadButton.toolTip = "Load Markups for Electrode Configuration" self.loadButton.enabled = True #### Aggiungo il bottone al layout self.innerLayout.addWidget(self.fidsSelector) self.innerLayout.addWidget(self.loadButton) self.loadFidsLayout.addRow("Fiducial :",self.innerLayout) self.layout.addWidget(self.loadfidsCB) # - connect Load button alla funzione onLoadButton self.loadButton.connect('clicked(bool)', self.onLoadButton)
def createUserInterface( self ): ''' ''' self.__layout = self.__parent.createUserInterface() roiLabel = qt.QLabel( 'Select ROI:' ) self.__roiSelector = slicer.qMRMLNodeComboBox() self.__roiSelector.nodeTypes = ['vtkMRMLAnnotationROINode'] self.__roiSelector.toolTip = "ROI defining the structure of interest" self.__roiSelector.setMRMLScene(slicer.mrmlScene) self.__roiSelector.addEnabled = 1 self.__layout.addRow( roiLabel, self.__roiSelector ) self.__roiSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onROIChanged) # the ROI parameters voiGroupBox = qt.QGroupBox() voiGroupBox.setTitle( 'Define VOI' ) self.__layout.addRow( voiGroupBox ) voiGroupBoxLayout = qt.QFormLayout( voiGroupBox ) self.__roiWidget = PythonQt.qSlicerAnnotationsModuleWidgets.qMRMLAnnotationROIWidget() voiGroupBoxLayout.addRow( self.__roiWidget ) # initialize VR stuff self.__vrLogic = slicer.modules.volumerendering.logic() # self.updateWidgetFromParameters(self.parameterNode()) qt.QTimer.singleShot(0, self.killButton)
def setup(self): if slicer.app.commandOptions().noMainWindow: # don't build the widget if there's no place to put it return self.volumes = ctk.ctkCollapsibleButton() #self.volumes.setLayout(qt.QVBoxLayout()) self.volumes.setText("Quality control volume") self.framelayout.addWidget(self.volumes) volumeLayout=qt.QFormLayout(self.volumes) self.masterSelector = slicer.qMRMLNodeComboBox() self.masterSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] #self.masterSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 0 ) self.masterSelector.selectNodeUponCreation = False self.masterSelector.addEnabled = False self.masterSelector.removeEnabled = False self.masterSelector.noneEnabled = True self.masterSelector.showHidden = False self.masterSelector.showChildNodeTypes = False self.masterSelector.setMRMLScene( slicer.mrmlScene ) self.masterSelector.setToolTip( "Pick the master structural volume to performing quality controls" ) volumeLayout.addRow("Input Volume: ", self.masterSelector) # node selected self.masterSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.select)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Collapsible button self.selectionCollapsibleButton = ctk.ctkCollapsibleButton() self.selectionCollapsibleButton.text = "Selection" self.layout.addWidget(self.selectionCollapsibleButton) # Layout within the collapsible button self.formLayout = qt.QFormLayout(self.selectionCollapsibleButton) # # the volume selectors # self.inputFrame = qt.QFrame(self.selectionCollapsibleButton) self.inputFrame.setLayout(qt.QHBoxLayout()) self.formLayout.addWidget(self.inputFrame) self.inputSelector = qt.QLabel("Input Vector Volume: ", self.inputFrame) self.inputFrame.layout().addWidget(self.inputSelector) self.inputSelector = slicer.qMRMLNodeComboBox(self.inputFrame) self.inputSelector.nodeTypes = ( ("vtkMRMLVectorVolumeNode"), "" ) self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputFrame.layout().addWidget(self.inputSelector) self.outputFrame = qt.QFrame(self.selectionCollapsibleButton) self.outputFrame.setLayout(qt.QHBoxLayout()) self.formLayout.addWidget(self.outputFrame) self.outputSelector = qt.QLabel("Output Scalar Volume: ", self.outputFrame) self.outputFrame.layout().addWidget(self.outputSelector) self.outputSelector = slicer.qMRMLNodeComboBox(self.outputFrame) self.outputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputSelector.addEnabled = True self.outputSelector.renameEnabled = True self.outputSelector.baseName = "Scalar Volume" self.outputFrame.layout().addWidget(self.outputSelector) # Apply button self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run Convert the vector to scalar." self.formLayout.addWidget(self.applyButton) self.applyButton.connect('clicked(bool)', self.onApply) # Add vertical spacer self.layout.addStretch(1)
def setupAdvancedPanel(self): logging.debug('setupAdvancedPanel') self.advancedCollapsibleButton.setProperty('collapsedHeight', 20) self.advancedCollapsibleButton.text = "Settings" self.sliceletPanelLayout.addWidget(self.advancedCollapsibleButton) self.advancedLayout = qt.QFormLayout(self.advancedCollapsibleButton) self.advancedLayout.setContentsMargins(12, 4, 4, 4) self.advancedLayout.setSpacing(4) # Layout selection combo box self.viewSelectorComboBox = qt.QComboBox(self.advancedCollapsibleButton) self.setupViewerLayouts() self.advancedLayout.addRow("Layout: ", self.viewSelectorComboBox) self.registerCustomLayouts() self.selectView(self.VIEW_ULTRASOUND_3D) # OpenIGTLink connector node selection self.linkInputSelector = slicer.qMRMLNodeComboBox() self.linkInputSelector.nodeTypes = ("vtkMRMLIGTLConnectorNode", "") self.linkInputSelector.selectNodeUponCreation = True self.linkInputSelector.addEnabled = False self.linkInputSelector.removeEnabled = True self.linkInputSelector.noneEnabled = False self.linkInputSelector.showHidden = False self.linkInputSelector.showChildNodeTypes = False self.linkInputSelector.setMRMLScene( slicer.mrmlScene ) self.linkInputSelector.setToolTip( "Select connector node" ) self.advancedLayout.addRow("OpenIGTLink connector: ", self.linkInputSelector) self.showFullSlicerInterfaceButton = qt.QPushButton() self.showFullSlicerInterfaceButton.setText("Show 3D Slicer user interface") self.advancedLayout.addRow(self.showFullSlicerInterfaceButton) self.showGuideletFullscreenButton = qt.QPushButton() self.showGuideletFullscreenButton.setText("Show guidelet in full screen") self.advancedLayout.addRow(self.showGuideletFullscreenButton) self.saveSceneButton = qt.QPushButton() self.saveSceneButton.setText("Save slicelet scene") self.advancedLayout.addRow(self.saveSceneButton) self.saveDirectoryLineEdit = qt.QLineEdit() node = self.logic.getParameterNode() sceneSaveDirectory = node.GetParameter('SavedScenesDirectory') self.saveDirectoryLineEdit.setText(sceneSaveDirectory) saveLabel = qt.QLabel() saveLabel.setText("Save scene directory:") hbox = qt.QHBoxLayout() hbox.addWidget(saveLabel) hbox.addWidget(self.saveDirectoryLineEdit) self.advancedLayout.addRow(hbox) self.exitButton = qt.QPushButton() self.exitButton.setText("Exit") self.advancedLayout.addRow(self.exitButton)
def labelSelectDialog(self): """label table dialog""" if not self.labelSelect: self.labelSelect = qt.QFrame() self.labelSelect.setLayout( qt.QVBoxLayout() ) self.labelPromptLabel = qt.QLabel() self.labelSelect.layout().addWidget( self.labelPromptLabel ) self.labelSelectorFrame = qt.QFrame() self.labelSelectorFrame.setLayout( qt.QHBoxLayout() ) self.labelSelect.layout().addWidget( self.labelSelectorFrame ) self.labelSelectorLabel = qt.QLabel() self.labelPromptLabel.setText( "Label Map: " ) self.labelSelectorFrame.layout().addWidget( self.labelSelectorLabel ) self.labelSelector = slicer.qMRMLNodeComboBox() self.labelSelector.nodeTypes = ( "vtkMRMLScalarVolumeNode", "" ) self.labelSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", "1" ) # todo addAttribute self.labelSelector.selectNodeUponCreation = False self.labelSelector.addEnabled = False self.labelSelector.noneEnabled = False self.labelSelector.removeEnabled = False self.labelSelector.showHidden = False self.labelSelector.showChildNodeTypes = False self.labelSelector.setMRMLScene( slicer.mrmlScene ) self.labelSelector.setToolTip( "Pick the label map to edit" ) self.labelSelectorFrame.layout().addWidget( self.labelSelector ) self.labelButtonFrame = qt.QFrame() self.labelButtonFrame.setLayout( qt.QHBoxLayout() ) self.labelSelect.layout().addWidget( self.labelButtonFrame ) self.labelDialogApply = qt.QPushButton("Apply", self.labelButtonFrame) self.labelDialogApply.setToolTip( "Use currently selected label node." ) self.labelButtonFrame.layout().addWidget(self.labelDialogApply) self.labelDialogCancel = qt.QPushButton("Cancel", self.labelButtonFrame) self.labelDialogCancel.setToolTip( "Cancel current operation." ) self.labelButtonFrame.layout().addWidget(self.labelDialogCancel) self.labelButtonFrame.layout().addStretch(1) self.labelDialogCreate = qt.QPushButton("Create New...", self.labelButtonFrame) self.labelDialogCreate.setToolTip( "Cancel current operation." ) self.labelButtonFrame.layout().addWidget(self.labelDialogCreate) self.labelDialogApply.connect("clicked()", self.onLabelDialogApply) self.labelDialogCancel.connect("clicked()", self.labelSelect.hide) self.labelDialogCreate.connect("clicked()", self.onLabelDialogCreate) self.labelPromptLabel.setText( "Select existing label map volume to edit." ) p = qt.QCursor().pos() self.labelSelect.setGeometry(p.x(), p.y(), 400, 200) self.labelSelect.show()
def createUserInterface( self ): ''' ''' self.skip = 0 self.__layout = self.__parent.createUserInterface() self.__basicFrame = ctk.ctkCollapsibleButton() self.__basicFrame.text = "Basic settings" self.__basicFrame.collapsed = 0 basicFrameLayout = qt.QFormLayout(self.__basicFrame) self.__layout.addRow(self.__basicFrame) self.__advancedFrame = ctk.ctkCollapsibleButton() self.__advancedFrame.text = "Advanced settings" self.__advancedFrame.collapsed = 1 advFrameLayout = qt.QFormLayout(self.__advancedFrame) self.__layout.addRow(self.__advancedFrame) threshLabel = qt.QLabel('1/ Make the holes visible:') self.__threshRange = slicer.qMRMLRangeWidget() self.__threshRange.decimals = 0 self.__threshRange.singleStep = 1 self.__useThresholdsCheck = qt.QCheckBox() self.__useThresholdsCheck.setEnabled(0) threshCheckLabel = qt.QLabel('Use thresholds for segmentation') roiLabel = qt.QLabel( 'Select segmentation:' ) self.__roiLabelSelector = slicer.qMRMLNodeComboBox() self.__roiLabelSelector.nodeTypes = ( 'vtkMRMLScalarVolumeNode', '' ) self.__roiLabelSelector.addAttribute('vtkMRMLScalarVolumeNode','LabelMap','1') self.__roiLabelSelector.toolTip = "Choose the ROI segmentation" self.__roiLabelSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__roiLabelSelector.addEnabled = 0 self.__roiLabelSelector.setMRMLScene(slicer.mrmlScene) self.__applyButton = qt.QPushButton('2/ Make a 3D Model') self.__applyButton.connect('clicked()', self.applyModelMaker) basicFrameLayout.addRow(threshLabel, self.__threshRange) basicFrameLayout.addRow(self.__applyButton) advFrameLayout.addRow(threshCheckLabel, self.__useThresholdsCheck) advFrameLayout.addRow( roiLabel, self.__roiLabelSelector ) self.__threshRange.connect('valuesChanged(double,double)', self.onThresholdChanged) self.__useThresholdsCheck.connect('stateChanged(int)', self.onThresholdsCheckChanged) self.__secondReg = qt.QPushButton('3/ ICP Registration') self.__secondReg.connect('clicked()', self.ICPRegistration) self.__secondReg.setEnabled(0) self.__layout.addRow(self.__secondReg) self.fiducialButton = qt.QPushButton('Manual Registration') self.fiducialButton.checkable = True self.__layout.addRow(self.fiducialButton) self.fiducialButton.connect('toggled(bool)', self.onRunButtonToggled)
def setup(self): # Collapsible button self.laplaceCollapsibleButton = ctk.ctkCollapsibleButton() self.laplaceCollapsibleButton.text = "Laplace Operator" self.layout.addWidget(self.laplaceCollapsibleButton) # Layout within the laplace collapsible button self.laplaceFormLayout = qt.QFormLayout(self.laplaceCollapsibleButton) # the volume selectors self.inputFrame = qt.QFrame(self.laplaceCollapsibleButton) self.inputFrame.setLayout(qt.QHBoxLayout()) self.laplaceFormLayout.addWidget(self.inputFrame) self.inputSelector = qt.QLabel("Input Volume: ", self.inputFrame) self.inputFrame.layout().addWidget(self.inputSelector) self.inputSelector = slicer.qMRMLNodeComboBox(self.inputFrame) self.inputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputFrame.layout().addWidget(self.inputSelector) self.outputFrame = qt.QFrame(self.laplaceCollapsibleButton) self.outputFrame.setLayout(qt.QHBoxLayout()) self.laplaceFormLayout.addWidget(self.outputFrame) self.outputSelector = qt.QLabel("Output Volume: ", self.outputFrame) self.outputFrame.layout().addWidget(self.outputSelector) self.outputSelector = slicer.qMRMLNodeComboBox(self.outputFrame) self.outputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputFrame.layout().addWidget(self.outputSelector) # Apply button laplaceButton = qt.QPushButton("Apply Laplace") laplaceButton.toolTip = "Run the Laplace Operator." self.laplaceFormLayout.addWidget(laplaceButton) laplaceButton.connect('clicked(bool)', self.onApply) # Add vertical spacer self.layout.addStretch(1) # Set local var as instance attribute self.laplaceButton = laplaceButton
def setup(self): # Instantiate and connect widgets ... #PARCHEE" w = qt.QWidget() layout = qt.QGridLayout() w.setLayout(layout) self.layout.addWidget(w) w.show() self.layout = layout # INPUT MENU self.inputFrame = ctk.ctkCollapsibleButton() self.inputFrame.text = "Input" self.inputFrame.collapsed = 0 inputFrameLayout = qt.QFormLayout(self.inputFrame) self.layout.addWidget(self.inputFrame) #Descubriendo que seria esto# self.__mvNode = None #Entrada multivolume label = qt.QLabel('Input multivolume') self.mvSelector = slicer.qMRMLNodeComboBox() self.mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode'] self.mvSelector.setMRMLScene(slicer.mrmlScene) self.mvSelector.addEnabled = 0 self.mvSelector.noneEnabled = 1 inputFrameLayout.addRow(label, self.mvSelector) #Entrada frame a mostrar label = qt.QLabel('Frame a mostrar') self.__veInitial = qt.QDoubleSpinBox() self.__veInitial.value = 0 inputFrameLayout.addRow(label, self.__veInitial) ###PARTE HELLO WORLD## BUTTON DE ACTIVACION # Collapsible button sampleCollapsibleButton = ctk.ctkCollapsibleButton() sampleCollapsibleButton.text = "A collapsible button" self.layout.addWidget(sampleCollapsibleButton) # Layout within the sample collapsible button sampleFormLayout = qt.QFormLayout(sampleCollapsibleButton) helloWorldButton = qt.QPushButton("Hello World") helloWorldButton.toolTip="Print 'Hello World' in standard output." sampleFormLayout.addWidget(helloWorldButton) helloWorldButton.connect('clicked(bool)',self.onHelloWorldButtonClicked) # Set local var as instance attribute self.helloWorldButton = helloWorldButton
def createUserInterface( self ): self.skip = 0 self.__layout = self.__parent.createUserInterface() baselineScanLabel = qt.QLabel( 'CT or MR scan:' ) self.__baselineVolumeSelector = slicer.qMRMLNodeComboBox() self.__baselineVolumeSelector.toolTip = "Choose the baseline scan" self.__baselineVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__baselineVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__baselineVolumeSelector.addEnabled = 0 # followupScanLabel = qt.QLabel( 'Followup scan:' ) # self.__followupVolumeSelector = slicer.qMRMLNodeComboBox() # self.__followupVolumeSelector.toolTip = "Choose the followup scan" # self.__followupVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] # self.__followupVolumeSelector.setMRMLScene(slicer.mrmlScene) # self.__followupVolumeSelector.addEnabled = 0 #Load Template Button self.loadTemplateButton = qt.QPushButton('Load template') self.__layout.addRow(self.loadTemplateButton) self.loadTemplateButton.connect('clicked()', self.loadTemplate) #Load Scan Button self.__fileFrame = ctk.ctkCollapsibleButton() self.__fileFrame.text = "File Input" self.__fileFrame.collapsed = 1 fileFrame = qt.QFormLayout(self.__fileFrame) self.__layout.addRow(self.__fileFrame) loadDataButton = qt.QPushButton('Load Scan') loadDataButton.connect('clicked()', self.loadData) fileFrame.addRow(loadDataButton) fileFrame.addRow( baselineScanLabel, self.__baselineVolumeSelector ) # DICOM ToolBox self.__DICOMFrame = ctk.ctkCollapsibleButton() self.__DICOMFrame.text = "DICOM Input" self.__DICOMFrame.collapsed = 1 dicomFrame = qt.QFormLayout(self.__DICOMFrame) self.__layout.addRow(self.__DICOMFrame) voiGroupBox = qt.QGroupBox() voiGroupBox.setTitle( 'DICOM' ) dicomFrame.addRow( voiGroupBox ) voiGroupBoxLayout = qt.QFormLayout( voiGroupBox ) self.__roiWidget = ctk.ctkDICOMAppWidget() voiGroupBoxLayout.addRow( self.__roiWidget ) self.updateWidgetFromParameters(self.parameterNode())
def setupInputFrame(self, parent=None): if not parent: parent = self.layout self.bgMultiVolumeSelector = slicer.qMRMLNodeComboBox() self.bgMultiVolumeSelector.nodeTypes = ['vtkMRMLMultiVolumeNode'] self.bgMultiVolumeSelector.setMRMLScene(slicer.mrmlScene) self.bgMultiVolumeSelector.addEnabled = 0 self._bgMultiVolumeSelectorLabel = QLabel('Input multivolume') inputFrameWidget = QWidget() self.inputFrameLayout = QFormLayout() inputFrameWidget.setLayout(self.inputFrameLayout) self.inputFrameLayout.addRow(self._bgMultiVolumeSelectorLabel, self.bgMultiVolumeSelector) parent.addWidget(inputFrameWidget)
def addInputNodeSelector(self, index, layout): inputNodeSelector = slicer.qMRMLNodeComboBox() inputNodeSelector.objectName = 'additionalInputNodeSelector'+str(index+1) inputNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] inputNodeSelector.noneEnabled = True inputNodeSelector.addEnabled = False inputNodeSelector.removeEnabled = False inputNodeSelector.editEnabled = True inputNodeSelector.enabled = 1 inputNodeSelector.setMRMLScene(slicer.mrmlScene) layout.addRow("Additional Input Volume "+str(index+1)+":", inputNodeSelector) self.connections.append( (inputNodeSelector, "currentNodeChanged(vtkMRMLNode*)", self.updateMRMLFromGUI ) ) return inputNodeSelector
def setupDialog(self): """setup dialog""" if not self.volumeSelectDialog: self.volumeSelectDialog = qt.QDialog(slicer.util.mainWindow()) self.volumeSelectDialog.objectName = 'LandmarkRegistrationVolumeSelect' self.volumeSelectDialog.setLayout( qt.QVBoxLayout() ) self.volumeSelectLabel = qt.QLabel() self.volumeSelectDialog.layout().addWidget( self.volumeSelectLabel ) self.volumeSelectorFrame = qt.QFrame() self.volumeSelectorFrame.objectName = 'VolumeSelectorFrame' self.volumeSelectorFrame.setLayout( qt.QFormLayout() ) self.volumeSelectDialog.layout().addWidget( self.volumeSelectorFrame ) self.volumeDialogSelectors = {} for viewName in ('Fixed', 'Moving',): self.volumeDialogSelectors[viewName] = slicer.qMRMLNodeComboBox() self.volumeDialogSelectors[viewName].nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.volumeDialogSelectors[viewName].selectNodeUponCreation = False self.volumeDialogSelectors[viewName].addEnabled = False self.volumeDialogSelectors[viewName].removeEnabled = True self.volumeDialogSelectors[viewName].noneEnabled = True self.volumeDialogSelectors[viewName].showHidden = False self.volumeDialogSelectors[viewName].showChildNodeTypes = True self.volumeDialogSelectors[viewName].setMRMLScene( slicer.mrmlScene ) self.volumeDialogSelectors[viewName].setToolTip( "Pick the %s volume." % viewName.lower() ) self.volumeSelectorFrame.layout().addRow("%s Volume " % viewName, self.volumeDialogSelectors[viewName]) self.volumeButtonFrame = qt.QFrame() self.volumeButtonFrame.objectName = 'VolumeButtonFrame' self.volumeButtonFrame.setLayout( qt.QHBoxLayout() ) self.volumeSelectDialog.layout().addWidget( self.volumeButtonFrame ) self.volumeDialogApply = qt.QPushButton("Apply", self.volumeButtonFrame) self.volumeDialogApply.objectName = 'VolumeDialogApply' self.volumeDialogApply.setToolTip( "Use currently selected volume nodes." ) self.volumeButtonFrame.layout().addWidget(self.volumeDialogApply) self.volumeDialogCancel = qt.QPushButton("Cancel", self.volumeButtonFrame) self.volumeDialogCancel.objectName = 'VolumeDialogCancel' self.volumeDialogCancel.setToolTip( "Cancel current operation." ) self.volumeButtonFrame.layout().addWidget(self.volumeDialogCancel) self.volumeDialogApply.connect("clicked()", self.onVolumeDialogApply) self.volumeDialogCancel.connect("clicked()", self.volumeSelectDialog.hide) self.volumeSelectLabel.setText( "Pick the volumes to use for landmark-based linear registration" ) self.volumeSelectDialog.show()
def setupFrameControlFrame(self): qSlicerMultiVolumeExplorerSimplifiedModuleWidget.setupFrameControlFrame(self) self.frameCopySelector = slicer.qMRMLNodeComboBox() self.frameCopySelector.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred) self.frameCopySelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.frameCopySelector.setMRMLScene(slicer.mrmlScene) self.frameCopySelector.addEnabled = 1 self.frameCopySelector.enabled = 0 # do not show "children" of vtkMRMLScalarVolumeNode self.frameCopySelector.hideChildNodeTypes = ["vtkMRMLDiffusionWeightedVolumeNode", "vtkMRMLDiffusionTensorVolumeNode", "vtkMRMLVectorVolumeNode"] self.extractFrameCopy = False self.extractFrameCheckBox = QCheckBox('Enable copying while sliding') hbox = QHBoxLayout() hbox.addWidget(QLabel('Current frame copy')) hbox.addWidget(self.frameCopySelector) hbox.addWidget(self.extractFrameCheckBox) self.inputFrameLayout.addRow(hbox) self.currentFrameCopySelector = slicer.qMRMLNodeComboBox() self.currentFrameCopySelector.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred) self.currentFrameCopySelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.currentFrameCopySelector.setMRMLScene(slicer.mrmlScene) self.currentFrameCopySelector.addEnabled = 0 self.currentFrameCopySelector.enabled = 0 self.currentFrameCopyButton = QPushButton('Copy frame') self.currentFrameCopyButton.toolTip = 'Copy currently selected frame' hbox2 = QHBoxLayout() hbox2.addWidget(QLabel('Current frame click-to-copy')) hbox2.addWidget(self.currentFrameCopySelector) hbox2.addWidget(self.currentFrameCopyButton) self.inputFrameLayout.addRow(hbox2)
def createInputWidget(self,n, noneEnabled=False): inputSelector = slicer.qMRMLNodeComboBox() self.widgets.append(inputSelector) inputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) inputSelector.selectNodeUponCreation = True inputSelector.addEnabled = False inputSelector.removeEnabled = False inputSelector.noneEnabled = noneEnabled inputSelector.showHidden = False inputSelector.showChildNodeTypes = False inputSelector.setMRMLScene( slicer.mrmlScene ) inputSelector.setToolTip( "Pick the input to the algorithm." ) # connect and verify parameters inputSelector.connect("nodeActivated(vtkMRMLNode*)", lambda node,i=n:self.onInputSelect(node,i)) return inputSelector
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 onPresetChanged(self, presetIndex=-1): slicer.presetSelector = self.presetSelector presetId = self.presetSelector.itemData( self.presetSelector.currentIndex) heartValveMeasurementNode = self.getHeartValveMeasurementNode() if heartValveMeasurementNode: heartValveMeasurementNode.SetAttribute( 'MeasurementPreset', presetId if presetId else "") self.measurementPreset = self.logic.getMeasurementPresetById(presetId) # Hide all valve node selectors and field selectors for widget in self.inputValveNodeLabels + self.inputValveNodeSelectors + \ self.inputReferenceRequiredCheckBoxes + self.inputReferenceNameLabels + \ self.inputReferencePointPlaceWidgets + self.inputReferenceResetButtons + \ self.inputReferenceValueSliders + [self.inputFieldsCommentLabel]: widget.hide() if not self.measurementPreset: self.setDefinitionUrl(qt.QUrl()) return if self.definitionsWidget.url != self.measurementPreset.definitionsUrl: self.setDefinitionUrl( qt.QUrl(self.measurementPreset.definitionsUrl)) if self.measurementPreset.inputFieldsComment: self.inputFieldsCommentLabel.text = self.measurementPreset.inputFieldsComment self.inputFieldsCommentLabel.show() # Add new valve selectors (reuse/hide cached selectors and labels, # as removing widgets from the layout is very tricky) inputValveIds = self.measurementPreset.inputValveIds for inputValveIndex in range(len(inputValveIds)): if inputValveIndex >= len(self.inputValveNodeSelectors): valveLabel = qt.QLabel() valveSelector = slicer.qMRMLNodeComboBox() valveSelector.nodeTypes = ["vtkMRMLScriptedModuleNode"] valveSelector.setNodeTypeLabel("HeartValve", "vtkMRMLScriptedModuleNode") valveSelector.addAttribute("vtkMRMLScriptedModuleNode", "ModuleName", "HeartValve") valveSelector.addEnabled = False valveSelector.removeEnabled = True valveSelector.noneEnabled = True valveSelector.showHidden = True # scripted module nodes are hidden by default valveSelector.renameEnabled = True valveSelector.setMRMLScene(slicer.mrmlScene) valveSelector.setToolTip("Select heart valve") self.valveSelectorsFormLayout.addRow(valveLabel, valveSelector) self.inputValveNodeLabels.append(valveLabel) self.inputValveNodeSelectors.append(valveSelector) self.annulusLabelsMarkupNodes.append(None) self.annulusLabelsMarkupNodeObservers.append([]) valveSelector.connect( "currentNodeChanged(vtkMRMLNode*)", lambda valveNode, inputValveIndex=inputValveIndex: self. onValveNodeSelect(inputValveIndex, valveNode)) else: valveLabel = self.inputValveNodeLabels[inputValveIndex] valveSelector = self.inputValveNodeSelectors[inputValveIndex] valveLabel.text = self.measurementPreset.inputValveNames[ inputValveIds[inputValveIndex]] valveLabel.show() heartValveMeasurementNode = self.getHeartValveMeasurementNode() valveNode = heartValveMeasurementNode.GetNodeReference( 'Valve' + inputValveIds[inputValveIndex]) valveSelector.setCurrentNode(valveNode) self.onValveNodeSelect(inputValveIndex, valveNode) valveSelector.show() # Add field selectors (reuse/hide cached widgets, as removing widgets from the layout is very tricky) inputFields = self.measurementPreset.inputFields self.inputFieldValues = {} self.fieldsCollapsibleButton.enabled = len(inputFields) != 0 for inputFieldIndex in range(len(inputFields)): # Get widgets if inputFieldIndex >= len(self.inputReferenceRequiredCheckBoxes): # need to add a new field requiredCheckBox = qt.QCheckBox() nameLabel = qt.QLabel() pointPlaceWidget = slicer.qSlicerMarkupsPlaceWidget() pointPlaceWidget.setButtonsVisible(False) pointPlaceWidget.placeButton().show() pointPlaceWidget.setMRMLScene(slicer.mrmlScene) pointPlaceWidget.placeMultipleMarkups = slicer.qSlicerMarkupsPlaceWidget.ForcePlaceSingleMarkup pointPlaceWidget.connect( 'activeMarkupsFiducialPlaceModeChanged(bool)', lambda enable, inputFieldIndex=inputFieldIndex: self. onReferencePointMarkupPlace(inputFieldIndex, enable)) resetButton = qt.QPushButton("Reset") resetButton.connect('clicked()', lambda inputFieldIndex=inputFieldIndex: self.onFieldValueReset(inputFieldIndex)) valueSlider = ctk.ctkSliderWidget() valueSlider.connect( 'valueChanged(double)', lambda value, inputFieldIndex=inputFieldIndex: self. onInputFieldValueChanged(inputFieldIndex, value)) self.fieldsWidgetsGridLayout.addWidget(requiredCheckBox, inputFieldIndex, 0) self.fieldsWidgetsGridLayout.addWidget(nameLabel, inputFieldIndex, 1) # Put the pointPlaceWidget and resetButton in the same grid cell, as either one or the other is shown hFrame = qt.QFrame() hBoxLayout = qt.QHBoxLayout() hFrame.setLayout(hBoxLayout) pointPlaceWidget.hide() # only one of widgets will be shown resetButton.hide() # only one of widgets will be shown hBoxLayout.addWidget(pointPlaceWidget) hBoxLayout.addWidget(resetButton) resetButton.checked = True # to be in sync with enabled status of other widgets requiredCheckBox.connect('toggled(bool)', resetButton, 'setEnabled(bool)') requiredCheckBox.connect('toggled(bool)', valueSlider, 'setEnabled(bool)') requiredCheckBox.connect( 'toggled(bool)', lambda enable, inputFieldIndex=inputFieldIndex: self. onFieldValueEnabled(inputFieldIndex, enable)) self.fieldsWidgetsGridLayout.addWidget(hFrame, inputFieldIndex, 2) self.fieldsWidgetsGridLayout.addWidget(valueSlider, inputFieldIndex, 3) self.inputReferenceRequiredCheckBoxes.append(requiredCheckBox) self.inputReferenceNameLabels.append(nameLabel) self.inputReferencePointPlaceWidgets.append(pointPlaceWidget) self.inputReferenceResetButtons.append(resetButton) self.inputReferenceValueSliders.append(valueSlider) else: requiredCheckBox = self.inputReferenceRequiredCheckBoxes[ inputFieldIndex] nameLabel = self.inputReferenceNameLabels[inputFieldIndex] pointPlaceWidget = self.inputReferencePointPlaceWidgets[ inputFieldIndex] resetButton = self.inputReferenceResetButtons[inputFieldIndex] valueSlider = self.inputReferenceValueSliders[inputFieldIndex] sliderWasBlocked = valueSlider.blockSignals(True) checkBoxWasBlocked = requiredCheckBox.blockSignals(True) field = inputFields[inputFieldIndex] fieldType = field[FIELD_TYPE] required = FIELD_REQUIRED in field.keys() and field[FIELD_REQUIRED] requiredCheckBox.show() if fieldType == FIELD_TYPE_POINT: # Reference point valveId = field[FIELD_VALVE_ID] valveModel = self.inputValveModels[ valveId] if valveId in self.inputValveModels.keys( ) else None pointPositionAnnulus = valveModel.getAnnulusMarkupPositionByLabel( field[FIELD_NAME]) if valveModel else None requiredCheckBox.checked = pointPositionAnnulus is not None requiredCheckBox.enabled = True nameLabel.text = field[FIELD_NAME] + ' point' nameLabel.show() pointPlaceWidget.setCurrentNode( self.pointFieldMarkupsNode[inputFieldIndex]) pointPlaceWidget.enabled = True pointPlaceWidget.show() if valveId: # point is constrained to the annulus contour, show slider to allow adjustment if pointPositionAnnulus is not None: [_, closestPointIdOnAnnulusCurve ] = valveModel.annulusContourCurve.getClosestPoint( pointPositionAnnulus) pointDistanceAlongCurve = valveModel.annulusContourCurve.getCurveLength( closestPointIdOnAnnulusCurve) valueSlider.minimum = pointDistanceAlongCurve - 20 valueSlider.maximum = pointDistanceAlongCurve + 20 valueSlider.value = pointDistanceAlongCurve else: valueSlider.minimum = 0 valueSlider.maximum = 0 valueSlider.value = 0 valueSlider.singleStep = 0.1 valueSlider.pageStep = 1.0 valueSlider.suffix = 'mm' valueSlider.enabled = requiredCheckBox.checked valueSlider.show() elif fieldType == FIELD_TYPE_SCALAR: requiredCheckBox.checked = required requiredCheckBox.enabled = not required # Reference value nameLabel.text = field[FIELD_NAME] nameLabel.show() resetButton.show() resetButton.enabled = required valueSlider.minimum = field[FIELD_MIN_VALUE] valueSlider.maximum = field[FIELD_MAX_VALUE] valueSlider.value = field[FIELD_DEFAULT_VALUE] if required: self.inputFieldValues[field[FIELD_ID]] = valueSlider.value valueSlider.singleStep = field[FIELD_STEP_SIZE] valueSlider.pageStep = valueSlider.singleStep * 5 valueSlider.suffix = field[KEY_UNIT] valueSlider.enabled = required valueSlider.show() valueSlider.blockSignals(sliderWasBlocked) requiredCheckBox.blockSignals(checkBoxWasBlocked)
def setup(self): # Instantiate and connect widgets ... # # Reload and Test area # reloadCollapsibleButton = ctk.ctkCollapsibleButton() reloadCollapsibleButton.text = "Reload && Test" self.layout.addWidget(reloadCollapsibleButton) reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) # reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "AblationMarginVisualizer Reload" reloadFormLayout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # # Basic Area # basicCollapsibleButton = ctk.ctkCollapsibleButton() basicCollapsibleButton.text = "Basic" self.layout.addWidget(basicCollapsibleButton) # Layout within the dummy collapsible button basicFormLayout = qt.QFormLayout(basicCollapsibleButton) # # Tumor label selector # self.tumorLabelSelector = slicer.qMRMLNodeComboBox() self.tumorLabelSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.tumorLabelSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", 1) self.tumorLabelSelector.selectNodeUponCreation = True self.tumorLabelSelector.addEnabled = False self.tumorLabelSelector.removeEnabled = False self.tumorLabelSelector.noneEnabled = False self.tumorLabelSelector.showHidden = False self.tumorLabelSelector.showChildNodeTypes = False self.tumorLabelSelector.setMRMLScene(slicer.mrmlScene) self.tumorLabelSelector.setToolTip( "Select label image of the tumor volume") basicFormLayout.addRow("Tumor Volume: ", self.tumorLabelSelector) self.outputModelSelector = slicer.qMRMLNodeComboBox() self.outputModelSelector.nodeTypes = (("vtkMRMLModelNode"), "") self.outputModelSelector.selectNodeUponCreation = False self.outputModelSelector.addEnabled = False self.outputModelSelector.renameEnabled = False self.outputModelSelector.removeEnabled = False self.outputModelSelector.noneEnabled = False self.outputModelSelector.showHidden = False self.outputModelSelector.showChildNodeTypes = False self.outputModelSelector.setMRMLScene(slicer.mrmlScene) self.outputModelSelector.setToolTip( "Select a surface model of the ablation volume") basicFormLayout.addRow("Ablation Volume Model: ", self.outputModelSelector) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = True basicFormLayout.addRow(self.applyButton) self.applyButton.connect('clicked(bool)', self.onApplyButton) # # Visualization Area # visualizationCollapsibleButton = ctk.ctkCollapsibleButton() visualizationCollapsibleButton.text = "Visualization" self.layout.addWidget(visualizationCollapsibleButton) # Layout within the dummy collapsible button visualizationFormLayout = qt.QFormLayout( visualizationCollapsibleButton) self.colorMapSelector = slicer.qMRMLColorTableComboBox() self.colorMapSelector.setMRMLScene(slicer.mrmlScene) visualizationFormLayout.addRow("Color Table: ", self.colorMapSelector) self.colorMapSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onColorTableSelect) #self.colorRangeWidget = slicer.qMRMLRangeWidget() self.colorRangeWidget = ctk.ctkRangeWidget() self.colorRangeWidget.setToolTip("Set color range") visualizationFormLayout.addRow("Color Range: ", self.colorRangeWidget) self.colorRangeWidget.connect('valuesChanged(double, double)', self.updateColorRange) self.showScaleButton = qt.QCheckBox() self.showScaleButton.setText('Show Scale') self.showScaleButton.checked = False self.showScaleButton.setToolTip( 'Check to show the scale bar in the 3D viewer') visualizationFormLayout.addRow("Ablation Volume Model: ", self.showScaleButton) self.showScaleButton.connect('clicked(bool)', self.onShowScaleButton) # connections #self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) #self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1) ## Create a scale self.scalarBarWidget = vtk.vtkScalarBarWidget() actor = self.scalarBarWidget.GetScalarBarActor() actor.SetOrientationToVertical() actor.SetNumberOfLabels(11) actor.SetTitle("") actor.SetLabelFormat(" %#8.3f") actor.SetPosition(0.1, 0.1) actor.SetWidth(0.1) actor.SetHeight(0.8) self.scalarBarWidget.SetEnabled(0) layout = slicer.app.layoutManager() view = layout.threeDWidget(0).threeDView() renderer = layout.activeThreeDRenderer() self.scalarBarWidget.SetInteractor( renderer.GetRenderWindow().GetInteractor())
def setup(self): # Path collapsible button pathCollapsibleButton = ctk.ctkCollapsibleButton() pathCollapsibleButton.text = "Path" self.layout.addWidget(pathCollapsibleButton) # Layout within the path collapsible button pathFormLayout = qt.QFormLayout(pathCollapsibleButton) # Camera node selector cameraNodeSelector = slicer.qMRMLNodeComboBox() cameraNodeSelector.objectName = 'cameraNodeSelector' cameraNodeSelector.toolTip = "Select a camera that will fly along this path." cameraNodeSelector.nodeTypes = ['vtkMRMLCameraNode'] cameraNodeSelector.noneEnabled = False cameraNodeSelector.addEnabled = False cameraNodeSelector.removeEnabled = False cameraNodeSelector.connect('currentNodeChanged(bool)', self.enableOrDisableCreateButton) cameraNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.setCameraNode) pathFormLayout.addRow("Camera:", cameraNodeSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', cameraNodeSelector, 'setMRMLScene(vtkMRMLScene*)') # Input fiducials node selector inputFiducialsNodeSelector = slicer.qMRMLNodeComboBox() inputFiducialsNodeSelector.objectName = 'inputFiducialsNodeSelector' inputFiducialsNodeSelector.toolTip = "Select a fiducial list to define control points for the path." inputFiducialsNodeSelector.nodeTypes = ['vtkMRMLAnnotationHierarchyNode', 'vtkMRMLFiducialListNode'] inputFiducialsNodeSelector.noneEnabled = True inputFiducialsNodeSelector.addEnabled = False inputFiducialsNodeSelector.removeEnabled = False inputFiducialsNodeSelector.connect('currentNodeChanged(bool)', self.enableOrDisableCreateButton) pathFormLayout.addRow("Input Fiducials:", inputFiducialsNodeSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', inputFiducialsNodeSelector, 'setMRMLScene(vtkMRMLScene*)') # CreatePath button createPathButton = qt.QPushButton("Create path") createPathButton.toolTip = "Create the path." createPathButton.enabled = False pathFormLayout.addRow(createPathButton) createPathButton.connect('clicked()', self.onCreatePathButtonClicked) # Flythrough collapsible button flythroughCollapsibleButton = ctk.ctkCollapsibleButton() flythroughCollapsibleButton.text = "Flythrough" flythroughCollapsibleButton.enabled = False self.layout.addWidget(flythroughCollapsibleButton) # Layout within the Flythrough collapsible button flythroughFormLayout = qt.QFormLayout(flythroughCollapsibleButton) # Frame slider frameSlider = ctk.ctkSliderWidget() frameSlider.connect('valueChanged(double)', self.frameSliderValueChanged) frameSlider.decimals = 0 flythroughFormLayout.addRow("Frame:", frameSlider) # Frame skip slider frameSkipSlider = ctk.ctkSliderWidget() frameSkipSlider.connect('valueChanged(double)', self.frameSkipSliderValueChanged) frameSkipSlider.decimals = 0 frameSkipSlider.minimum = 0 frameSkipSlider.maximum = 10 flythroughFormLayout.addRow("Frame skip:", frameSkipSlider) # Frame delay slider frameDelaySlider = ctk.ctkSliderWidget() frameDelaySlider.connect('valueChanged(double)', self.frameDelaySliderValueChanged) frameDelaySlider.decimals = 0 frameDelaySlider.minimum = 5 frameDelaySlider.maximum = 100 frameDelaySlider.suffix = " ms" frameDelaySlider.value = 20 flythroughFormLayout.addRow("Frame delay:", frameDelaySlider) # View angle slider viewAngleSlider = ctk.ctkSliderWidget() viewAngleSlider.connect('valueChanged(double)', self.viewAngleSliderValueChanged) viewAngleSlider.decimals = 0 viewAngleSlider.minimum = 30 viewAngleSlider.maximum = 180 flythroughFormLayout.addRow("View Angle:", viewAngleSlider) # Play button playButton = qt.QPushButton("Play") playButton.toolTip = "Fly through path." playButton.checkable = True flythroughFormLayout.addRow(playButton) playButton.connect('toggled(bool)', self.onPlayButtonToggled) # Add vertical spacer self.layout.addStretch(1) # Set local var as instance attribute self.cameraNodeSelector = cameraNodeSelector self.inputFiducialsNodeSelector = inputFiducialsNodeSelector self.createPathButton = createPathButton self.flythroughCollapsibleButton = flythroughCollapsibleButton self.frameSlider = frameSlider self.viewAngleSlider = viewAngleSlider self.playButton = playButton
def setup(self): # Instantiate and connect widgets ... # Reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "CMRToolkitRegistration Reload" self.layout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # Register Volume collapsible button collapsibleButton = ctk.ctkCollapsibleButton() collapsibleButton.text = "Register Volume" self.layout.addWidget(collapsibleButton) # Layout within the dummy collapsible button formLayout = qt.QFormLayout(collapsibleButton) # The image volume selectors self.fixedFrame = qt.QFrame(collapsibleButton) self.fixedFrame.setLayout(qt.QHBoxLayout()) formLayout.addWidget(self.fixedFrame) self.fixedSelector = qt.QLabel("Image Volume One (Fixed): ", self.fixedFrame) self.fixedFrame.layout().addWidget(self.fixedSelector) self.fixedSelector = slicer.qMRMLNodeComboBox(self.fixedFrame) self.fixedSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.fixedSelector.addEnabled = False self.fixedSelector.removeEnabled = False self.fixedSelector.renameEnabled = True self.fixedSelector.setMRMLScene( slicer.mrmlScene ) self.fixedFrame.layout().addWidget(self.fixedSelector) self.movingFrame = qt.QFrame(collapsibleButton) self.movingFrame.setLayout(qt.QHBoxLayout()) formLayout.addWidget(self.movingFrame) self.movingSelector = qt.QLabel("Image Volume Two (Moving): ", self.movingFrame) self.movingFrame.layout().addWidget(self.movingSelector) self.movingSelector = slicer.qMRMLNodeComboBox(self.movingFrame) self.movingSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.movingSelector.addEnabled = False self.movingSelector.removeEnabled = False self.movingSelector.renameEnabled = True self.movingSelector.setMRMLScene( slicer.mrmlScene ) self.movingFrame.layout().addWidget(self.movingSelector) self.outputFrame = qt.QFrame(collapsibleButton) self.outputFrame.setLayout(qt.QHBoxLayout()) formLayout.addWidget(self.outputFrame) self.outputSelector = qt.QLabel("Output Image Volume: ", self.outputFrame) self.outputFrame.layout().addWidget(self.outputSelector) self.outputSelector = slicer.qMRMLNodeComboBox(self.outputFrame) self.outputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputSelector.addEnabled = True self.outputSelector.renameEnabled = True self.outputSelector.baseName = "Registered Volume" self.outputFrame.layout().addWidget(self.outputSelector) # Imaging Modality selection self.presetFrame = qt.QFrame(collapsibleButton) self.presetFrame.setLayout(qt.QHBoxLayout()) formLayout.addWidget(self.presetFrame) self.presetSelector = qt.QLabel("Imaging Modality: ", self.presetFrame) self.presetFrame.layout().addWidget(self.presetSelector) self.presetComboBox = qt.QComboBox() self.presetComboBox.addItem("LGE-MRI to LGE-MRI") self.presetComboBox.addItem("MRA to LGE-MRI") self.presetComboBox.addItem("MRA to MRA") self.presetComboBox.addItem("CT to LGE-MRI") self.presetComboBox.addItem("Acute Scar to LGE-MRI") self.presetComboBox.setCurrentIndex(-1) self.presetFrame.layout().addWidget(self.presetComboBox) # Connect Imaging Modality widget to parameters widgets self.presetComboBox.connect('currentIndexChanged(QString)', self.setParameters) # Check box self.cropCheckBox = qt.QCheckBox("Image volumes are cropped to area around LA", collapsibleButton) self.cropCheckBox.toolTip = "For best registration, indicate whether the volumes have been cropped to the LA ROI" formLayout.addWidget(self.cropCheckBox) # Connect check box to registration parameters self.cropCheckBox.connect('stateChanged(int)', self.croppedImagesParameters) # Register Volume button registerButton = qt.QPushButton("Apply Registration") registerButton.toolTip = "Register Volume Two (Moving) onto Volume One (Fixed)." formLayout.addWidget(registerButton) registerButton.connect('clicked(bool)', self.onRegisterButtonClicked) # Advanced Registration Parameters collapsible button collapsibleButton2 = ctk.ctkCollapsibleButton() collapsibleButton2.text = "Advanced Registration Parameters" collapsibleButton2.collapsedHeight = 350 collapsibleButton2.collapsed = True self.layout.addWidget(collapsibleButton2) formLayout2 = qt.QFormLayout(collapsibleButton2) # Registration options self.regnFrame = qt.QFrame(collapsibleButton2) self.regnFrame.setLayout(qt.QHBoxLayout()) formLayout2.addWidget(self.regnFrame) self.regnSelector = qt.QLabel("Select the Type of Registration: ", self.regnFrame) self.regnFrame.layout().addWidget(self.regnSelector) self.regnComboBox = qt.QComboBox() self.regnComboBox.addItem("Rigid") self.regnComboBox.addItem("Affine") self.regnComboBox.addItem("BSpline") self.regnComboBox.addItem("PipelineRigid") self.regnComboBox.addItem("PipelineAffine") self.regnComboBox.addItem("PipelineBSpline") self.regnComboBox.setCurrentIndex(-1) self.regnFrame.layout().addWidget(self.regnComboBox) # Metric options self.metFrame = qt.QFrame(collapsibleButton2) self.metFrame.setLayout(qt.QHBoxLayout()) formLayout2.addWidget(self.metFrame) self.metSelector = qt.QLabel("Select the Type of Metric: ", self.metFrame) self.metFrame.layout().addWidget(self.metSelector) self.metComboBox = qt.QComboBox() self.metComboBox.setLayout(qt.QHBoxLayout()) self.metComboBox.addItem("MattesMI") self.metComboBox.addItem("NormCorr") self.metComboBox.addItem("MeanSqrd") self.metComboBox.setCurrentIndex(-1) self.metFrame.layout().addWidget(self.metComboBox) # Initialization options self.initFrame = qt.QFrame(collapsibleButton2) self.initFrame.setLayout(qt.QHBoxLayout()) formLayout2.addWidget(self.initFrame) self.initSelector = qt.QLabel("Select the Type of Initialization: ", self.initFrame) self.initFrame.layout().addWidget(self.initSelector) self.initComboBox = qt.QComboBox() self.initComboBox.setLayout(qt.QHBoxLayout()) self.initComboBox.addItem("ImageCenters") self.initComboBox.addItem("CentersOfMass") self.initComboBox.addItem("SecondMoments") self.initComboBox.setCurrentIndex(-1) self.initFrame.layout().addWidget(self.initComboBox) # Interpolation options self.interpFrame = qt.QFrame(collapsibleButton2) self.interpFrame.setLayout(qt.QHBoxLayout()) formLayout2.addWidget(self.interpFrame) self.interpSelector = qt.QLabel("Select the Type of Interpolation: ", self.interpFrame) self.interpFrame.layout().addWidget(self.interpSelector) self.interpComboBox = qt.QComboBox() self.interpComboBox.setLayout(qt.QHBoxLayout()) self.interpComboBox.addItem("NearestNeighbor") self.interpComboBox.addItem("Linear") self.interpComboBox.addItem("BSpline") self.interpComboBox.setCurrentIndex(-1) self.interpFrame.layout().addWidget(self.interpComboBox) # Maximum number of iterations self.iterFrame = qt.QFrame(collapsibleButton2) self.iterFrame.setLayout(qt.QHBoxLayout()) formLayout2.addWidget(self.iterFrame) self.iterEditSelector = qt.QLabel("Enter the Maximum Number of Iterations: ", self.iterFrame) self.iterFrame.layout().addWidget(self.iterEditSelector) self.iterSpinBox = qt.QSpinBox() self.iterSpinBox.setLayout(qt.QHBoxLayout()) self.iterSpinBox.setMinimum(1) self.iterSpinBox.setMaximum(2000) self.iterSpinBox.setValue(0) self.iterSpinBox.toolTip = "The maximum number of iterations to try before failing to converge." self.iterFrame.layout().addWidget(self.iterSpinBox) # Sampling Ratio Slider self.sampframe = qt.QFrame(collapsibleButton2) self.sampframe.setLayout(qt.QHBoxLayout()) formLayout2.addWidget(self.sampframe) self.sampSliderSelector = qt.QLabel("Sampling Ratio (Accuracy of Registration): ", self.sampframe) self.sampframe.layout().addWidget(self.sampSliderSelector) self.sampSliderFrame = ctk.ctkSliderWidget() self.sampSliderFrame.minimum = 0 self.sampSliderFrame.maximum = 1 self.sampSliderFrame.decimals = 2 self.sampSliderFrame.singleStep = 0.01 self.sampframe.layout().addWidget(self.sampSliderFrame) # Sample from fixed/moving overlap check box self.sampleCheckBox = qt.QCheckBox("Sample from fixed/moving image overlap", collapsibleButton2) self.sampleCheckBox.toolTip = "Limit metric evaluation to the fixed image region overlapped by the moving image" formLayout2.addWidget(self.sampleCheckBox) # Set local var as instance attribute self.registerButton = registerButton
def create(self): """create the segmentation helper box""" # # Master Frame # self.masterFrame = qt.QFrame(self.parent) self.masterFrame.setLayout(qt.QVBoxLayout()) self.parent.layout().addWidget(self.masterFrame) # # the master volume selector # self.masterSelectorFrame = qt.QFrame(self.parent) self.masterSelectorFrame.setLayout(qt.QHBoxLayout()) self.masterFrame.layout().addWidget(self.masterSelectorFrame) self.masterSelectorLabel = qt.QLabel("Master Volume: ", self.masterSelectorFrame) self.masterSelectorLabel.setToolTip( "Select the master volume (background grayscale scalar volume node)" ) self.masterSelectorFrame.layout().addWidget(self.masterSelectorLabel) self.masterSelector = slicer.qMRMLNodeComboBox( self.masterSelectorFrame) # TODO self.masterSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.masterSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", 0) self.masterSelector.selectNodeUponCreation = False self.masterSelector.addEnabled = False self.masterSelector.removeEnabled = False self.masterSelector.noneEnabled = True self.masterSelector.showHidden = False self.masterSelector.showChildNodeTypes = False self.masterSelector.setMRMLScene(slicer.mrmlScene) # TODO: need to add a QLabel # self.masterSelector.SetLabelText( "Master Volume:" ) self.masterSelector.setToolTip( "Pick the master structural volume to define the segmentation. A label volume with the with \"-label\" appended to the name will be created if it doesn't already exist." ) self.masterSelectorFrame.layout().addWidget(self.masterSelector) # # merge label name and set button # self.mergeFrame = qt.QFrame(self.masterFrame) self.mergeFrame.setLayout(qt.QHBoxLayout()) self.masterFrame.layout().addWidget(self.mergeFrame) mergeNameToolTip = "Composite label map containing the merged structures (be aware that merge operations will overwrite any edits applied to this volume)" self.mergeNameLabel = qt.QLabel("Merge Volume: ", self.mergeFrame) self.mergeNameLabel.setToolTip(mergeNameToolTip) self.mergeFrame.layout().addWidget(self.mergeNameLabel) self.mergeName = qt.QLabel("", self.mergeFrame) self.mergeName.setToolTip(mergeNameToolTip) self.mergeFrame.layout().addWidget(self.mergeName) self.setMergeButton = qt.QPushButton("Set...", self.mergeFrame) self.setMergeButton.setToolTip( "Set the merge volume to use with this master.") self.mergeFrame.layout().addWidget(self.setMergeButton) # # Structures Frame # self.structuresFrame = ctk.ctkCollapsibleGroupBox(self.masterFrame) self.structuresFrame.title = "Per-Structure Volumes" self.structuresFrame.collapsed = True self.structuresFrame.setLayout(qt.QVBoxLayout()) self.masterFrame.layout().addWidget(self.structuresFrame) # buttons frame self.structureButtonsFrame = qt.QFrame(self.structuresFrame) self.structureButtonsFrame.setLayout(qt.QHBoxLayout()) self.structuresFrame.layout().addWidget(self.structureButtonsFrame) # add button self.addStructureButton = qt.QPushButton("Add Structure", self.structureButtonsFrame) self.addStructureButton.setToolTip( "Add a label volume for a structure to edit") self.structureButtonsFrame.layout().addWidget(self.addStructureButton) # split button self.splitButton = qt.QPushButton("Split Merge Volume", self.structuresFrame) self.splitButton.setToolTip( "Split distinct labels from merge volume into new volumes") self.structureButtonsFrame.layout().addWidget(self.splitButton) # structures view self.structuresView = qt.QTreeView() self.structuresView.sortingEnabled = True self.structuresFrame.layout().addWidget(self.structuresView) # all buttons frame self.allButtonsFrame = qt.QFrame(self.structuresFrame) self.allButtonsFrame.setLayout(qt.QHBoxLayout()) self.structuresFrame.layout().addWidget(self.allButtonsFrame) # delete structures button self.deleteStructuresButton = qt.QPushButton("Delete Structures", self.allButtonsFrame) self.deleteStructuresButton.setToolTip( "Delete all the structure volumes from the scene.\n\nNote: to delete individual structure volumes, use the Data Module." ) self.allButtonsFrame.layout().addWidget(self.deleteStructuresButton) # merge button self.mergeButton = qt.QPushButton("Merge All", self.allButtonsFrame) self.mergeButton.setToolTip("Merge all structures into Merge Volume") self.allButtonsFrame.layout().addWidget(self.mergeButton) # merge and build button self.mergeAndBuildButton = qt.QPushButton("Merge And Build", self.allButtonsFrame) self.mergeAndBuildButton.setToolTip( "Merge all structures into Merge Volume and build models from all structures" ) self.allButtonsFrame.layout().addWidget(self.mergeAndBuildButton) # options frame self.optionsFrame = qt.QFrame(self.structuresFrame) self.optionsFrame.setLayout(qt.QHBoxLayout()) self.structuresFrame.layout().addWidget(self.optionsFrame) # replace models button self.replaceModels = qt.QCheckBox("Replace Models", self.optionsFrame) self.replaceModels.setToolTip( "Replace any existing models when building") self.replaceModels.setChecked(1) self.optionsFrame.layout().addWidget(self.replaceModels) # # signals, slots, and observers # # signals/slots on qt widgets are automatically when # this class destructs, but observers of the scene must be explicitly # removed in the destuctor # node selected self.masterSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # buttons pressed self.addStructureButton.connect("clicked()", self.addStructure) self.deleteStructuresButton.connect("clicked()", self.deleteStructures) # selection changed event # invoked event self.splitButton.connect("clicked()", self.split) self.mergeButton.connect("clicked()", self.mergeStructures) self.mergeAndBuildButton.connect("clicked()", self.onMergeAndBuild) self.setMergeButton.connect("clicked()", self.labelSelectDialog) # so buttons will initially be disabled self.master = None self.updateStructures()
def createUserInterface(self): """ This method uses qt to create a user interface. qMRMLNodeComboBox is a drop down menu for picking MRML files. MRML files have to be added to a "scene," i.e. the main Slicer container, hence setMRMLScene. """ self.__layout = self.__parent.createUserInterface() image_label = qt.QLabel('Test label') image = qt.QPixmap( 'C:/Users/azb22/Documents/GitHub/Public_qtim_tools/SlicerGBMWizard/GBMWizard/GBMWizard_Lib/VolumeSelect.png' ) image_label.setPixmap(image) image_label.alignment = 4 self.__layout.addRow(image_label) step_label = qt.QLabel( 'This module requires four MRI volumes for GBM cases. Please select pre- and post-contrast T1 images, a T2 image, and a FLAIR image from a single patient visit. The ability to use multiple cases will be added in future versions.' ) step_label.setWordWrap(True) self.__informationGroupBox = qt.QGroupBox() self.__informationGroupBox.setTitle('Information') self.__informationGroupBoxLayout = qt.QFormLayout( self.__informationGroupBox) self.__volumeSelectionGroupBox = qt.QGroupBox() self.__volumeSelectionGroupBox.setTitle('Volume Selection') self.__volumeSelectionGroupBoxLayout = qt.QFormLayout( self.__volumeSelectionGroupBox) t1PreScanLabel = qt.QLabel('Pre-Contrast T1 Image:') self.__t1PreVolumeSelector = slicer.qMRMLNodeComboBox() self.__t1PreVolumeSelector.toolTip = "Select a pre-contrast T1 image." self.__t1PreVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__t1PreVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__t1PreVolumeSelector.addEnabled = 0 t1PostScanLabel = qt.QLabel('Post-Contrast T1 Image:') self.__t1PostVolumeSelector = slicer.qMRMLNodeComboBox() self.__t1PostVolumeSelector.toolTip = "Select a post-contrast T1 image." self.__t1PostVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__t1PostVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__t1PostVolumeSelector.addEnabled = 0 t2ScanLabel = qt.QLabel('T2 Image:') self.__t2VolumeSelector = slicer.qMRMLNodeComboBox() self.__t2VolumeSelector.toolTip = "Select a T2 image." self.__t2VolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__t2VolumeSelector.setMRMLScene(slicer.mrmlScene) self.__t2VolumeSelector.addEnabled = 0 flairScanLabel = qt.QLabel('FLAIR Image:') self.__flairVolumeSelector = slicer.qMRMLNodeComboBox() self.__flairVolumeSelector.toolTip = "Select a FLAIR image." self.__flairVolumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.__flairVolumeSelector.setMRMLScene(slicer.mrmlScene) self.__flairVolumeSelector.addEnabled = 0 self.__layout.addRow(self.__informationGroupBox) self.__informationGroupBoxLayout.addRow(step_label) self.__layout.addRow(self.__volumeSelectionGroupBox) self.__volumeSelectionGroupBoxLayout.addRow(t1PreScanLabel, self.__t1PreVolumeSelector) self.__volumeSelectionGroupBoxLayout.addRow( t1PostScanLabel, self.__t1PostVolumeSelector) self.__volumeSelectionGroupBoxLayout.addRow(t2ScanLabel, self.__t2VolumeSelector) self.__volumeSelectionGroupBoxLayout.addRow(flairScanLabel, self.__flairVolumeSelector) self.volumeNodes = [ self.__t1PostVolumeSelector.currentNode(), self.__t1PostVolumeSelector.currentNode(), self.__t2VolumeSelector.currentNode(), self.__flairVolumeSelector.currentNode() ] self.updateWidgetFromParameters(self.parameterNode()) # This timer is a trick to wait for buttons to load BEFORE deleting them. qt.QTimer.singleShot(0, self.killButton)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) transformWarningLabel = qt.QLabel( "Note: Parent transforms of models are not used. Models should be defined in the coordinate system that is being registered." ) transformWarningLabel.setWordWrap(True) parametersFormLayout.addRow(transformWarningLabel) # # input target (fixed, dense) model selector # self.inputTargetModelSelector = slicer.qMRMLNodeComboBox() self.inputTargetModelSelector.nodeTypes = (("vtkMRMLModelNode"), "") self.inputTargetModelSelector.selectNodeUponCreation = True self.inputTargetModelSelector.addEnabled = False self.inputTargetModelSelector.removeEnabled = False self.inputTargetModelSelector.noneEnabled = False self.inputTargetModelSelector.showHidden = False self.inputTargetModelSelector.showChildNodeTypes = False self.inputTargetModelSelector.setMRMLScene(slicer.mrmlScene) self.inputTargetModelSelector.setToolTip( "Select the model the other will be transformed to. This model required to contain a dense set of points." ) parametersFormLayout.addRow("Input fixed (dense) model: ", self.inputTargetModelSelector) # # input source (moving) model selector # self.inputSourceModelSelector = slicer.qMRMLNodeComboBox() self.inputSourceModelSelector.nodeTypes = (("vtkMRMLModelNode"), "") self.inputSourceModelSelector.selectNodeUponCreation = True self.inputSourceModelSelector.addEnabled = False self.inputSourceModelSelector.removeEnabled = False self.inputSourceModelSelector.noneEnabled = False self.inputSourceModelSelector.showHidden = False self.inputSourceModelSelector.showChildNodeTypes = False self.inputSourceModelSelector.setMRMLScene(slicer.mrmlScene) self.inputSourceModelSelector.setToolTip( "Select the model that will be transformed. This model may require a sparse set of points." ) parametersFormLayout.addRow("Input moving (sparse) model: ", self.inputSourceModelSelector) # # output transform selector # self.outputSourceToTargetTransformSelector = slicer.qMRMLNodeComboBox() self.outputSourceToTargetTransformSelector.nodeTypes = (( "vtkMRMLLinearTransformNode"), "") self.outputSourceToTargetTransformSelector.selectNodeUponCreation = True self.outputSourceToTargetTransformSelector.addEnabled = True self.outputSourceToTargetTransformSelector.removeEnabled = True self.outputSourceToTargetTransformSelector.noneEnabled = False self.outputSourceToTargetTransformSelector.showHidden = False self.outputSourceToTargetTransformSelector.showChildNodeTypes = False self.outputSourceToTargetTransformSelector.renameEnabled = True self.outputSourceToTargetTransformSelector.setMRMLScene( slicer.mrmlScene) self.outputSourceToTargetTransformSelector.setToolTip( "Pick the moving to fixed transform computed by the algorithm.") parametersFormLayout.addRow("Output transform: ", self.outputSourceToTargetTransformSelector) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # # Output panel # outputCollapsibleButton = ctk.ctkCollapsibleButton() outputCollapsibleButton.text = "Output" self.layout.addWidget(outputCollapsibleButton) outputFormLayout = qt.QFormLayout(outputCollapsibleButton) self.outputLine = qt.QLineEdit() self.outputLine.setReadOnly(True) outputFormLayout.addRow("Mean distance after registration:", self.outputLine) # # Advanced parameters # advancedCollapsibleButton = ctk.ctkCollapsibleButton() advancedCollapsibleButton.text = "Advanced" self.layout.addWidget(advancedCollapsibleButton) # Layout advancedCollapsibleButton.collapsed = True advancedFormLayout = qt.QFormLayout(advancedCollapsibleButton) # # Transform type selector # self.typeSelector = qt.QComboBox() self.typeSelector.insertItem(0, "Rigid") self.typeSelector.insertItem(1, "Similarity") self.typeSelector.insertItem(2, "Affine") advancedFormLayout.addRow("Transform type: ", self.typeSelector) # # Iteration selector # self.iterationSpin = qt.QSpinBox() self.iterationSpin.setMaximum(1000) self.iterationSpin.setValue(100) advancedFormLayout.addRow("Number of iterations:", self.iterationSpin) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputTargetModelSelector.connect( "currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.inputSourceModelSelector.connect( "currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputSourceToTargetTransformSelector.connect( "currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1)
def setup(self): # Instantiate and connect widgets ... # # IO Area # IOCollapsibleButton = ctk.ctkCollapsibleButton() IOCollapsibleButton.text = "IO Parameters" self.layout.addWidget(IOCollapsibleButton) # Layout within the dummy collapsible button IOFormLayout = qt.QFormLayout(IOCollapsibleButton) # # input volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() #self.inputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) #self.inputSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 0 ) self.inputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = True 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." ) IOFormLayout.addRow("Input Volume: ", self.inputSelector) self.fiducialsList = slicer.qMRMLNodeComboBox() self.fiducialsList.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" ) self.fiducialsList.selectNodeUponCreation = False self.fiducialsList.addEnabled = True self.fiducialsList.removeEnabled = True self.fiducialsList.noneEnabled = False self.fiducialsList.showHidden = False self.fiducialsList.showChildNodeTypes = False self.fiducialsList.setMRMLScene( slicer.mrmlScene ) self.fiducialsList.setToolTip( "Place a fiducial point within the trachea." ) self.fiducialsList.baseName = 'AirwayFiducial' IOFormLayout.addRow("Seed: ", self.fiducialsList) # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Segmentation Parameters" parametersCollapsibleButton.setChecked(False) self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # Label color slider # self.labelColorSliderWidget = ctk.ctkSliderWidget() self.labelColorSliderWidget.singleStep = 1.0 self.labelColorSliderWidget.minimum = 1.0 self.labelColorSliderWidget.maximum = 50.0 self.labelColorSliderWidget.value = 2.0 self.labelColorSliderWidget.setToolTip("Set color for the airway label") parametersFormLayout.addRow("Airway Label Color", self.labelColorSliderWidget) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." if( self.inputSelector.currentNode() and self.fiducialsList.currentNode() ): self.applyButton.enabled = True else: self.applyButton.enabled = False self.applyButton.setFixedSize(150,45) self.layout.addWidget(self.applyButton, 0, 4) # # Link to Bronchoscopy Module # """self.bronchoscopyButton = qt.QPushButton("Link To Bronchoscopy Navigation") self.bronchoscopyButton.toolTip = "Connect to the Bronchoscopy module." #self.bronchoscopyButton.checkable = True self.bronchoscopyButton.enabled = False self.bronchoscopyButton.setFixedSize(200,50) self.layout.addWidget(self.bronchoscopyButton, 0, 4)""" # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.fiducialsList.connect("currentNodeChanged(vtkMRMLNode*)",self.onSelect) #self.bronchoscopyButton.connect('clicked(bool)', self.onBronchoscopyButton) # Add vertical spacer self.layout.addStretch(1)
def setupPlotSettingsFrame(self): self.plotSettingsFrame = ctk.ctkCollapsibleButton() self.plotSettingsFrame.text = "Plotting Settings" self.plotSettingsFrame.collapsed = 1 plotSettingsFrameLayout = QFormLayout(self.plotSettingsFrame) self.layout.addWidget(self.plotSettingsFrame) # label map for probing self.labelMapSelector = slicer.qMRMLNodeComboBox() self.labelMapSelector.nodeTypes = ['vtkMRMLLabelMapVolumeNode'] self.labelMapSelector.toolTip = 'Label map to be probed' self.labelMapSelector.setMRMLScene(slicer.mrmlScene) self.labelMapSelector.addEnabled = 0 self.chartButton = QPushButton('Chart') self.chartButton.setEnabled(False) hbox = QHBoxLayout() hbox.addWidget(QLabel('Probed label volume')) hbox.addWidget(self.labelMapSelector) hbox.addWidget(self.chartButton) plotSettingsFrameLayout.addRow(hbox) self.iCharting = QCheckBox('Interactive charting') self.iCharting.setChecked(True) plotSettingsFrameLayout.addRow(self.iCharting) self.iChartingMode = QButtonGroup() self.iChartingIntensity = QRadioButton('Signal intensity') self.iChartingIntensityFixedAxes = QRadioButton('Fixed range intensity') self.iChartingPercent = QRadioButton('Percentage change') self.iChartingIntensity.setChecked(1) self.iChartingMode.addButton(self.iChartingIntensity) self.iChartingMode.addButton(self.iChartingIntensityFixedAxes) self.iChartingMode.addButton(self.iChartingPercent) hbox = QHBoxLayout() self.plottingModeGroupBox = QGroupBox('Plotting mode:') plottingModeLayout = QVBoxLayout() self.plottingModeGroupBox.setLayout(plottingModeLayout) plottingModeLayout.addWidget(self.iChartingIntensity) plottingModeLayout.addWidget(self.iChartingIntensityFixedAxes) plottingModeLayout.addWidget(self.iChartingPercent) hbox.addWidget(self.plottingModeGroupBox) self.showLegendCheckBox = QCheckBox('Display legend') self.showLegendCheckBox.setChecked(0) self.xLogScaleCheckBox = QCheckBox('Use log scale for X axis') self.xLogScaleCheckBox.setChecked(0) self.yLogScaleCheckBox = QCheckBox('Use log scale for Y axis') self.yLogScaleCheckBox.setChecked(0) self.plotGeneralSettingsGroupBox = QGroupBox('General Plot options:') plotGeneralSettingsLayout = QVBoxLayout() self.plotGeneralSettingsGroupBox.setLayout(plotGeneralSettingsLayout) plotGeneralSettingsLayout.addWidget(self.showLegendCheckBox) plotGeneralSettingsLayout.addWidget(self.xLogScaleCheckBox) plotGeneralSettingsLayout.addWidget(self.yLogScaleCheckBox) hbox.addWidget(self.plotGeneralSettingsGroupBox) plotSettingsFrameLayout.addRow(hbox) self.nFramesBaselineCalculation = QSpinBox() self.nFramesBaselineCalculation.minimum = 1 hbox = QHBoxLayout() hbox.addWidget(QLabel('Frame count(baseline calculation):')) hbox.addWidget(self.nFramesBaselineCalculation) plotSettingsFrameLayout.addRow(hbox)
def setup(self): # Instantiate and connect widgets ... w = qt.QWidget() layout = qt.QGridLayout() w.setLayout(layout) self.layout.addWidget(w) w.show() #self.layout = layout # # Reload and Test area # reloadCollapsibleButton = ctk.ctkCollapsibleButton() reloadCollapsibleButton.text = "Reload && Test" self.layout.addWidget(reloadCollapsibleButton) reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) # reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "SequenceRegistration Reload" reloadFormLayout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # reload and test button # (use this during development, but remove it when delivering # your module to users) self.reloadAndTestButton = qt.QPushButton("Reload and Test") self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests." reloadFormLayout.addWidget(self.reloadAndTestButton) self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest) # # Input Area # parametersCollapsibleButton1 = ctk.ctkCollapsibleButton() parametersCollapsibleButton1.text = "Inputs" self.layout.addWidget(parametersCollapsibleButton1) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton1) # # Input fixed image # self.fixedImageSelector = slicer.qMRMLNodeComboBox() self.fixedImageSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.fixedImageSelector.selectNodeUponCreation = True self.fixedImageSelector.addEnabled = False self.fixedImageSelector.removeEnabled = False self.fixedImageSelector.noneEnabled = False self.fixedImageSelector.showHidden = False self.fixedImageSelector.showChildNodeTypes = False self.fixedImageSelector.setMRMLScene( slicer.mrmlScene ) self.fixedImageSelector.setToolTip( "Please select the fixed image node for tracking." ) parametersFormLayout.addRow("Reference sequence/image node: ", self.fixedImageSelector) # # Input moving sequence image # self.movingImageSequenceSelector = slicer.qMRMLNodeComboBox() self.movingImageSequenceSelector.nodeTypes = ( ("vtkMRMLSequenceNode"), "" ) self.movingImageSequenceSelector.selectNodeUponCreation = True self.movingImageSequenceSelector.addEnabled = False self.movingImageSequenceSelector.removeEnabled = False self.movingImageSequenceSelector.noneEnabled = False self.movingImageSequenceSelector.showHidden = False self.movingImageSequenceSelector.showChildNodeTypes = False self.movingImageSequenceSelector.setMRMLScene( slicer.mrmlScene ) self.movingImageSequenceSelector.setToolTip( "Please select the moving sequence image node for tracking." ) parametersFormLayout.addRow("Moving sequence/image node: ", self.movingImageSequenceSelector) # # Input rigid transform # self.linearTransformSelector = slicer.qMRMLNodeComboBox() self.linearTransformSelector.nodeTypes = ( ("vtkMRMLLinearTransformNode"), "" ) self.linearTransformSelector.selectNodeUponCreation = True self.linearTransformSelector.addEnabled = True self.linearTransformSelector.removeEnabled = True self.linearTransformSelector.noneEnabled = True self.linearTransformSelector.showHidden = False self.linearTransformSelector.showChildNodeTypes = False self.linearTransformSelector.setMRMLScene( slicer.mrmlScene ) self.linearTransformSelector.setToolTip( "Please select a transform." ) parametersFormLayout.addRow("Initial transform node: ", self.linearTransformSelector) # # ROI # self.InputROISelector = slicer.qMRMLNodeComboBox() self.InputROISelector.nodeTypes = ( ("vtkMRMLAnnotationROINode"), "" ) self.InputROISelector.selectNodeUponCreation = True self.InputROISelector.addEnabled = True self.InputROISelector.removeEnabled = True self.InputROISelector.noneEnabled = True self.InputROISelector.showHidden = False self.InputROISelector.showChildNodeTypes = False self.InputROISelector.setMRMLScene( slicer.mrmlScene ) parametersFormLayout.addRow("ROI: ", self.InputROISelector) self.ROIVisibilityButton = qt.QPushButton("Off") self.ROIVisibilityButton.checkable = True self.ROIVisibilityButton.checked = False self.ROIVisibilityButton.enabled = False parametersFormLayout.addRow("ROI Visibility: ", self.ROIVisibilityButton) self.InitializeTransformModeOptions = ("Off","useGeometryAlign","useMomentsAlign") # #Initialization # self.groupBox = qt.QGroupBox("Initialize Transform Mode") self.groupBoxLayout = qt.QHBoxLayout(self.groupBox) parametersFormLayout.addRow(self.groupBox) # # layout selection # for initializeTransformModeOption in self.InitializeTransformModeOptions: initializeTransformModeButton = qt.QRadioButton(initializeTransformModeOption) initializeTransformModeButton.connect('clicked()', lambda itmo=initializeTransformModeOption: self.selectInitializeTransformMode(itmo)) self.groupBoxLayout.addWidget(initializeTransformModeButton) #self.groupBoxLayout.addRow("Layout", layoutHolder) # # Register Button # self.registerButton = qt.QPushButton("Register") self.registerButton.toolTip = "Run the algorithm." self.registerButton.enabled = False parametersFormLayout.addRow(self.registerButton) # Connections self.fixedImageSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onInputSelect) self.movingImageSequenceSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onInputSelect) self.InputROISelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onInputSelect) self.ROIVisibilityButton.connect('clicked(bool)', self.onROIVisible) self.registerButton.connect('clicked(bool)', self.onApply) # # Output Area # outputsCollapsibleButton1 = ctk.ctkCollapsibleButton() outputsCollapsibleButton1.text = "Outputs (at least one output must be specified)" self.layout.addWidget(outputsCollapsibleButton1) # Layout within the dummy collapsible button outputsFormLayout = qt.QFormLayout(outputsCollapsibleButton1) # # Output rigid transform # self.outputTransformSequenceSelector = slicer.qMRMLNodeComboBox() self.outputTransformSequenceSelector.nodeTypes = ( ("vtkMRMLSequenceNode"), "" ) self.outputTransformSequenceSelector.selectNodeUponCreation = True self.outputTransformSequenceSelector.addEnabled = True self.outputTransformSequenceSelector.removeEnabled = True self.outputTransformSequenceSelector.noneEnabled = True self.outputTransformSequenceSelector.showHidden = False self.outputTransformSequenceSelector.showChildNodeTypes = False self.outputTransformSequenceSelector.setMRMLScene( slicer.mrmlScene ) self.outputTransformSequenceSelector.setToolTip( "Please select a sequence transform node." ) outputsFormLayout.addRow("Output sequence transform node: ", self.outputTransformSequenceSelector) # # Output images # self.outputImageSequenceSelector = slicer.qMRMLNodeComboBox() self.outputImageSequenceSelector.nodeTypes = ( ("vtkMRMLSequenceNode"), "" ) self.outputImageSequenceSelector.selectNodeUponCreation = True self.outputImageSequenceSelector.addEnabled = True self.outputImageSequenceSelector.removeEnabled = True self.outputImageSequenceSelector.noneEnabled = True self.outputImageSequenceSelector.showHidden = False self.outputImageSequenceSelector.showChildNodeTypes = False self.outputImageSequenceSelector.setMRMLScene( slicer.mrmlScene ) self.outputImageSequenceSelector.setToolTip( "Please select a sequence image node." ) outputsFormLayout.addRow("Output sequence image node: ", self.outputImageSequenceSelector) # Comment out the following code as this functionality is not moved to Sequence Browser module # plottingCollapsibleButton = ctk.ctkCollapsibleButton() # plottingCollapsibleButton.text = "Plotting" # plottingCollapsibleButton.collapsed = 0 # self.layout.addWidget(plottingCollapsibleButton) # plottingFrameLayout = qt.QGridLayout(plottingCollapsibleButton) # self.ChartingDisplayOptions = ("LR","AP","SI") # self.chartingDisplayOption = 'LR' # # # #Initialization # # # self.chartGroupBox = qt.QGroupBox("Display options:") # self.chartGroupBoxLayout = qt.QHBoxLayout(self.chartGroupBox) # plottingFrameLayout.addWidget(self.chartGroupBox,0,0,1,3) # # # # layout selection # # # for chartingDisplayOption in self.ChartingDisplayOptions: # chartingDisplayOptionButton = qt.QRadioButton(chartingDisplayOption) # chartingDisplayOptionButton.connect('clicked()', lambda cdo=chartingDisplayOption: self.selectChartingDisplayOption(cdo)) # self.chartGroupBoxLayout.addWidget(chartingDisplayOptionButton) # #self.groupBoxLayout.addRow("Layout", layoutHolder) # # add chart container widget # self.__chartView = ctk.ctkVTKChartView(w) # plottingFrameLayout.addWidget(self.__chartView,1,0,1,3) # self.__chart = self.__chartView.chart() # self.__chartTable = vtk.vtkTable() # self.__xArray = vtk.vtkFloatArray() # self.__yArray = vtk.vtkFloatArray() # self.__zArray = vtk.vtkFloatArray() # self.__mArray = vtk.vtkFloatArray() # # will crash if there is no name # self.__xArray.SetName('') # self.__yArray.SetName('signal intensity') # self.__zArray.SetName('') # self.__mArray.SetName('signal intensity') # self.__chartTable.AddColumn(self.__xArray) # self.__chartTable.AddColumn(self.__yArray) # self.__chartTable.AddColumn(self.__zArray) # self.__chartTable.AddColumn(self.__mArray) self.outputTransformSequenceSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onOutputSelect) self.outputImageSequenceSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onOutputSelect) # Add vertical spacer self.layout.addStretch(1)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... if not NUMPY_AVAILABLE: label = qt.QLabel( 'The module is not available due to missing Numpy package.') self.layout.addWidget(label) label = qt.QLabel( 'You can seek help by contacting 3D Slicer user list: [email protected]' ) self.layout.addWidget(label) # Add vertical spacer self.layout.addStretch(1) return # Collapsible button dummyCollapsibleButton = ctk.ctkCollapsibleButton() dummyCollapsibleButton.text = "Basic settings" self.layout.addWidget(dummyCollapsibleButton) dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton) # add input directory selector label = qt.QLabel('Input directory:') self.__fDialog = ctk.ctkDirectoryButton() self.__fDialog.caption = 'Input directory' dummyFormLayout.addRow(label, self.__fDialog) label = qt.QLabel('Output node:') self.__mvSelector = slicer.qMRMLNodeComboBox() self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode'] self.__mvSelector.setMRMLScene(slicer.mrmlScene) self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onMRMLSceneChanged) self.__mvSelector.addEnabled = 1 dummyFormLayout.addRow(label, self.__mvSelector) # Collapsible button dummyCollapsibleButton = ctk.ctkCollapsibleButton() dummyCollapsibleButton.text = "Advanced settings" dummyCollapsibleButton.collapsed = 1 self.layout.addWidget(dummyCollapsibleButton) dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton) self.__advancedFrame = dummyCollapsibleButton label = qt.QLabel('Frame identifying DICOM tag (if known):') self.__dicomTag = qt.QLineEdit() self.__dicomTag.text = 'NA' dummyFormLayout.addRow(label, self.__dicomTag) label = qt.QLabel('Frame identifying units:') self.__veLabel = qt.QLineEdit() self.__veLabel.text = 'na' dummyFormLayout.addRow(label, self.__veLabel) label = qt.QLabel('Initial value:') self.__veInitial = qt.QDoubleSpinBox() self.__veInitial.value = 0 dummyFormLayout.addRow(label, self.__veInitial) label = qt.QLabel('Step:') self.__veStep = qt.QDoubleSpinBox() self.__veStep.value = 1 dummyFormLayout.addRow(label, self.__veStep) label = qt.QLabel('EchoTime:') self.__te = qt.QDoubleSpinBox() self.__te.value = 1 dummyFormLayout.addRow(label, self.__te) label = qt.QLabel('RepetitionTime:') self.__tr = qt.QDoubleSpinBox() self.__tr.value = 1 dummyFormLayout.addRow(label, self.__tr) label = qt.QLabel('FlipAngle:') self.__fa = qt.QDoubleSpinBox() self.__fa.value = 1 dummyFormLayout.addRow(label, self.__fa) importButton = qt.QPushButton("Import") importButton.toolTip = "Import the contents of the directory as a MultiVolume" self.layout.addWidget(importButton) importButton.connect('clicked(bool)', self.onImportButtonClicked) self.__status = qt.QLabel('Status: Idle') self.layout.addWidget(self.__status) # Add vertical spacer self.layout.addStretch(1)
def createUserInterface(self): slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.NodeAddedEvent, self.onNodeAddedRemoved) slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.NodeRemovedEvent, self.onNodeAddedRemoved) rulers = slicer.util.getNodesByClass('vtkMRMLAnnotationRulerNode') for ruler in rulers: ruler.AddObserver('ModifiedEvent', self.rulerLengthCheck) ''' rs = slicer.mrmlScene.GetNodeByID('vtkMRMLAnnotationRulerNode1') rs.AddObserver('ModifiedEvent', a) ''' self.__layout = self.__parent.createUserInterface() #slicer.app.applicationLogic().PropagateVolumeSelection() #self.fiducialSelectionButton = slicer.qSlicerMouseModeToolBar() #self.fiducialSelectionButton.connect('mrmlSceneChanged(slicer.vtkMRMLScene*)', 'setMRMLScene(slicer.vtkMRMLScene*)') #buttonDescription = qt.QLabel('Click to Add Insertion Points to Scene:') #self.__layout.addRow(buttonDescription) #self.__layout.addRow(self.fiducialSelectionButton) #self.fiducialSelectionButton.setApplicationLogic(slicer.app.applicationLogic()) #self.fiducialSelectionButton.setMRMLScene(slicer.app.mrmlScene()) self.startMeasurements = qt.QPushButton("Start Measuring") self.startMeasurements.connect('clicked(bool)', self.startMeasure) #self.__layout.addWidget(self.startMeasurements) #self.stopMeasurements = qt.QPushButton("Stop Measuring") #self.stopMeasurements.connect('clicked(bool)', self.stop) #self.__layout.addWidget(self.stopMeasurements) #self.updateTable2 = qt.QPushButton("Update Table") #self.updateTable2.connect('clicked(bool)', self.updateTable) #self.__layout.addWidget(self.updateTable2) self.adjustFiducials = qt.QPushButton("Adjust Landmarks") self.adjustFiducials.connect('clicked(bool)', self.makeFidAdjustments) self.crosshair = qt.QPushButton("Hide Crosshair") self.crosshair.connect('clicked(bool)', self.crosshairVisible) buttonLayout = qt.QHBoxLayout() buttonLayout.addWidget(self.startMeasurements) #buttonLayout.addWidget(self.stopMeasurements) #buttonLayout.addWidget(self.updateTable2) self.__layout.addRow(buttonLayout) buttonLayout2 = qt.QHBoxLayout() buttonLayout2.addWidget(self.adjustFiducials) buttonLayout2.addWidget(self.crosshair) self.__layout.addRow(buttonLayout2) self.fiducial = self.fiducialNode() self.fidNumber = self.fiducial.GetNumberOfFiducials() self.fidLabels = [] self.fidLevels = [] self.fidSides = [] self.oldPosition = 0 ''' for i in range(0,self.fidNumber): self.fidLabels.append(slicer.modules.PedicleScrewSimulatorWidget.landmarksStep.table2.item(i,0).text()) self.fidLevels.append(slicer.modules.PedicleScrewSimulatorWidget.landmarksStep.table2.cellWidget(i,1).currentText) self.fidSides.append(slicer.modules.PedicleScrewSimulatorWidget.landmarksStep.table2.cellWidget(i,2).currentText) #self.fidLabels.append(self.fiducial.GetNthFiducialLabel(i)) #position = [0,0,0] #self.fiducial.GetNthFiducialPosition(i,position) #self.fidPositions.append(position) ''' logging.debug(self.fidLabels) logging.debug(self.fidLevels) logging.debug(self.fidSides) #self.levels = ("C1","C2","C3","C4","C5","C6","C7","T1","T2","T3","T4","T5","T6","T7","T8","T9","T10","T11","T12","L1", "L2", "L3", "L4", "L5","S1") #pNode = self.parameterNode() # Angle Table horizontalHeaders = [ "Fiducial", "Level", "Side", "Pedicle\n Length", "Pedicle\n Width" ] #self.vertebra = str(pNode.GetParameter('vertebra')) #self.inst_length = str(pNode.GetParameter('inst_length')) #logging.debug(self.vertebra) #logging.debug(self.inst_length) #self.levelselection = [] #for i in range(self.levels.index(self.vertebra),self.levels.index(self.vertebra)+int(self.inst_length)): # logging.debug(self.levels[i]) # self.levelselection.append(self.levels[i]) #logging.debug(self.levelselection) self.angleTable = qt.QTableWidget(self.fidNumber, 5) self.angleTable.sortingEnabled = False self.angleTable.setEditTriggers(1) self.angleTable.setMinimumHeight( self.angleTable.verticalHeader().length()) self.angleTable.horizontalHeader().setSectionResizeMode( qt.QHeaderView.Stretch) self.angleTable.setSizePolicy(qt.QSizePolicy.MinimumExpanding, qt.QSizePolicy.Preferred) self.angleTable.itemSelectionChanged.connect(self.onTableCellClicked) self.__layout.addWidget(self.angleTable) self.angleTable.setHorizontalHeaderLabels(horizontalHeaders) self.items = [] ''' for i in range(0,self.fidNumber): #logging.debug(self.levelselection[i] + "loop") Label = qt.QTableWidgetItem(str(self.fidLabels[i])) logging.debug(Label) Level = qt.QTableWidgetItem(str(self.fidLevels[i])) logging.debug(Level) Side = qt.QTableWidgetItem(str(self.fidSides[i])) logging.debug(Side) #self.items.append(Label) self.angleTable.setItem(i, 0, Label) self.angleTable.setItem(i, 1, Level) self.angleTable.setItem(i, 2, Side) ''' reconCollapsibleButton = ctk.ctkCollapsibleButton() reconCollapsibleButton.text = "Change Slice Reconstruction" self.__layout.addWidget(reconCollapsibleButton) reconCollapsibleButton.collapsed = True # Layout reconLayout = qt.QFormLayout(reconCollapsibleButton) #label for ROI selector reconLabel = qt.QLabel('Recon Slice:') rotationLabel = qt.QLabel('Rotation Angle:') #creates combobox and populates it with all vtkMRMLAnnotationROINodes in the scene self.selector = slicer.qMRMLNodeComboBox() self.selector.nodeTypes = ['vtkMRMLSliceNode'] self.selector.toolTip = "Change Slice Reconstruction" self.selector.setMRMLScene(slicer.mrmlScene) self.selector.addEnabled = 1 #add label + combobox reconLayout.addRow(reconLabel, self.selector) #self.reconSlice = slicer.qMRMLNodeComboBox() #self.recon = slicer.modules.reformat.createNewWidgetRepresentation() # pull slice selector #self.selector = self.recon.findChild('qMRMLNodeComboBox') #self.selector.setCurrentNodeID('vtkMRMLSliceNodeRed') #self.__layout.addWidget(self.selector) self.slider = ctk.ctkSliderWidget() #self.slider = PythonQt.qMRMLWidgets.qMRMLLinearTransformSlider() #tnode = slicer.mrmlScene.GetNodeByID('vtkMRMLLinearTransformNode1') #self.slider.setMRMLTransformNode(tnode) self.slider.connect('valueChanged(double)', self.sliderValueChanged) self.slider.minimum = -100 self.slider.maximum = 100 reconLayout.addRow(rotationLabel, self.slider) ''' # pull offset & rotation sliders self.reconButton = self.recon.findChild('ctkCollapsibleButton') self.reconProperties = self.reconButton.findChildren('ctkCollapsibleGroupBox') self.reconSpecificProperty1 = self.reconProperties[2] self.reconSlider1 = self.reconSpecificProperty1.findChildren('qMRMLLinearTransformSlider') self.slider = self.reconSlider1[0] self.reconSpecificProperty2 = self.reconProperties[0] self.reconSlider2 = self.reconSpecificProperty2.findChildren('qMRMLLinearTransformSlider') self.slider2 = self.reconSlider2[0] rText = qt.QLabel("Rotate Slice:") self.__layout.addWidget(rText) self.__layout.addWidget(self.slider) #tText = qt.QLabel("Translate Slice:") #self.__layout.addWidget(tText) #self.__layout.addWidget(self.slider2) ''' # self.updateWidgetFromParameters(self.parameterNode()) qt.QTimer.singleShot(0, self.killButton) self.updateTable()
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # input fiducial list selector # fiducialWarningLabel = qt.QLabel( "Note: Parent transforms of fiducials are not used. Fiducials should be defined in the coordinate system that is being registered." ) fiducialWarningLabel.setWordWrap(True) parametersFormLayout.addRow(fiducialWarningLabel) self.inputFiducialSelector = slicer.qMRMLNodeComboBox() self.inputFiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "") self.inputFiducialSelector.selectNodeUponCreation = True self.inputFiducialSelector.addEnabled = False self.inputFiducialSelector.removeEnabled = False self.inputFiducialSelector.noneEnabled = False self.inputFiducialSelector.showHidden = False self.inputFiducialSelector.showChildNodeTypes = False self.inputFiducialSelector.setMRMLScene(slicer.mrmlScene) self.inputFiducialSelector.setToolTip( "Pick the input fiducial list for the algorithm.") parametersFormLayout.addRow("Input fiducials: ", self.inputFiducialSelector) # # input model selector # self.inputModelSelector = slicer.qMRMLNodeComboBox() self.inputModelSelector.nodeTypes = (("vtkMRMLModelNode"), "") self.inputModelSelector.selectNodeUponCreation = True self.inputModelSelector.addEnabled = False self.inputModelSelector.removeEnabled = False self.inputModelSelector.noneEnabled = False self.inputModelSelector.showHidden = False self.inputModelSelector.showChildNodeTypes = False self.inputModelSelector.setMRMLScene(slicer.mrmlScene) self.inputModelSelector.setToolTip( "Pick the input model for the algorithm.") parametersFormLayout.addRow("Input model: ", self.inputModelSelector) # # output transform selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = (("vtkMRMLLinearTransformNode"), "") self.outputSelector.selectNodeUponCreation = True self.outputSelector.addEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.noneEnabled = False self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.renameEnabled = True self.outputSelector.setMRMLScene(slicer.mrmlScene) self.outputSelector.setToolTip("Pick the output to the algorithm.") parametersFormLayout.addRow("Output transform: ", self.outputSelector) # # check box to trigger taking screen shots for later use in tutorials # self.enableScreenshotsFlagCheckBox = qt.QCheckBox() self.enableScreenshotsFlagCheckBox.checked = 0 self.enableScreenshotsFlagCheckBox.setToolTip( "If checked, take screen shots for tutorials. Use Save Data to write them to disk." ) # parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox) # # scale factor for screen shots # self.screenshotScaleFactorSliderWidget = ctk.ctkSliderWidget() self.screenshotScaleFactorSliderWidget.singleStep = 1.0 self.screenshotScaleFactorSliderWidget.minimum = 1.0 self.screenshotScaleFactorSliderWidget.maximum = 50.0 self.screenshotScaleFactorSliderWidget.value = 1.0 self.screenshotScaleFactorSliderWidget.setToolTip( "Set scale factor for the screen shots.") # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # # Output panel # outputCollapsibleButton = ctk.ctkCollapsibleButton() outputCollapsibleButton.text = "Output" self.layout.addWidget(outputCollapsibleButton) outputFormLayout = qt.QFormLayout(outputCollapsibleButton) self.outputLine = qt.QLineEdit() self.outputLine.setReadOnly(True) outputFormLayout.addRow("Mean distance after registration:", self.outputLine) # # Advanced parameters # advancedCollapsibleButton = ctk.ctkCollapsibleButton() advancedCollapsibleButton.text = "Advanced" self.layout.addWidget(advancedCollapsibleButton) # Layout advancedCollapsibleButton.collapsed = True advancedFormLayout = qt.QFormLayout(advancedCollapsibleButton) # # Transform type selector # self.typeSelector = qt.QComboBox() self.typeSelector.insertItem(0, "Rigid") self.typeSelector.insertItem(1, "Similarity") self.typeSelector.insertItem(2, "Affine") advancedFormLayout.addRow("Transform type: ", self.typeSelector) # # Iteration selector # self.iterationSpin = qt.QSpinBox() self.iterationSpin.setMaximum(1000) self.iterationSpin.setValue(100) advancedFormLayout.addRow("Number of iterations:", self.iterationSpin) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.inputFiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1)
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) # # Place Sphere Button # self.placeSphereButton = qt.QPushButton() self.placeSphereButton.setText("Place Entry Point") self.placeSphereButton.setToolTip( "Place the entry point the robot is gonna be centered at.") parametersFormLayout.addRow(self.placeSphereButton) # # Sphere Radius Widget # self.sphereRadiusWidget = ctk.ctkSliderWidget() self.sphereRadiusWidget.singleStep = 1.0 self.sphereRadiusWidget.minimum = 1 self.sphereRadiusWidget.maximum = 100 self.sphereRadiusWidget.value = 40 self.sphereRadiusWidget.setToolTip("Set radius of the spherical ROI") parametersFormLayout.addRow("Sphere Radius", self.sphereRadiusWidget) # # Input Model # self.inputModel = slicer.qMRMLNodeComboBox() self.inputModel.nodeTypes = (("vtkMRMLModelNode"), "") self.inputModel.selectNodeUponCreation = True self.inputModel.addEnabled = False self.inputModel.removeEnabled = False self.inputModel.noneEnabled = False self.inputModel.showHidden = False self.inputModel.showChildNodeTypes = False self.inputModel.setMRMLScene(slicer.mrmlScene) self.inputModel.setToolTip("Pick the input model.") parametersFormLayout.addRow("Input Model: ", self.inputModel) # # Output Transform # self.outputTransform = slicer.qMRMLNodeComboBox() self.outputTransform.nodeTypes = (("vtkMRMLLinearTransformNode"), "") self.outputTransform.selectNodeUponCreation = True self.outputTransform.addEnabled = True self.outputTransform.renameEnabled = True self.outputTransform.removeEnabled = True self.outputTransform.noneEnabled = False self.outputTransform.showHidden = False self.outputTransform.showChildNodeTypes = False self.outputTransform.setMRMLScene(slicer.mrmlScene) self.outputTransform.setToolTip( "Pick the output transform of the algorithm.") parametersFormLayout.addRow("Output Transform: ", self.outputTransform) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.placeSphereButton.connect('clicked(bool)', self.onPlaceSphereButton) self.sphereRadiusWidget.connect('valueChanged(double)', self.onSphereRadiusChanged) self.outputTransform.connect('currentNodeChanged(vtkMRMLNode*)', self.checkConditions) self.inputModel.connect('currentNodeChanged(vtkMRMLNode*)', self.checkConditions) self.applyButton.connect('clicked(bool)', self.onApplyButton) # variables self.sphereMarkupList = None self.sphereModel = None # Add vertical spacer self.layout.addStretch(1)
def setup(self): # Instantiate and connect widgets ... # # Reload and Test area # reloadCollapsibleButton = ctk.ctkCollapsibleButton() reloadCollapsibleButton.text = "Reload && Test" self.layout.addWidget(reloadCollapsibleButton) reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) # reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "LungRegistration Reload" reloadFormLayout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # reload and test button # (use this during development, but remove it when delivering # your module to users) self.reloadAndTestButton = qt.QPushButton("Reload and Test") self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests." reloadFormLayout.addWidget(self.reloadAndTestButton) self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest) # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # input .vtk selector # self.inputVTKSelector = slicer.qMRMLNodeComboBox() self.inputVTKSelector.nodeTypes = ( ("vtkMRMLModelNode"), "" ) self.inputVTKSelector.selectNodeUponCreation = True self.inputVTKSelector.addEnabled = False self.inputVTKSelector.removeEnabled = False self.inputVTKSelector.noneEnabled = False self.inputVTKSelector.showHidden = False self.inputVTKSelector.showChildNodeTypes = False self.inputVTKSelector.setMRMLScene( slicer.mrmlScene ) self.inputVTKSelector.setToolTip( "Pick the input convex hull to the algorithm." ) parametersFormLayout.addRow("Input .vtk atlas convex hull: ", self.inputVTKSelector) #input CT image selector self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) #self.inputSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 0 ) self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = False self.inputSelector.setMRMLScene( slicer.mrmlScene ) self.inputSelector.setToolTip( "Pick the input to the algorithm." ) parametersFormLayout.addRow("Input volume: ", self.inputSelector) ## ## atlas volume selector ## self.atlasSelector = slicer.qMRMLNodeComboBox() self.atlasSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) #self.leftAtlasSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 1 ) self.atlasSelector.selectNodeUponCreation = True self.atlasSelector.addEnabled = False self.atlasSelector.removeEnabled = False self.atlasSelector.noneEnabled = False self.atlasSelector.showHidden = False self.atlasSelector.showChildNodeTypes = False self.atlasSelector.setMRMLScene( slicer.mrmlScene ) self.atlasSelector.setToolTip( "Pick the atlas volume." ) parametersFormLayout.addRow("Atlas Volume: ", self.atlasSelector) # ## ## right atlas volume selector ## #self.rightAtlasSelector = slicer.qMRMLNodeComboBox() #self.rightAtlasSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) ##self.rightAtlasSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 2 ) #self.rightAtlasSelector.selectNodeUponCreation = True #self.rightAtlasSelector.addEnabled = False #self.rightAtlasSelector.removeEnabled = False #self.rightAtlasSelector.noneEnabled = False #self.rightAtlasSelector.showHidden = False #self.rightAtlasSelector.showChildNodeTypes = False #self.rightAtlasSelector.setMRMLScene( slicer.mrmlScene ) #self.rightAtlasSelector.setToolTip( "Pick the atlas volume." ) #parametersFormLayout.addRow("right Atlas Volume: ", self.rightAtlasSelector) # # output volume selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" ) self.outputSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 0 ) self.outputSelector.selectNodeUponCreation = False self.outputSelector.addEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.noneEnabled = False self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.setMRMLScene( slicer.mrmlScene ) self.outputSelector.setToolTip( "Pick the output to the algorithm." ) parametersFormLayout.addRow("Output Volume: ", self.outputSelector) #Add parameters: self.numberOfIterations = qt.QSpinBox() self.numberOfIterations.setRange(1,1000000) self.numberOfIterations.setValue(200) self.numberOfIterations.setToolTip( "Specify the number of iterations to find the transformation." ) parametersFormLayout.addRow("Number of iterations (Registration part): ", self.numberOfIterations) self.boneThreshold = qt.QSpinBox() self.boneThreshold.setRange(1,1000000) self.boneThreshold.setValue(600) self.boneThreshold.setToolTip( "Threshold value for bone. Any voxel having HU intensity greater than or equal to this value will be considered bone and will be added to the fixed point set.." ) parametersFormLayout.addRow("Threshold value for bone (Registration part): ", self.boneThreshold) # # Apply Button # self.applyButton = qt.QPushButton("Register") self.applyButton.toolTip = "Run the registration algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.inputVTKSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.atlasSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.boneThreshold.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) #self.rightAtlasSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) #self.outModel.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) #self.numberOfIterations.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1)
def labelSelectDialog(self): """label table dialog""" if not self.labelSelect: self.labelSelect = qt.QFrame() self.labelSelect.setLayout(qt.QVBoxLayout()) self.labelPromptLabel = qt.QLabel() self.labelSelect.layout().addWidget(self.labelPromptLabel) self.labelSelectorFrame = qt.QFrame() self.labelSelectorFrame.setLayout(qt.QHBoxLayout()) self.labelSelect.layout().addWidget(self.labelSelectorFrame) self.labelSelectorLabel = qt.QLabel() self.labelPromptLabel.setText("Label Map: ") self.labelSelectorFrame.layout().addWidget(self.labelSelectorLabel) self.labelSelector = slicer.qMRMLNodeComboBox() self.labelSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "") self.labelSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", "1") # todo addAttribute self.labelSelector.selectNodeUponCreation = False self.labelSelector.addEnabled = False self.labelSelector.noneEnabled = False self.labelSelector.removeEnabled = False self.labelSelector.showHidden = False self.labelSelector.showChildNodeTypes = False self.labelSelector.setMRMLScene(slicer.mrmlScene) self.labelSelector.setToolTip("Pick the label map to edit") self.labelSelectorFrame.layout().addWidget(self.labelSelector) self.labelButtonFrame = qt.QFrame() self.labelButtonFrame.setLayout(qt.QHBoxLayout()) self.labelSelect.layout().addWidget(self.labelButtonFrame) self.labelDialogApply = qt.QPushButton("Apply", self.labelButtonFrame) self.labelDialogApply.setToolTip( "Use currently selected label node.") self.labelButtonFrame.layout().addWidget(self.labelDialogApply) self.labelDialogCancel = qt.QPushButton("Cancel", self.labelButtonFrame) self.labelDialogCancel.setToolTip("Cancel current operation.") self.labelButtonFrame.layout().addWidget(self.labelDialogCancel) self.labelButtonFrame.layout().addStretch(1) self.labelDialogCreate = qt.QPushButton("Create New...", self.labelButtonFrame) self.labelDialogCreate.setToolTip("Cancel current operation.") self.labelButtonFrame.layout().addWidget(self.labelDialogCreate) self.labelDialogApply.connect("clicked()", self.onLabelDialogApply) self.labelDialogCancel.connect("clicked()", self.labelSelect.hide) self.labelDialogCreate.connect("clicked()", self.onLabelDialogCreate) self.labelPromptLabel.setText( "Select existing label map volume to edit.") p = qt.QCursor().pos() self.labelSelect.setGeometry(p.x(), p.y(), 400, 200) self.labelSelect.show()
def setup(self): # # the grayscale volume selector # self.grayscaleSelectorFrame = qt.QFrame(self.parent) self.grayscaleSelectorFrame.setLayout(qt.QHBoxLayout()) self.parent.layout().addWidget(self.grayscaleSelectorFrame) self.grayscaleSelectorLabel = qt.QLabel("Grayscale Volume: ", self.grayscaleSelectorFrame) self.grayscaleSelectorLabel.setToolTip( "Select the grayscale volume (background grayscale scalar volume node) for statistics calculations" ) self.grayscaleSelectorFrame.layout().addWidget( self.grayscaleSelectorLabel) self.grayscaleSelector = slicer.qMRMLNodeComboBox( self.grayscaleSelectorFrame) self.grayscaleSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.grayscaleSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", 0) self.grayscaleSelector.selectNodeUponCreation = False self.grayscaleSelector.addEnabled = False self.grayscaleSelector.removeEnabled = False self.grayscaleSelector.noneEnabled = True self.grayscaleSelector.showHidden = False self.grayscaleSelector.showChildNodeTypes = False self.grayscaleSelector.setMRMLScene(slicer.mrmlScene) # TODO: need to add a QLabel # self.grayscaleSelector.SetLabelText( "Master Volume:" ) self.grayscaleSelectorFrame.layout().addWidget(self.grayscaleSelector) # # the label volume selector # self.labelSelectorFrame = qt.QFrame() self.labelSelectorFrame.setLayout(qt.QHBoxLayout()) self.parent.layout().addWidget(self.labelSelectorFrame) self.labelSelectorLabel = qt.QLabel() self.labelSelectorLabel.setText("Label Map: ") self.labelSelectorFrame.layout().addWidget(self.labelSelectorLabel) self.labelSelector = slicer.qMRMLNodeComboBox() self.labelSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "") self.labelSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", "1") # todo addAttribute self.labelSelector.selectNodeUponCreation = False self.labelSelector.addEnabled = False self.labelSelector.noneEnabled = True self.labelSelector.removeEnabled = False self.labelSelector.showHidden = False self.labelSelector.showChildNodeTypes = False self.labelSelector.setMRMLScene(slicer.mrmlScene) self.labelSelector.setToolTip("Pick the label map to edit") self.labelSelectorFrame.layout().addWidget(self.labelSelector) # Apply button self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Calculate Statistics." self.applyButton.enabled = False self.parent.layout().addWidget(self.applyButton) # model and view for stats table self.view = qt.QTableView() self.view.sortingEnabled = True self.parent.layout().addWidget(self.view) # Chart button self.chartFrame = qt.QFrame() self.chartFrame.setLayout(qt.QHBoxLayout()) self.parent.layout().addWidget(self.chartFrame) self.chartButton = qt.QPushButton("Chart") self.chartButton.toolTip = "Make a chart from the current statistics." self.chartFrame.layout().addWidget(self.chartButton) self.chartOption = qt.QComboBox() self.chartOption.addItems(self.chartOptions) self.chartFrame.layout().addWidget(self.chartOption) self.chartIgnoreZero = qt.QCheckBox() self.chartIgnoreZero.setText('Ignore Zero') self.chartIgnoreZero.checked = False self.chartIgnoreZero.setToolTip( 'Do not include the zero index in the chart to avoid dwarfing other bars' ) self.chartFrame.layout().addWidget(self.chartIgnoreZero) self.chartFrame.enabled = False # Save button self.saveButton = qt.QPushButton("Save") self.saveButton.toolTip = "Calculate Statistics." self.saveButton.enabled = False self.parent.layout().addWidget(self.saveButton) # Add vertical spacer self.parent.layout().addStretch(1) # connections self.applyButton.connect('clicked()', self.onApply) self.chartButton.connect('clicked()', self.onChart) self.saveButton.connect('clicked()', self.onSave) self.grayscaleSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onGrayscaleSelect) self.labelSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onLabelSelect)
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.inputModelSelector = slicer.qMRMLNodeComboBox() self.inputModelSelector.nodeTypes = [ "vtkMRMLModelNode" ] self.inputModelSelector.addEnabled = False self.inputModelSelector.removeEnabled = True self.inputModelSelector.renameEnabled = True self.inputModelSelector.noneEnabled = False self.inputModelSelector.showHidden = False self.inputModelSelector.showChildNodeTypes = False self.inputModelSelector.setMRMLScene( slicer.mrmlScene ) self.inputModelSelector.setToolTip( "Model node containing geometry and texture coordinates." ) parametersFormLayout.addRow("Model: ", self.inputModelSelector) #input texture selector self.inputTextureSelector = slicer.qMRMLNodeComboBox() self.inputTextureSelector.nodeTypes = [ "vtkMRMLVectorVolumeNode" ] self.inputTextureSelector.addEnabled = False self.inputTextureSelector.removeEnabled = True self.inputTextureSelector.renameEnabled = True self.inputTextureSelector.noneEnabled = False self.inputTextureSelector.showHidden = False self.inputTextureSelector.showChildNodeTypes = False self.inputTextureSelector.setMRMLScene( slicer.mrmlScene ) self.inputTextureSelector.setToolTip( "Color image containing texture image." ) parametersFormLayout.addRow("Texture: ", self.inputTextureSelector) self.addColorAsPointAttributeComboBox = qt.QComboBox() self.addColorAsPointAttributeComboBox.addItem("disabled") self.addColorAsPointAttributeComboBox.addItem("separate scalars") self.addColorAsPointAttributeComboBox.addItem("single vector") self.addColorAsPointAttributeComboBox.setCurrentIndex(0) self.addColorAsPointAttributeComboBox.setToolTip("It is useful if further color-based filtering will be performed on the model.") parametersFormLayout.addRow("Save color information as point data: ", self.addColorAsPointAttributeComboBox) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Apply texture to selected model." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.inputTextureSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1) # Refresh Apply button state self.onSelect()
def setup(self): # Instantiate and connect widgets ScriptedLoadableModuleWidget.setup(self) self.connectorNodeObserverTagList = [] # Plus parameters plusParametersCollapsibleButton = ctk.ctkCollapsibleButton() plusParametersCollapsibleButton.text = "Plus parameters" plusParametersCollapsibleButton.collapsed = False self.layout.addWidget(plusParametersCollapsibleButton) plusParametersLayout = qt.QFormLayout(plusParametersCollapsibleButton) self.connectorNodeSelector = slicer.qMRMLNodeComboBox() self.connectorNodeSelector.nodeTypes = ["vtkMRMLIGTLConnectorNode"] self.connectorNodeSelector.setMRMLScene(slicer.mrmlScene) plusParametersLayout.addRow("Connector node:", self.connectorNodeSelector) self.deviceIDComboBox = qt.QComboBox() plusParametersLayout.addRow("Device ID:", self.deviceIDComboBox) # Ultrasound parameters ultrasoundParametersCollapsibleButton = ctk.ctkCollapsibleButton() ultrasoundParametersCollapsibleButton.text = "Ultrasound parameters" ultrasoundParametersCollapsibleButton.collapsed = False self.layout.addWidget(ultrasoundParametersCollapsibleButton) ultrasoundParametersLayout = qt.QFormLayout( ultrasoundParametersCollapsibleButton) self.depthSlider = slicer.qSlicerUltrasoundDoubleParameterSlider() self.depthSlider.setParameterName("DepthMm") self.depthSlider.setSuffix(" mm") self.depthSlider.setMinimum(10.0) self.depthSlider.setMaximum(150.0) self.depthSlider.setSingleStep(1.0) self.depthSlider.setPageStep(10.0) ultrasoundParametersLayout.addRow("Depth:", self.depthSlider) self.gainSlider = slicer.qSlicerUltrasoundDoubleParameterSlider() self.gainSlider.setParameterName("GainPercent") self.gainSlider.setSuffix("%") self.gainSlider.setMinimum(0.0) self.gainSlider.setMaximum(100.0) self.gainSlider.setSingleStep(1.0) self.gainSlider.setPageStep(10.0) ultrasoundParametersLayout.addRow("Gain:", self.gainSlider) self.frequencySlider = slicer.qSlicerUltrasoundDoubleParameterSlider() self.frequencySlider.setParameterName("FrequencyMhz") self.frequencySlider.setSuffix(" MHz") self.frequencySlider.setMinimum(2.0) self.frequencySlider.setMaximum(5.0) self.frequencySlider.setSingleStep(0.5) self.frequencySlider.setPageStep(1.0) ultrasoundParametersLayout.addRow("Frequency:", self.frequencySlider) self.dynamicRangeSlider = slicer.qSlicerUltrasoundDoubleParameterSlider( ) self.dynamicRangeSlider.setParameterName("DynRangeDb") self.dynamicRangeSlider.setSuffix(" dB") self.dynamicRangeSlider.setMinimum(10.0) self.dynamicRangeSlider.setMaximum(100.0) self.dynamicRangeSlider.setSingleStep(1.0) self.dynamicRangeSlider.setPageStep(10.0) ultrasoundParametersLayout.addRow("Dynamic Range:", self.dynamicRangeSlider) self.layout.addStretch(1) self.parameterWidgets = [ self.depthSlider, self.gainSlider, self.frequencySlider, self.dynamicRangeSlider, ] self.connectorNodeSelector.connect("nodeActivated(vtkMRMLNode*)", self.onConnectorNodeSelected) self.connectorNodeSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onConnectorNodeSelected) self.deviceIDComboBox.connect("currentIndexChanged(int)", self.onDeviceIdChanged) self.plusRemoteNode = slicer.mrmlScene.GetFirstNodeByClass( 'vtkMRMLPlusRemoteNode') if self.plusRemoteNode is None: self.plusRemoteNode = slicer.vtkMRMLPlusRemoteNode() self.plusRemoteNode.SetName("PlusRemoteNode") slicer.mrmlScene.AddNode(self.plusRemoteNode) self.plusRemoteNode.AddObserver( slicer.vtkMRMLPlusRemoteNode.DeviceIdsReceivedEvent, self.requestDeviceIDsCompleted) self.onConnectorNodeSelected(self.connectorNodeSelector.currentNode())
def setup(self): # Instantiate and connect widgets ... # # Reload and Test area # reloadCollapsibleButton = ctk.ctkCollapsibleButton() reloadCollapsibleButton.text = "Reload && Test" self.layout.addWidget(reloadCollapsibleButton) reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) # reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "ScriptedLoadableModuleTemplate Reload" reloadFormLayout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # reload and test button # (use this during development, but remove it when delivering # your module to users) self.reloadAndTestButton = qt.QPushButton("Reload and Test") self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests." reloadFormLayout.addWidget(self.reloadAndTestButton) self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest) # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # input volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.inputSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", 0) self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = False self.inputSelector.setMRMLScene(slicer.mrmlScene) self.inputSelector.setToolTip("Pick the input to the algorithm.") parametersFormLayout.addRow("Input Volume: ", self.inputSelector) # # output volume selector # self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.outputSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", 0) self.outputSelector.selectNodeUponCreation = False self.outputSelector.addEnabled = True self.outputSelector.removeEnabled = True self.outputSelector.noneEnabled = False self.outputSelector.showHidden = False self.outputSelector.showChildNodeTypes = False self.outputSelector.setMRMLScene(slicer.mrmlScene) self.outputSelector.setToolTip("Pick the output to the algorithm.") parametersFormLayout.addRow("Output Volume: ", self.outputSelector) # # 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)
def setup(self): ScriptedLoadableModuleWidget.setup(self) # Instantiate and connect widgets ... #-------------------------------------------------- # For debugging # # Reload and Test area reloadCollapsibleButton = ctk.ctkCollapsibleButton() reloadCollapsibleButton.text = "Reload && Test" self.layout.addWidget(reloadCollapsibleButton) reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) reloadCollapsibleButton.collapsed = True # reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "NeedleGuideTemlpate Reload" reloadFormLayout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # #-------------------------------------------------- # # Fiducial Node # fiducialsCollapsibleButton = ctk.ctkCollapsibleButton() fiducialsCollapsibleButton.text = "Fiducials" self.layout.addWidget(fiducialsCollapsibleButton) # Layout within the dummy collapsible button fiducialsFormLayout = qt.QFormLayout(fiducialsCollapsibleButton) # # Fiducial node selector # self.fiducialSelector = slicer.qMRMLNodeComboBox() self.fiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "") self.fiducialSelector.selectNodeUponCreation = True self.fiducialSelector.addEnabled = True self.fiducialSelector.removeEnabled = True self.fiducialSelector.noneEnabled = False self.fiducialSelector.renameEnabled = True self.fiducialSelector.showHidden = False self.fiducialSelector.showChildNodeTypes = False self.fiducialSelector.setMRMLScene(slicer.mrmlScene) self.fiducialSelector.setToolTip("Pick the input to the algorithm.") fiducialsFormLayout.addRow("Input Volume: ", self.fiducialSelector) # # Reconfigure Button # self.radiusEdit = qt.QDoubleSpinBox() self.radiusEdit.setMinimum(0.0) self.radiusEdit.setMaximum(500.0) self.radiusEdit.setSingleStep(0.5) self.radiusEdit.setValue(50) self.numFiducialsEdit = qt.QSpinBox() self.numFiducialsEdit.setMinimum(0) self.numFiducialsEdit.setMaximum(100) self.numFiducialsEdit.setSingleStep(1) self.numFiducialsEdit.setValue(5) fiducialsFormLayout.addRow("Radius (mm):", self.radiusEdit) fiducialsFormLayout.addRow("# of fiducials:", self.numFiducialsEdit) self.reconfigureButton = qt.QPushButton("Reconfigure Fiducials") self.reconfigureButton.toolTip = "Reconfigure fiducial frame" self.reconfigureButton.enabled = False fiducialsFormLayout.addRow(self.reconfigureButton) # # Test Area # testCollapsibleButton = ctk.ctkCollapsibleButton() testCollapsibleButton.text = "Test" self.layout.addWidget(testCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(testCollapsibleButton) # # input volume selector # self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "") self.inputSelector.selectNodeUponCreation = True self.inputSelector.addEnabled = False self.inputSelector.removeEnabled = False self.inputSelector.noneEnabled = False self.inputSelector.showHidden = False self.inputSelector.showChildNodeTypes = False self.inputSelector.setMRMLScene(slicer.mrmlScene) self.inputSelector.setToolTip("Pick the input to the algorithm.") parametersFormLayout.addRow("Input Fiducial: ", self.inputSelector) # # reference volume selector # self.referenceSelector = slicer.qMRMLNodeComboBox() self.referenceSelector.nodeTypes = (("vtkMRMLScalarVolumeNode"), "") self.referenceSelector.selectNodeUponCreation = False self.referenceSelector.addEnabled = True self.referenceSelector.removeEnabled = True self.referenceSelector.noneEnabled = False self.referenceSelector.showHidden = False self.referenceSelector.showChildNodeTypes = False self.referenceSelector.setMRMLScene(slicer.mrmlScene) self.referenceSelector.setToolTip( "Pick the reference to the algorithm.") parametersFormLayout.addRow("Reference Volume: ", self.referenceSelector) logFileLayout = qt.QHBoxLayout() self.logFileLineEdit = qt.QLineEdit() self.logFileLineEdit.text = '' self.logFileLineEdit.readOnly = True self.logFileLineEdit.frame = True self.logFileLineEdit.styleSheet = "QLineEdit { background:transparent; }" self.logFileLineEdit.cursor = qt.QCursor(qt.Qt.IBeamCursor) logFileLayout.addWidget(self.logFileLineEdit) self.logFileButton = qt.QPushButton("Choose File...") self.logFileButton.toolTip = "Choose log file from dialog box" logFileLayout.addWidget(self.logFileButton) parametersFormLayout.addRow("Log file:", logFileLayout) # # Apply Button # self.applyButton = qt.QPushButton("Apply") self.applyButton.toolTip = "Run the algorithm." self.applyButton.enabled = False parametersFormLayout.addRow(self.applyButton) # connections self.fiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onFiducialSelect) self.reconfigureButton.connect('clicked(bool)', self.onReconfigureButton) self.logFileButton.connect('clicked(bool)', self.onLogFileButton) self.applyButton.connect('clicked(bool)', self.onApplyButton) self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.referenceSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) # Add vertical spacer self.layout.addStretch(1) # Create logic self.logic = FiducialRegistrationTestLogic(None) # Enable buttons, if nodes are selected self.onSelect() self.onFiducialSelect()
def setup(self): # Instantiate and connect widgets ... # # Reload and Test area # reloadCollapsibleButton = ctk.ctkCollapsibleButton() reloadCollapsibleButton.text = "Reload && Test" #self.layout.addWidget(reloadCollapsibleButton) reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) # reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "CornerAnnotation Reload" #reloadFormLayout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # reload and test button # (use this during development, but remove it when delivering # your module to users) self.reloadAndTestButton = qt.QPushButton("Reload and Test") self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests." #reloadFormLayout.addWidget(self.reloadAndTestButton) self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest) # # Module Area # annotationCollapsibleButton = ctk.ctkCollapsibleButton() annotationCollapsibleButton.text = "Annotations" annotationCollapsibleButton.collapsed = False self.annotationList = annotationCollapsibleButton self.layout.addWidget(annotationCollapsibleButton) # Layout within the collapsible button annotationFormLayout = qt.QFormLayout(annotationCollapsibleButton) # # Transform matrix for left bottom annotation (vtkMRMLLinearTransformNode) # self.node1Selector = slicer.qMRMLNodeComboBox() #self.node1Selector.nodeTypes = ( ("vtkMRMLLinearTransformNode"), "" ) self.node1Selector.nodeTypes = [ 'vtkMRMLLinearTransformNode', 'vtkMRMLAnnotationTextNode' ] self.node1Selector.addEnabled = False self.node1Selector.removeEnabled = False self.node1Selector.noneEnabled = True self.node1Selector.showHidden = False self.node1Selector.showChildNodeTypes = False self.node1Selector.setMRMLScene(slicer.mrmlScene) # # Transform matrix for left upper annotation (vtkMRMLLinearTransformNode) # self.node2Selector = slicer.qMRMLNodeComboBox() self.node2Selector.nodeTypes = [ 'vtkMRMLLinearTransformNode', 'vtkMRMLAnnotationTextNode' ] self.node2Selector.addEnabled = False self.node2Selector.removeEnabled = False self.node2Selector.noneEnabled = True self.node2Selector.showHidden = False self.node2Selector.showChildNodeTypes = False self.node2Selector.setMRMLScene(slicer.mrmlScene) # # Transform matrix for left upper annotation (vtkMRMLLinearTransformNode) # self.node3Selector = slicer.qMRMLNodeComboBox() self.node3Selector.nodeTypes = [ 'vtkMRMLLinearTransformNode', 'vtkMRMLAnnotationTextNode' ] self.node3Selector.addEnabled = False self.node3Selector.removeEnabled = False self.node3Selector.noneEnabled = True self.node3Selector.showHidden = False self.node3Selector.showChildNodeTypes = False self.node3Selector.setMRMLScene(slicer.mrmlScene) # # Transform matrix for right upper annotation (vtkMRMLLinearTransformNode) # self.node4Selector = slicer.qMRMLNodeComboBox() self.node4Selector.nodeTypes = [ 'vtkMRMLLinearTransformNode', 'vtkMRMLAnnotationTextNode' ] self.node4Selector.addEnabled = False self.node4Selector.removeEnabled = False self.node4Selector.noneEnabled = True self.node4Selector.showHidden = False self.node4Selector.showChildNodeTypes = False self.node4Selector.setMRMLScene(slicer.mrmlScene) # # Check box for left bottom annotation # self.leftBottomCheckBox = ctk.ctkCheckBox() self.leftBottomCheckBox.text = "Enable" self.leftBottomCheckBox.enabled = True self.leftBottomCheckBox.checked = False # # Check box for displaying right upper annotation # self.leftBottomTextBox = qt.QLineEdit() self.leftBottomTextBox.enabled = True # # Check box for displaying left upper annotation # self.leftUpperCheckBox = ctk.ctkCheckBox() self.leftUpperCheckBox.text = "Enable" self.leftUpperCheckBox.enabled = True self.leftUpperCheckBox.checked = False # # Check box for displaying right upper annotation # self.leftUpperTextBox = qt.QLineEdit() self.leftUpperTextBox.enabled = True # # Check box for displaying right bottom annotation # self.rightBottomCheckBox = ctk.ctkCheckBox() self.rightBottomCheckBox.text = "Enable" self.rightBottomCheckBox.enabled = True self.rightBottomCheckBox.checked = False # # Check box for displaying right upper annotation # self.rightBottomTextBox = qt.QLineEdit() self.rightBottomTextBox.enabled = True # # Check box for displaying right upper annotation # self.rightUpperCheckBox = ctk.ctkCheckBox() self.rightUpperCheckBox.text = "Enable" self.rightUpperCheckBox.enabled = True self.rightUpperCheckBox.checked = False # # Check box for displaying right upper annotation # self.rightUpperTextBox = qt.QLineEdit() self.rightUpperTextBox.enabled = True self.textLable1 = qt.QLabel() self.textLable1.setText("Text:") self.textLable2 = qt.QLabel() self.textLable2.setText("Text:") self.textLable3 = qt.QLabel() self.textLable3.setText("Text:") self.textLable4 = qt.QLabel() self.textLable4.setText("Text:") self.leftUpperFrame = qt.QFrame() self.leftUpperLayout = qt.QHBoxLayout() self.leftUpperFrame.setLayout(self.leftUpperLayout) annotationFormLayout.addRow("Left Upper:", self.leftUpperFrame) self.leftBottomFrame = qt.QFrame() self.leftBottomLayout = qt.QHBoxLayout() self.leftBottomFrame.setLayout(self.leftBottomLayout) annotationFormLayout.addRow("Left Bottom:", self.leftBottomFrame) self.rightUpperFrame = qt.QFrame() self.rightUpperLayout = qt.QHBoxLayout() self.rightUpperFrame.setLayout(self.rightUpperLayout) annotationFormLayout.addRow("Right Upper:", self.rightUpperFrame) self.rightBottomFrame = qt.QFrame() self.rightBottomLayout = qt.QHBoxLayout() self.rightBottomFrame.setLayout(self.rightBottomLayout) annotationFormLayout.addRow("Right Bottom:", self.rightBottomFrame) self.leftUpperFrame.layout().addWidget(self.leftUpperCheckBox) self.leftUpperFrame.layout().addWidget(self.textLable2) self.leftUpperFrame.layout().addWidget(self.leftUpperTextBox) self.leftBottomFrame.layout().addWidget(self.leftBottomCheckBox) self.leftBottomFrame.layout().addWidget(self.textLable1) self.leftBottomFrame.layout().addWidget(self.leftBottomTextBox) self.rightUpperFrame.layout().addWidget(self.rightUpperCheckBox) self.rightUpperFrame.layout().addWidget(self.textLable4) self.rightUpperFrame.layout().addWidget(self.rightUpperTextBox) self.rightBottomFrame.layout().addWidget(self.rightBottomCheckBox) self.rightBottomFrame.layout().addWidget(self.textLable3) self.rightBottomFrame.layout().addWidget(self.rightBottomTextBox) # # Configuration Area # configurationCollapsibleButton = ctk.ctkCollapsibleButton() configurationCollapsibleButton.text = "Configurations" configurationCollapsibleButton.collapsed = False self.annotationList = configurationCollapsibleButton self.layout.addWidget(configurationCollapsibleButton) # Layout within the collapsible button configurationFormLayout = qt.QFormLayout( configurationCollapsibleButton) self.threeDViewCheckBox = ctk.ctkCheckBox() self.threeDViewCheckBox.text = "3D" self.threeDViewCheckBox.enabled = True self.threeDViewCheckBox.checked = True self.redViewCheckBox = ctk.ctkCheckBox() self.redViewCheckBox.text = "Red" self.redViewCheckBox.enabled = True self.redViewCheckBox.checked = False self.yellowViewCheckBox = ctk.ctkCheckBox() self.yellowViewCheckBox.text = "Yellow" self.yellowViewCheckBox.enabled = True self.yellowViewCheckBox.checked = False self.greenViewCheckBox = ctk.ctkCheckBox() self.greenViewCheckBox.text = "Green" self.greenViewCheckBox.enabled = True self.greenViewCheckBox.checked = False # view frame self.viewFrame = qt.QFrame(configurationCollapsibleButton) self.viewLayout = qt.QHBoxLayout() self.viewFrame.setLayout(self.viewLayout) configurationFormLayout.addRow("Display Panels:", self.viewFrame) self.viewFrame.layout().addWidget(self.threeDViewCheckBox) self.viewFrame.layout().addWidget(self.redViewCheckBox) self.viewFrame.layout().addWidget(self.yellowViewCheckBox) self.viewFrame.layout().addWidget(self.greenViewCheckBox) self.fontSizeLable = qt.QLabel() self.fontSizeLable.setText("Size:") # # Bold font check box for displaying right upper annotation # self.rightUpperBoldCheckBox = ctk.ctkCheckBox() self.rightUpperBoldCheckBox.text = "Bold" self.rightUpperBoldCheckBox.enabled = True self.rightUpperBoldCheckBox.checked = False # # Italic fong check box for displaying right upper annotation # self.rightUpperItalicCheckBox = ctk.ctkCheckBox() self.rightUpperItalicCheckBox.text = "Italic" self.rightUpperItalicCheckBox.enabled = True self.rightUpperItalicCheckBox.checked = False # # Shadow font check box for displaying right upper annotation # self.rightUpperShadowCheckBox = ctk.ctkCheckBox() self.rightUpperShadowCheckBox.text = "Shadow" self.rightUpperShadowCheckBox.enabled = True self.rightUpperShadowCheckBox.checked = False # # Font size slider # self.fontSizeSlider = ctk.ctkSliderWidget() self.fontSizeSlider.decimals = 0 self.fontSizeSlider.maximum = 200 self.fontSizeSlider.minimum = 0 self.fontSizeSlider.value = 20 self.fontSizeSlider.enabled = True self.fontBox = qt.QComboBox() self.fontBox.insertItem(0, "Arial", "Arial") self.fontBox.insertItem(1, "Courier", "Courier") self.fontBox.insertItem(2, "Times", "Times") self.fontBox.enabled = True configurationFormLayout.addRow("Font Family:", self.fontBox) self.rightUpperColorBox = ctk.ctkColorPickerButton() self.rightUpperColorBox.enabled = True self.rightUpperColorBox.setColor(qt.QColor(255, 0, 0)) configurationFormLayout.addRow("Font Color:", self.rightUpperColorBox) self.fontOpacitySlider = ctk.ctkSliderWidget() self.fontOpacitySlider.decimals = 0 self.fontOpacitySlider.maximum = 100 self.fontOpacitySlider.minimum = 0 self.fontOpacitySlider.value = 100 self.fontOpacitySlider.enabled = True configurationFormLayout.addRow("Font Opacity:", self.fontOpacitySlider) self.fontStyleFrame = qt.QFrame() self.fonstStyleLayout = qt.QHBoxLayout() self.fontStyleFrame.setLayout(self.fonstStyleLayout) configurationFormLayout.addRow("Font Style:", self.fontStyleFrame) self.fontStyleFrame.layout().addWidget(self.rightUpperBoldCheckBox) self.fontStyleFrame.layout().addWidget(self.rightUpperItalicCheckBox) self.fontStyleFrame.layout().addWidget(self.rightUpperShadowCheckBox) self.fontStyleFrame.layout().addWidget(self.fontSizeLable) self.fontStyleFrame.layout().addWidget(self.fontSizeSlider) # Timer start button self.timerStartButton = qt.QPushButton("Start") self.timerStartButton.toolTip = "Start timer" self.timerStartButton.name = "Start timer" # Timer stop button self.timerStopButton = qt.QPushButton("Stop") self.timerStopButton.toolTip = "Stop timer" self.timerStopButton.name = "Stop timer" # Timer reset button self.timerResetButton = qt.QPushButton("Reset") self.timerResetButton.toolTip = "Reset timer" self.timerResetButton.name = "Reset timer" self.timerFrame = qt.QFrame(configurationCollapsibleButton) self.timerLayout = qt.QHBoxLayout() self.timerFrame.setLayout(self.timerLayout) configurationFormLayout.addRow("Timer:", self.timerFrame) self.timerFrame.layout().addWidget(self.timerStartButton) self.timerFrame.layout().addWidget(self.timerStopButton) self.timerFrame.layout().addWidget(self.timerResetButton) configurationFormLayout.addRow("Node1: ", self.node1Selector) configurationFormLayout.addRow("Node2: ", self.node2Selector) configurationFormLayout.addRow("Node3: ", self.node3Selector) configurationFormLayout.addRow("Node4: ", self.node4Selector) self.timerStartButton.connect('clicked(bool)', self.onStartButton) self.timerStopButton.connect('clicked(bool)', self.onStopButton) self.timerResetButton.connect('clicked(bool)', self.onResetButton) self.fontOpacitySlider.connect('valueChanged(double)', self.fontOpacitySliderValueChanged) self.fontSizeSlider.connect('valueChanged(double)', self.fontSizeSliderValueChanged) self.rightUpperBoldCheckBox.connect('clicked(bool)', self.boldChanged) self.rightUpperItalicCheckBox.connect('clicked(bool)', self.italicChanged) self.rightUpperShadowCheckBox.connect('clicked(bool)', self.shadowChanged) self.rightUpperColorBox.connect('colorChanged(QColor)', self.fontColorChanged) self.rightUpperCheckBox.connect('clicked(bool)', self.onRightUpperCheckBox) self.rightBottomCheckBox.connect('clicked(bool)', self.onRightBottomCheckBox) self.leftUpperCheckBox.connect('clicked(bool)', self.onLeftUpperCheckBox) self.leftBottomCheckBox.connect('clicked(bool)', self.onLeftBottomCheckBox) self.rightUpperTextBox.connect('textEdited(QString)', self.editedRightUpperTextBox) self.rightBottomTextBox.connect('textEdited(QString)', self.editedRightBottomTextBox) self.leftUpperTextBox.connect('textEdited(QString)', self.editedLeftUpperTextBox) self.leftBottomTextBox.connect('textEdited(QString)', self.editedLeftBottomTextBox) self.threeDViewCheckBox.connect('clicked(bool)', self.onThreeDViewCheckBox) self.redViewCheckBox.connect('clicked(bool)', self.onRedViewCheckBox) self.yellowViewCheckBox.connect('clicked(bool)', self.onYellowViewCheckBox) self.greenViewCheckBox.connect('clicked(bool)', self.onGreenViewCheckBox) self.fontBox.connect('currentIndexChanged(int)', self.fontChanged) # Text property for corner annotation self.textProperty = vtk.vtkTextProperty() # Corner annotation function self.cornerAnnotationDisplay = vtk.vtkCornerAnnotation() self.cornerAnnotationDisplay.SetLinearFontScaleFactor(2) self.cornerAnnotationDisplay.SetNonlinearFontScaleFactor(1) self.cornerAnnotationDisplay.SetMaximumFontSize(20) self.cornerAnnotationDisplay.GetTextProperty().SetColor(1, 0, 0) # Addition of corner annotation function to three D render window layout = slicer.app.layoutManager() if layout != None: self.threeDRenderer = layout.activeThreeDRenderer() self.threeDRenderer.AddViewProp(self.cornerAnnotationDisplay) self.threeDRenderWindow = self.threeDRenderer.GetRenderWindow() self.threeDRenderWindow.Render() self.redRenderer = layout.sliceWidget('Red').sliceView( ).renderWindow().GetRenderers().GetFirstRenderer() self.redRenderWindow = self.redRenderer.GetRenderWindow() self.redRenderWindow.Render() self.yellowRenderer = layout.sliceWidget('Yellow').sliceView( ).renderWindow().GetRenderers().GetFirstRenderer() self.yellowRenderWindow = self.yellowRenderer.GetRenderWindow() self.yellowRenderWindow.Render() self.greenRenderer = layout.sliceWidget('Green').sliceView( ).renderWindow().GetRenderers().GetFirstRenderer() self.greenRenderWindow = self.greenRenderer.GetRenderWindow() self.greenRenderWindow.Render() # QTimer self.t = qt.QTimer() self.t.connect('timeout()', self.tCount) self.freq = 50 self.stopWatchTimer = qt.QTimer() self.stopWatchTimer.connect('timeout()', self.stopWatchTimerCount) self.timerCount = 0 self.timerFreq = 100 # Flags for displaying annotations self.rightUpperFlag = 0 self.rightBottomFlag = 0 self.leftUpperFlag = 0 self.leftBottomFlag = 0 self.timerStopFlag = 0 self.colorR = 0 self.colorG = 0 self.colorB = 0 self.rightUpperMessage = "" self.rightBottomMessage = "" self.leftUpperMessage = "" self.leftBottomMessage = "" self.rightUpperSource = "" self.rightBottomSource = "" self.leftUpperSource = "" self.leftBottomSource = "" import numpy self.row2 = numpy.zeros([10]) self.column2 = numpy.zeros([10]) self.stopWatchTimerStartFlag = 0 # Add vertical spacer self.layout.addStretch(1)
def open(self): # main dialog self.dialog = qt.QDialog(slicer.util.mainWindow()) self.dialog.setWindowTitle('Export to DICOM Study') self.dialog.setWindowModality(1) layout = qt.QVBoxLayout() self.dialog.setLayout(layout) self.studyLabel = qt.QLabel('Attach Data to Study: %s' % self.studyUID) layout.addWidget(self.studyLabel) # scene or volume option self.selectFrame = qt.QFrame(self.dialog) layout.addWidget(self.selectFrame) self.selectLayout = qt.QGridLayout() self.selectFrame.setLayout(self.selectLayout) self.exportScene = qt.QRadioButton("Export Entire Scene", self.selectFrame) self.exportScene.setToolTip( "Create a Slicer Data Bundle in a DICOM Private Creator\n(Only compatible with Slicer)" ) self.exportVolume = qt.QRadioButton("Export Selected Volume", self.selectFrame) self.exportVolume.setToolTip( "Create a compatible DICOM series of slice images") self.exportVolume.checked = True self.selectLayout.addWidget(self.exportScene, 0, 0) self.selectLayout.addWidget(self.exportVolume, 1, 0) self.exportScene.connect('toggled(bool)', self.onExportRadio) self.exportVolume.connect('toggled(bool)', self.onExportRadio) # select volume self.volumeSelector = slicer.qMRMLNodeComboBox(self.dialog) self.volumeSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "") self.volumeSelector.selectNodeUponCreation = False 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.setToolTip("Pick the label map to edit") self.selectLayout.addWidget(self.volumeSelector, 1, 1) # DICOM Parameters self.dicomFrame = qt.QFrame(self.dialog) self.dicomFormLayout = qt.QFormLayout() self.dicomFrame.setLayout(self.dicomFormLayout) self.dicomEntries = {} exporter = DICOMLib.DICOMExporter(self.studyUID) self.dicomParameters = exporter.parametersFromStudy() self.dicomParameters['Series Description'] = '3D Slicer Export' for label in self.dicomParameters.keys(): self.dicomEntries[label] = qt.QLineEdit() self.dicomEntries[label].text = self.dicomParameters[label] self.dicomFormLayout.addRow(label + ": ", self.dicomEntries[label]) layout.addWidget(self.dicomFrame) # button box bbox = qt.QDialogButtonBox(self.dialog) bbox.addButton(bbox.Ok) bbox.addButton(bbox.Cancel) bbox.connect('accepted()', self.onOk) bbox.connect('rejected()', self.onCancel) layout.addWidget(bbox) self.dialog.open()
def setup(self): # Instantiate and connect widgets ... # # Reload and Test area # ''' reloadCollapsibleButton = ctk.ctkCollapsibleButton() reloadCollapsibleButton.text = "Reload && Test" self.layout.addWidget(reloadCollapsibleButton) reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton) # reload button # (use this during development, but remove it when delivering # your module to users) self.reloadButton = qt.QPushButton("Reload") self.reloadButton.toolTip = "Reload this module." self.reloadButton.name = "ResectionVolume Reload" reloadFormLayout.addWidget(self.reloadButton) self.reloadButton.connect('clicked()', self.onReload) # reload and test button # (use this during development, but remove it when delivering # your module to users) self.reloadAndTestButton = qt.QPushButton("Reload and Test") self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests." reloadFormLayout.addWidget(self.reloadAndTestButton) self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest) ''' # # Parameters Area # parametersCollapsibleButton = ctk.ctkCollapsibleButton() parametersCollapsibleButton.text = "Parameters" self.layout.addWidget(parametersCollapsibleButton) # Layout within the dummy collapsible button parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton) # # Fiducial Selector # self.fiducialSelector = slicer.qMRMLNodeComboBox() self.fiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "") self.fiducialSelector.addEnabled = True self.fiducialSelector.removeEnabled = False self.fiducialSelector.noneEnabled = True self.fiducialSelector.showHidden = False self.fiducialSelector.renameEnabled = True self.fiducialSelector.showChildNodeTypes = False self.fiducialSelector.setMRMLScene(slicer.mrmlScene) self.fiducialSelector.setToolTip( "Select the fiducials to use for the resection area") parametersFormLayout.addRow("Fiducial points: ", self.fiducialSelector) # # Resection model Selector # self.modelSelector = slicer.qMRMLNodeComboBox() self.modelSelector.nodeTypes = (("vtkMRMLModelNode"), "") self.modelSelector.addEnabled = True self.modelSelector.removeEnabled = False self.modelSelector.noneEnabled = True self.modelSelector.showHidden = False self.modelSelector.renameEnabled = True self.modelSelector.selectNodeUponCreation = True self.modelSelector.showChildNodeTypes = False self.modelSelector.setMRMLScene(slicer.mrmlScene) self.modelSelector.setToolTip("Choose the resection area model.") parametersFormLayout.addRow("Resection area model: ", self.modelSelector) # # Generate Button # self.generateSurface = qt.QCheckBox() self.generateSurface.setToolTip("Generate the resection area surface") self.generateSurface.checked = 0 parametersFormLayout.addRow("Generate resection surface", self.generateSurface) # # Label Volume Selector # self.labelSelector = slicer.qMRMLNodeComboBox() self.labelSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "") self.labelSelector.addEnabled = False self.labelSelector.removeEnabled = False self.labelSelector.noneEnabled = True self.labelSelector.showHidden = False self.labelSelector.showChildNodeTypes = False self.labelSelector.setMRMLScene(slicer.mrmlScene) self.labelSelector.setToolTip("Choose the label map") parametersFormLayout.addRow("Label map: ", self.labelSelector) # # Initial Label Value Selector # self.initialLabelValueSelector = qt.QSpinBox() self.initialLabelValueSelector.setToolTip( "Choose the value within the label map to recolor using the resection area" ) self.initialLabelValueSelector.setValue(1) parametersFormLayout.addRow("Label value for recoloring", self.initialLabelValueSelector) # # Output Label Value Selector # self.outputLabelValueSelector = qt.QSpinBox() self.outputLabelValueSelector.setToolTip( "Choose the value to recolor the area within the resection to") parametersFormLayout.addRow("Label value for resection area", self.outputLabelValueSelector) # # Relabel button # self.recolorLabelButton = qt.QPushButton("Recolor label map") self.recolorLabelButton.toolTip = "Recolor the label map to create a new label for the resection area." self.recolorLabelButton.enabled = False parametersFormLayout.addRow(self.recolorLabelButton) # # Connections # self.generateSurface.connect('toggled(bool)', self.onGenerateSurface) self.fiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.modelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.labelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect) self.recolorLabelButton.connect('clicked(bool)', self.onRecolorLabelMap) # Add vertical spacer self.layout.addStretch(1)
def initRegistrationPanel(self): # Create collapsible Button for registration, transformix and invert transform self.registrationCollapsibleBtn = ctk.ctkCollapsibleButton() self.registrationCollapsibleBtn.setStyleSheet( "ctkCollapsibleButton { background-color: DarkSeaGreen }") self.registrationCollapsibleBtn.text = "ACIR: Automatic Cochlea Image Registration" self.layout.addWidget(self.registrationCollapsibleBtn) self.registrationFormLayout = qt.QFormLayout( self.registrationCollapsibleBtn) # Create fixed Volume Selector self.fixedSelectorCoBx = slicer.qMRMLNodeComboBox() self.fixedSelectorCoBx.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.fixedSelectorCoBx.selectNodeUponCreation = True self.fixedSelectorCoBx.addEnabled = False self.fixedSelectorCoBx.removeEnabled = False self.fixedSelectorCoBx.noneEnabled = False self.fixedSelectorCoBx.showHidden = False self.fixedSelectorCoBx.showChildNodeTypes = False self.fixedSelectorCoBx.setMRMLScene(slicer.mrmlScene) self.fixedSelectorCoBx.setToolTip("Pick the fixed volume") self.registrationFormLayout.addRow("Fixed Volume: ", self.fixedSelectorCoBx) # Create moving Volume Selector self.movingSelectorCoBx = slicer.qMRMLNodeComboBox() self.movingSelectorCoBx.nodeTypes = ["vtkMRMLScalarVolumeNode"] self.movingSelectorCoBx.selectNodeUponCreation = True self.movingSelectorCoBx.addEnabled = False self.movingSelectorCoBx.removeEnabled = False self.movingSelectorCoBx.noneEnabled = False self.movingSelectorCoBx.showHidden = False self.movingSelectorCoBx.showChildNodeTypes = False self.movingSelectorCoBx.setMRMLScene(slicer.mrmlScene) self.movingSelectorCoBx.setToolTip("Pick the moving volume") self.registrationFormLayout.addRow("Moving Volume: ", self.movingSelectorCoBx) # Create fixed Fiducial selector. The fixed input volume will be cropped around the chosen Fiducial. # The lambda function is useful to send which button pressed the function FiducialButtonClick # instead of having two functions self.fixedPoint = [0, 0, 0] self.fixedPointLbl = qt.QLineEdit() self.fixedPointLbl.setReadOnly( True) # The point can only be edited by placing a new Fiducial self.fixedPointLbl.setText(str(self.fixedPoint)) self.fixedFiducialBtn = qt.QPushButton( "Pick cochlea location in fixed image ") #self.fixedFiducialBtn.setFixedWidth(400) self.fixedFiducialBtn.setToolTip( "Pick the input fiducial point that will be the center of the cropped image" ) self.fixedFiducialBtn.connect( 'clicked(bool)', lambda: self.FiducialButtonClick("fixed")) self.registrationFormLayout.addRow(self.fixedFiducialBtn, self.fixedPointLbl) # Create moving Fiducial selector. The moving input volume will be cropped around the chosen Fiducial. self.movingPoint = [0, 0, 0] self.movingPointLbl = qt.QLineEdit() self.movingPointLbl.setReadOnly( True) # The point can only be edited by placing a new Fiducial self.movingPointLbl.setText(str(self.movingPoint)) self.movingFiducialBtn = qt.QPushButton( "Pick cochlea location in moving image") #self.movingFiducialBtn.setFixedWidth(400) self.movingFiducialBtn.setToolTip( "Pick the input fiducial point that will be the center of the cropped image" ) self.movingFiducialBtn.connect( 'clicked(bool)', lambda: self.FiducialButtonClick("moving")) self.registrationFormLayout.addRow(self.movingFiducialBtn, self.movingPointLbl) # Create and link Button to run the registration self.runBtn = qt.QPushButton("Run") self.runBtn.setFixedHeight(50) self.runBtn.setFixedWidth(250) self.runBtn.setStyleSheet( "QPushButton{ background-color: DarkSeaGreen }") self.runBtn.toolTip = ( 'How to use:' ' Load at least two images into Slicer. Pick cochlea locations using the buttons and the Slicer Fiducial tool ' ) self.runBtn.connect('clicked(bool)', self.runBtnClick) self.registrationFormLayout.addRow(self.runBtn, self.timeLbl) # Add time label self.timeLbl.setText(" Time: 00:00") self.registrationFormLayout.addWidget(qt.QLabel("")) # Spacer self.layout.addStretch( 1 ) # Collapsible button is held in place when collapsing/expanding.
def setup(self): # Collapsible button self.mascaraCollapsibleButton = ctk.ctkCollapsibleButton() self.mascaraCollapsibleButton.text = "Creacion de la Mascara Corteza derecha e izquierda" self.layout.addWidget(self.mascaraCollapsibleButton) # Creacion de el boton desplegable para la creacion de la mascara self.mascaraFormLayout = qt.QFormLayout(self.mascaraCollapsibleButton) #selector de imgen a partir de la cual se crea la mascara self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.objectName = 'Seleccionar imagen' self.inputSelector.toolTip = 'Seleccione la imagen de entrada' self.inputSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.inputSelector.noneEnabled = True self.inputSelector.addEnabled = False # Se quita la posibilidad al usuario de crear un nuevo nodo con este widget self.inputSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento self.inputSelector.setMRMLScene(slicer.mrmlScene) self.mascaraFormLayout.addRow("Imagen de entrada:", self.inputSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.inputSelector, 'setMRMLScene(vtkMRMLScene*)') #selector de imgen que que contendra la mascara self.outputSelector = slicer.qMRMLNodeComboBox() self.outputSelector.objectName = 'imagenSelector' self.outputSelector.toolTip = 'Seleccione la imagen que desea centrar' self.outputSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.outputSelector.noneEnabled = True self.outputSelector.addEnabled = True # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget self.outputSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento self.outputSelector.setMRMLScene(slicer.mrmlScene) self.mascaraFormLayout.addRow("Corteza cerebral derecha:", self.outputSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.outputSelector, 'setMRMLScene(vtkMRMLScene*)') self.petSelector = slicer.qMRMLNodeComboBox() self.petSelector.objectName = 'imagenSelector' self.petSelector.toolTip = 'Seleccione la imagen que desea centrar' self.petSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.petSelector.noneEnabled = True self.petSelector.addEnabled = True # Se quita la posibilidad al usuario de crear un nuevo nodo con este widget self.petSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento self.petSelector.setMRMLScene(slicer.mrmlScene) self.mascaraFormLayout.addRow("Imagen PET:", self.petSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.petSelector, 'setMRMLScene(vtkMRMLScene*)') self.mascaraDerechaSelector = slicer.qMRMLNodeComboBox() self.mascaraDerechaSelector.objectName = 'imagenSelector' self.mascaraDerechaSelector.toolTip = 'Seleccione la imagen que desea centrar' self.mascaraDerechaSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.mascaraDerechaSelector.noneEnabled = True self.mascaraDerechaSelector.addEnabled = True # Se quita la posibilidad al usuario de crear un nuevo nodo con este widget self.mascaraDerechaSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento self.mascaraDerechaSelector.setMRMLScene(slicer.mrmlScene) self.mascaraFormLayout.addRow("Corteza derecha-mascara:", self.mascaraDerechaSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.mascaraDerechaSelector, 'setMRMLScene(vtkMRMLScene*)') self.mascaraIzquierdaSelector = slicer.qMRMLNodeComboBox() self.mascaraIzquierdaSelector.objectName = 'imagenSelector' self.mascaraIzquierdaSelector.toolTip = 'Seleccione la imagen que desea centrar' self.mascaraIzquierdaSelector.nodeTypes = ['vtkMRMLScalarVolumeNode'] self.mascaraIzquierdaSelector.noneEnabled = True self.mascaraIzquierdaSelector.addEnabled = True # Se quita la posibilidad al usuario de crear un nuevo nodo con este widget self.mascaraIzquierdaSelector.removeEnabled = False # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento self.mascaraIzquierdaSelector.setMRMLScene(slicer.mrmlScene) self.mascaraFormLayout.addRow("Corteza izquierda-mascara:", self.mascaraIzquierdaSelector) self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.mascaraIzquierdaSelector, 'setMRMLScene(vtkMRMLScene*)') # Crear button mascaraDerechaButton = qt.QPushButton("Crear mascara corteza derecha") self.mascaraFormLayout.addWidget(mascaraDerechaButton) mascaraDerechaButton.connect('clicked(bool)', self.CrearDerecha) # Add vertical spacer self.layout.addStretch(1) # Set local var as instance attribute self.mascaraDerechaButton = mascaraDerechaButton # Crear button mascaraIzquierdaButton = qt.QPushButton( "Crear mascara corteza izquierda") self.mascaraFormLayout.addWidget(mascaraIzquierdaButton) mascaraIzquierdaButton.connect('clicked(bool)', self.CrearIzquierda) # Add vertical spacer self.layout.addStretch(1) # Set local var as instance attribute self.mascaraIzquierdaButton = mascaraIzquierdaButton
def setup(self): ScriptedLoadableModuleWidget.setup(self) # TODO: The following lines are strictly for debug purposes, should be removed when this module is done self.developerMode = True slicer.igwidget = self self.logic = InsertionGridPlannerLogic() # Collapsible buttons self.parametersCollapsibleButton = ctk.ctkCollapsibleButton() self.parametersCollapsibleButton.text = "InsertionGridPlanner" self.layout.addWidget(self.parametersCollapsibleButton) # Layout within the collapsible button self.parametersFormLayout = qt.QFormLayout( self.parametersCollapsibleButton) # Transform Tool Tip To Reference combobox self.transformNodeGridToTargetLabel = qt.QLabel() self.transformNodeGridToTargetLabel.setText( "Grid to Target Transform: ") self.transformNodeGridToTargetSelector = slicer.qMRMLNodeComboBox() self.transformNodeGridToTargetSelector.nodeTypes = (( "vtkMRMLLinearTransformNode"), "") self.transformNodeGridToTargetSelector.noneEnabled = False self.transformNodeGridToTargetSelector.addEnabled = False self.transformNodeGridToTargetSelector.removeEnabled = False self.transformNodeGridToTargetSelector.setMRMLScene(slicer.mrmlScene) self.transformNodeGridToTargetSelector.setToolTip( "Pick the transform for going from the grid's coordinate system to the target (reference) coordinate system" ) self.parametersFormLayout.addRow( self.transformNodeGridToTargetLabel, self.transformNodeGridToTargetSelector) # Grid type self.gridPatternRectangularLabel = qt.QLabel(qt.Qt.Horizontal, None) self.gridPatternRectangularLabel.setText("Rectangular Grid") self.gridPatternRectangularRadioButton = qt.QRadioButton() self.gridPatternRectangularRadioButton.setToolTip( "Make the grid rectangular") self.gridPatternRectangularRadioButton.setChecked(True) self.parametersFormLayout.addRow( self.gridPatternRectangularLabel, self.gridPatternRectangularRadioButton) self.gridPatternTriangularLabel = qt.QLabel(qt.Qt.Horizontal, None) self.gridPatternTriangularLabel.setText("Triangular Grid") self.gridPatternTriangularRadioButton = qt.QRadioButton() self.gridPatternTriangularRadioButton.setToolTip( "Make the grid triangular") self.parametersFormLayout.addRow(self.gridPatternTriangularLabel, self.gridPatternTriangularRadioButton) # Grid size self.gridSizeLeftLabel = qt.QLabel() self.gridSizeLeftLabel.setText("Extent left (mm): ") self.gridSizeLeftSlider = slicer.qMRMLSliderWidget() self.gridSizeLeftSlider.minimum = 0 # mm self.gridSizeLeftSlider.maximum = 150 # mm self.gridSizeLeftSlider.value = 0 # mm self.gridSizeLeftSlider.setToolTip("Adjust the size of the grid") self.parametersFormLayout.addRow(self.gridSizeLeftLabel, self.gridSizeLeftSlider) self.gridSizeRightLabel = qt.QLabel() self.gridSizeRightLabel.setText("Extent right (mm): ") self.gridSizeRightSlider = slicer.qMRMLSliderWidget() self.gridSizeRightSlider.minimum = 0 # mm self.gridSizeRightSlider.maximum = 150 # mm self.gridSizeRightSlider.value = 0 # mm self.gridSizeRightSlider.setToolTip("Adjust the size of the grid") self.parametersFormLayout.addRow(self.gridSizeRightLabel, self.gridSizeRightSlider) self.gridSizeUpLabel = qt.QLabel() self.gridSizeUpLabel.setText("Extent up (mm): ") self.gridSizeUpSlider = slicer.qMRMLSliderWidget() self.gridSizeUpSlider.minimum = 0 # mm self.gridSizeUpSlider.maximum = 150 # mm self.gridSizeUpSlider.value = 0 # mm self.gridSizeUpSlider.setToolTip("Adjust the size of the grid") self.parametersFormLayout.addRow(self.gridSizeUpLabel, self.gridSizeUpSlider) self.gridSizeDownLabel = qt.QLabel() self.gridSizeDownLabel.setText("Extent down (mm): ") self.gridSizeDownSlider = slicer.qMRMLSliderWidget() self.gridSizeDownSlider.minimum = 0 # mm self.gridSizeDownSlider.maximum = 150 # mm self.gridSizeDownSlider.value = 0 # mm self.gridSizeDownSlider.setToolTip("Adjust the size of the grid") self.parametersFormLayout.addRow(self.gridSizeDownLabel, self.gridSizeDownSlider) # Grid spacing self.gridSpacingHorizontalLabel = qt.QLabel(qt.Qt.Horizontal, None) self.gridSpacingHorizontalLabel.text = "Horizontal Spacing (mm): " self.gridSpacingHorizontalSlider = slicer.qMRMLSliderWidget() self.gridSpacingHorizontalSlider.minimum = 1 # mm self.gridSpacingHorizontalSlider.maximum = 50 # mm self.gridSpacingHorizontalSlider.value = 10 # mm self.parametersFormLayout.addRow(self.gridSpacingHorizontalLabel, self.gridSpacingHorizontalSlider) self.gridSpacingVerticalLabel = qt.QLabel(qt.Qt.Horizontal, None) self.gridSpacingVerticalLabel.text = "Vertical Spacing (mm): " self.gridSpacingVerticalSlider = slicer.qMRMLSliderWidget() self.gridSpacingVerticalSlider.minimum = 1 # mm self.gridSpacingVerticalSlider.maximum = 50 # mm self.gridSpacingVerticalSlider.value = 10 # mm self.parametersFormLayout.addRow(self.gridSpacingVerticalLabel, self.gridSpacingVerticalSlider) # Grid creation self.createGridButton = qt.QPushButton() self.createGridButton.text = "Create Grid" self.createGridButton.setToolTip("Create the virtual grid guide.") self.parametersFormLayout.addRow(self.createGridButton) self.deleteGridButton = qt.QPushButton() self.deleteGridButton.text = "Delete Grid" self.deleteGridButton.setToolTip("Delete the virtual grid guide.") self.parametersFormLayout.addRow(self.deleteGridButton) # Add vertical spacer self.layout.addStretch(1) #Connections self.createGridButton.connect('clicked()', self.createGridButtonPressed) self.deleteGridButton.connect('clicked()', self.logic.deleteGrid)
def setup(self): ScriptedLoadableModuleWidget.setup(self) #### Collapsible Button --- montage self.finalizerCBSave = ctk.ctkCollapsibleButton() self.finalizerCBSave.text = "1. Montage" self.finalizerCBSave.contentsLineWidth = 1 self.layout.addWidget(self.finalizerCBSave) #### Collapsible Button layout self.finalizerFLSave = qt.QFormLayout(self.finalizerCBSave) self.tableBox = slicer.qMRMLNodeComboBox() self.tableBox.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "") self.tableBox.selectNodeUponCreation = False self.tableBox.addEnabled = False self.tableBox.removeEnabled = False self.tableBox.noneEnabled = True self.tableBox.setMRMLScene(slicer.mrmlScene) self.tableBox.setToolTip("Select a fiducial list") # Create montage files # NOTE: TODO fix this using qSlicerDataDialog i.e. add the 21E file format # to the supported file formats in slicer, implement a reader that converts the # 21E to a markup fiducial list. self.channelFileTB = qt.QToolButton() self.channelFileTB.setText("...") self.channelFileTB.toolTip = "Channel File" self.channelFileTB.enabled = True self.channelFileTB.connect('clicked(bool)', self.onChannelFileTB) #### Line Edit button, where the executable path is shown self.channelFileLE = qt.QLineEdit() self.channelFileLE.setDisabled(True) self.channelFileLE.setMaximumWidth(200) self.channelFileLE.setFixedWidth(300) badChannelList = slicer.qSlicerSimpleMarkupsWidget() badChannelList.setMRMLScene(slicer.mrmlScene) badChannelList.setCurrentNode(slicer.util.getNode('recon')) self.finalizerFLSave.addWidget(badChannelList) #### Buttons Layout self.channelFileHBL = qt.QHBoxLayout() self.channelFileHBL.addWidget(self.channelFileLE) self.channelFileHBL.addWidget(self.channelFileTB) self.saveMontagePB = qt.QPushButton("Save Montage") self.saveMontagePB.toolTip = "Save Montage" self.saveMontagePB.enabled = False self.saveMontagePB.connect('clicked(bool)', self.onSaveMontageClick) self.createMontagePB = qt.QPushButton("Create Montage") self.createMontagePB.toolTip = "Create Montage" self.createMontagePB.enabled = True self.createMontagePB.connect('clicked(bool)', self.onMontageCreation) self.finalizerFLSave.addRow(self.channelFileHBL) self.finalizerFLSave.addWidget(self.tableBox) self.finalizerFLSave.addWidget(self.createMontagePB) self.finalizerFLSave.addWidget(self.saveMontagePB) #### Collapsible Button --- Split Fiducial self.finalizerCBSplit = ctk.ctkCollapsibleButton() self.finalizerCBSplit.text = "2. Split Fiducials" self.finalizerCBSplit.contentsLineWidth = 1 self.layout.addWidget(self.finalizerCBSplit) #### Collapsible Button layout self.finalizerFLSplit = qt.QFormLayout(self.finalizerCBSplit) # SPLIT Fiducial Combobox self.fiducialSplitBox = slicer.qMRMLNodeComboBox() self.fiducialSplitBox.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "") self.fiducialSplitBox.selectNodeUponCreation = False self.fiducialSplitBox.addEnabled = False self.fiducialSplitBox.removeEnabled = False self.fiducialSplitBox.noneEnabled = True self.fiducialSplitBox.setMRMLScene(slicer.mrmlScene) self.fiducialSplitBox.setToolTip("Select a fiducial list") # SPLIT Fiducials Button self.splitFiducialPB = qt.QPushButton("Split Fiducial List") self.splitFiducialPB.toolTip = "Split Fiducial file, one for each electrode" self.splitFiducialPB.enabled = True self.splitFiducialPB.connect('clicked(bool)', self.onsplitFiducialClick) self.finalizerFLSplit.addWidget(self.fiducialSplitBox) self.finalizerFLSplit.addWidget(self.splitFiducialPB) # Collapsible Button Layout - Report self.finalizerCBDoc = ctk.ctkCollapsibleButton() self.finalizerCBDoc.text = "3. Report" self.finalizerCBDoc.contentsLineWidth = 1 self.layout.addWidget(self.finalizerCBDoc)
def setup(self): ScriptedLoadableModuleWidget.setup(self) pointSetProcessingCollapsibleButton = ctk.ctkCollapsibleButton() pointSetProcessingCollapsibleButton.text = "Surface Reconstruction from Unorganized Points" self.layout.addWidget(pointSetProcessingCollapsibleButton) pointSetProcessingFormLayout = qt.QFormLayout( pointSetProcessingCollapsibleButton) # Input self.inputSelector = slicer.qMRMLNodeComboBox() self.inputSelector.nodeTypes = (("vtkMRMLModelNode"), "") 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.") pointSetProcessingFormLayout.addRow("Input Model: ", self.inputSelector) self.nbrOfPointsLabel = qt.QLabel( 'Number of Points in Input Model: - ') pointSetProcessingFormLayout.addRow(self.nbrOfPointsLabel) self.inputPointSizeSlider = ctk.ctkSliderWidget() self.inputPointSizeSlider.setDecimals(0) self.inputPointSizeSlider.singleStep = 1 self.inputPointSizeSlider.minimum = 1 self.inputPointSizeSlider.maximum = 10 self.inputPointSizeSlider.value = 1 pointSetProcessingFormLayout.addRow('Input Model Point Size: ', self.inputPointSizeSlider) # Runtime self.runtimeGroupBox = qt.QGroupBox('Runtime') runtimeFormLayout = qt.QFormLayout(self.runtimeGroupBox) pointSetProcessingFormLayout.addRow(self.runtimeGroupBox) self.runtimeLabel = qt.QLabel() self.runtimeLabel.setText("... s.") self.runtimeLabel.setWordWrap(True) self.runtimeLabel.setStyleSheet("QLabel { background-color : black; \ color : #66FF00; \ height : 60px; \ border-style: outset; \ border-width: 5px; \ border-radius: 10px; \ font: bold 14px; \ padding: 0px;\ font-family : SimSun; \ qproperty-alignment: AlignCenter}") runtimeFormLayout.addRow(self.runtimeLabel) # Downsample self.downSampleGroupBox = ctk.ctkCollapsibleGroupBox() self.downSampleGroupBox.setTitle("Downsample Input Model") downSampleFormLayout = qt.QFormLayout(self.downSampleGroupBox) pointSetProcessingFormLayout.addRow(self.downSampleGroupBox) self.toleranceCleanSlider = ctk.ctkSliderWidget() self.toleranceCleanSlider.setDecimals(2) self.toleranceCleanSlider.singleStep = 0.01 self.toleranceCleanSlider.minimum = 0.0 self.toleranceCleanSlider.maximum = 1.0 self.toleranceCleanSlider.value = 0.01 self.toleranceCleanSlider.setToolTip('') self.toleranceCleanSlider.enabled = True downSampleFormLayout.addRow('Tolerance: ', self.toleranceCleanSlider) self.vtkCleanPolyDataButton = qt.QPushButton("Apply") self.vtkCleanPolyDataButton.enabled = False self.vtkCleanPolyDataButton.checkable = True downSampleFormLayout.addRow(self.vtkCleanPolyDataButton) # Outlier Removal self.outlierRemovalGroupBox = ctk.ctkCollapsibleGroupBox() self.outlierRemovalGroupBox.setTitle("Outlier Removal") outlierRemovalFormLayout = qt.QFormLayout(self.outlierRemovalGroupBox) pointSetProcessingFormLayout.addRow(self.outlierRemovalGroupBox) self.percentToRemoveSlider = ctk.ctkSliderWidget() self.percentToRemoveSlider.setDecimals(2) self.percentToRemoveSlider.singleStep = 0.01 self.percentToRemoveSlider.minimum = 0.0 self.percentToRemoveSlider.maximum = 1.0 self.percentToRemoveSlider.value = 0.01 self.percentToRemoveSlider.setToolTip('') self.percentToRemoveSlider.enabled = True outlierRemovalFormLayout.addRow('Percent to Remove: ', self.percentToRemoveSlider) self.vtkPointSetOutlierRemovalButton = qt.QPushButton("Apply") self.vtkPointSetOutlierRemovalButton.enabled = False self.vtkPointSetOutlierRemovalButton.checkable = True outlierRemovalFormLayout.addRow(self.vtkPointSetOutlierRemovalButton) # Compute Normals self.normalsGroupBox = ctk.ctkCollapsibleGroupBox() self.normalsGroupBox.setTitle("Compute Normals") normalsFormLayout = qt.QFormLayout(self.normalsGroupBox) pointSetProcessingFormLayout.addRow(self.normalsGroupBox) self.normalsTabWidget = qt.QTabWidget() normalsFormLayout.addRow(self.normalsTabWidget) # vtkPointSetNormalEstimationAndOrientation self.vtkPointSetNormalEstimationWidget = qt.QWidget() vtkPointSetNormalEstimationFormLayout = qt.QFormLayout( self.vtkPointSetNormalEstimationWidget) normalsFormLayout.addRow(self.vtkPointSetNormalEstimationWidget) self.normalsTabWidget.addTab( self.vtkPointSetNormalEstimationWidget, "vtkPointSetNormalEstimationAndOrientation") self.modeTypeComboBox = qt.QComboBox() self.modeTypeComboBox.addItem('Fixed') self.modeTypeComboBox.addItem('Radius') self.modeTypeComboBox.setCurrentIndex(1) self.modeTypeComboBox.setToolTip('') vtkPointSetNormalEstimationFormLayout.addRow('Mode Type: ', self.modeTypeComboBox) self.numberOfNeighborsSlider = ctk.ctkSliderWidget() self.numberOfNeighborsSlider.setDecimals(0) self.numberOfNeighborsSlider.singleStep = 1 self.numberOfNeighborsSlider.minimum = 1 self.numberOfNeighborsSlider.maximum = 20 self.numberOfNeighborsSlider.value = 4 self.numberOfNeighborsSlider.setToolTip('') self.numberOfNeighborsSlider.enabled = False vtkPointSetNormalEstimationFormLayout.addRow( 'Fixed Neighbors: ', self.numberOfNeighborsSlider) self.radiusSlider = ctk.ctkSliderWidget() self.radiusSlider.setDecimals(2) self.radiusSlider.singleStep = 0.01 self.radiusSlider.minimum = 0 self.radiusSlider.maximum = 50 self.radiusSlider.value = 1.0 self.radiusSlider.setToolTip('') vtkPointSetNormalEstimationFormLayout.addRow('Radius: ', self.radiusSlider) self.graphTypeComboBox = qt.QComboBox() self.graphTypeComboBox.addItem('Riemann') self.graphTypeComboBox.addItem('KNN') self.graphTypeComboBox.setCurrentIndex(1) self.graphTypeComboBox.setToolTip('') vtkPointSetNormalEstimationFormLayout.addRow('Graph Type: ', self.graphTypeComboBox) self.knnSlider = ctk.ctkSliderWidget() self.knnSlider.setDecimals(0) self.knnSlider.singleStep = 1 self.knnSlider.minimum = 1 self.knnSlider.maximum = 100 self.knnSlider.value = 5 self.knnSlider.setToolTip('') vtkPointSetNormalEstimationFormLayout.addRow('K-Nearest Neighbors: ', self.knnSlider) self.vtkPointSetNormalEstimationButton = qt.QPushButton("Apply") self.vtkPointSetNormalEstimationButton.enabled = False self.vtkPointSetNormalEstimationButton.checkable = True vtkPointSetNormalEstimationFormLayout.addRow( self.vtkPointSetNormalEstimationButton) # vtkPolyDataNormals self.vtkPolyDataNormalsWidget = qt.QWidget() vtkPolyDataNormalsFormLayout = qt.QFormLayout( self.vtkPolyDataNormalsWidget) normalsFormLayout.addRow(self.vtkPolyDataNormalsWidget) self.normalsTabWidget.addTab(self.vtkPolyDataNormalsWidget, "vtkPolyDataNormals") self.featureAngleSlider = ctk.ctkSliderWidget() self.featureAngleSlider.setDecimals(2) self.featureAngleSlider.singleStep = 0.01 self.featureAngleSlider.minimum = 0 self.featureAngleSlider.maximum = 360 self.featureAngleSlider.value = 0.1 self.featureAngleSlider.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Feature Angle: ', self.featureAngleSlider) self.splittingComboBox = qt.QComboBox() self.splittingComboBox.addItem('False') self.splittingComboBox.addItem('True') self.splittingComboBox.setCurrentIndex(1) self.splittingComboBox.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Splitting: ', self.splittingComboBox) self.consistencyComboBox = qt.QComboBox() self.consistencyComboBox.addItem('False') self.consistencyComboBox.addItem('True') self.consistencyComboBox.setCurrentIndex(0) self.consistencyComboBox.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Consistency: ', self.consistencyComboBox) self.autoOrientNormalsComboBox = qt.QComboBox() self.autoOrientNormalsComboBox.addItem('False') self.autoOrientNormalsComboBox.addItem('True') self.autoOrientNormalsComboBox.setCurrentIndex(0) self.autoOrientNormalsComboBox.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Auto-Orient Normals: ', self.autoOrientNormalsComboBox) self.computePointNormalsComboBox = qt.QComboBox() self.computePointNormalsComboBox.addItem('False') self.computePointNormalsComboBox.addItem('True') self.computePointNormalsComboBox.setCurrentIndex(1) self.computePointNormalsComboBox.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Compute Point Normals: ', self.computePointNormalsComboBox) self.computeCellNormalsComboBox = qt.QComboBox() self.computeCellNormalsComboBox.addItem('False') self.computeCellNormalsComboBox.addItem('True') self.computeCellNormalsComboBox.setCurrentIndex(0) self.computeCellNormalsComboBox.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Compute Cell Normals: ', self.computeCellNormalsComboBox) self.flipNormalsComboBox = qt.QComboBox() self.flipNormalsComboBox.addItem('False') self.flipNormalsComboBox.addItem('True') self.flipNormalsComboBox.setCurrentIndex(0) self.flipNormalsComboBox.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Flip Normals: ', self.flipNormalsComboBox) self.nonManifoldTraversalComboBox = qt.QComboBox() self.nonManifoldTraversalComboBox.addItem('False') self.nonManifoldTraversalComboBox.addItem('True') self.nonManifoldTraversalComboBox.setCurrentIndex(1) self.nonManifoldTraversalComboBox.setToolTip('') vtkPolyDataNormalsFormLayout.addRow('Non-Manifold Traversal: ', self.nonManifoldTraversalComboBox) self.vtkPolyDataNormalsButton = qt.QPushButton("Apply") self.vtkPolyDataNormalsButton.enabled = False self.vtkPolyDataNormalsButton.checkable = True vtkPolyDataNormalsFormLayout.addRow(self.vtkPolyDataNormalsButton) self.normalsVisibleCheckBox = qt.QCheckBox('Arrows Visibility: ') self.normalsVisibleCheckBox.checked = True self.normalsVisibleCheckBox.enabled = True self.normalsVisibleCheckBox.setLayoutDirection(1) normalsFormLayout.addRow(self.normalsVisibleCheckBox) # Compute Surface self.surfaceGroupBox = ctk.ctkCollapsibleGroupBox() self.surfaceGroupBox.setTitle("Compute Surface") surfaceFormLayout = qt.QFormLayout(self.surfaceGroupBox) pointSetProcessingFormLayout.addRow(self.surfaceGroupBox) self.surfaceTabWidget = qt.QTabWidget() surfaceFormLayout.addRow(self.surfaceTabWidget) # vtkPoissionReconstruction self.vtkPoissionReconstructionWidget = qt.QWidget() vtkPoissionReconstructionFormLayout = qt.QFormLayout( self.vtkPoissionReconstructionWidget) surfaceFormLayout.addRow(self.vtkPoissionReconstructionWidget) self.surfaceTabWidget.addTab(self.vtkPoissionReconstructionWidget, "vtkPoissionReconstruction") self.depthSlider = ctk.ctkSliderWidget() self.depthSlider.setDecimals(0) self.depthSlider.singleStep = 1 self.depthSlider.minimum = 1 self.depthSlider.maximum = 14 self.depthSlider.value = 8 self.depthSlider.setToolTip( 'This integer controls the reconstruction depth; the maximum depth of the tree that will be used for surface reconstruction. Running at depth d corresponds to solving on a voxel grid whose resolution is no larger than 2^d x 2^d x 2^d. Note that since the reconstructor adapts the octree to the sampling density, the specified reconstruction depth is only an upper bound.' ) vtkPoissionReconstructionFormLayout.addRow('Depth: ', self.depthSlider) self.scaleSlider = ctk.ctkSliderWidget() self.scaleSlider.setDecimals(2) self.scaleSlider.singleStep = 0.01 self.scaleSlider.minimum = 0 self.scaleSlider.maximum = 10 self.scaleSlider.value = 1.25 self.scaleSlider.setToolTip( 'This floating point value specifies the ratio between the diameter of the cube used for reconstruction and the diameter of the samples bounding cube.' ) vtkPoissionReconstructionFormLayout.addRow('Scale: ', self.scaleSlider) self.solverDivideSlider = ctk.ctkSliderWidget() self.solverDivideSlider.setDecimals(0) self.solverDivideSlider.singleStep = 1 self.solverDivideSlider.minimum = 1 self.solverDivideSlider.maximum = 20 self.solverDivideSlider.value = 8 self.solverDivideSlider.setToolTip( 'Solver subdivision depth; This integer argument specifies the depth at which a block Gauss-Seidel solver is used to solve the Laplacian equation. Using this parameter helps reduce the memory overhead at the cost of a small increase in reconstruction time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide depth of 7 or 8 can greatly reduce the memory usage.)' ) vtkPoissionReconstructionFormLayout.addRow('Solver Divide: ', self.solverDivideSlider) self.isoDivideSlider = ctk.ctkSliderWidget() self.isoDivideSlider.setDecimals(0) self.isoDivideSlider.singleStep = 1 self.isoDivideSlider.minimum = 1 self.isoDivideSlider.maximum = 20 self.isoDivideSlider.value = 8 self.isoDivideSlider.setToolTip( 'Iso-surface extraction subdivision depth; This integer argument specifies the depth at which a block isosurface extractor should be used to extract the iso-surface. Using this parameter helps reduce the memory overhead at the cost of a small increase in extraction time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide depth of 7 or 8 can greatly reduce the memory usage.)' ) vtkPoissionReconstructionFormLayout.addRow('Iso Divide: ', self.isoDivideSlider) self.samplesPerNodeSlider = ctk.ctkSliderWidget() self.samplesPerNodeSlider.setDecimals(2) self.samplesPerNodeSlider.singleStep = 0.1 self.samplesPerNodeSlider.minimum = 1 self.samplesPerNodeSlider.maximum = 30 self.samplesPerNodeSlider.value = 1.0 self.samplesPerNodeSlider.setToolTip( 'Minimum number of samples; This floating point value specifies the minimum number of sample points that should fall within an octree node as the octree construction is adapted to sampling density. For noise-free samples, small values in the range [1.0 - 5.0] can be used. For more noisy samples, larger values in the range [15.0 - 20.0] may be needed to provide a smoother, noise-reduced, reconstruction.' ) vtkPoissionReconstructionFormLayout.addRow('Samples per Node: ', self.samplesPerNodeSlider) self.confidenceComboBox = qt.QComboBox() self.confidenceComboBox.addItem('False') self.confidenceComboBox.addItem('True') self.confidenceComboBox.setToolTip( 'Enabling tells the reconstructor to use the size of the normals as confidence information. When the flag is not enabled, all normals are normalized to have unit-length prior to reconstruction.' ) vtkPoissionReconstructionFormLayout.addRow('Confidence: ', self.confidenceComboBox) self.verboseComboBox = qt.QComboBox() self.verboseComboBox.addItem('False') self.verboseComboBox.addItem('True') self.verboseComboBox.setToolTip( 'Enabling this flag provides a more verbose description of the running times and memory usages of individual components of the surface reconstructor.' ) vtkPoissionReconstructionFormLayout.addRow('Verbose: ', self.verboseComboBox) self.vtkPoissionReconstructionButton = qt.QPushButton("Apply") self.vtkPoissionReconstructionButton.enabled = False self.vtkPoissionReconstructionButton.checkable = True vtkPoissionReconstructionFormLayout.addRow( self.vtkPoissionReconstructionButton) # vtkDelaunay3D self.vtkDelaunay3DWidget = qt.QWidget() vtkDelaunay3DFormLayout = qt.QFormLayout(self.vtkDelaunay3DWidget) surfaceFormLayout.addRow(self.vtkDelaunay3DWidget) self.surfaceTabWidget.addTab(self.vtkDelaunay3DWidget, "vtkDelaunay3D") self.alphaSlider = ctk.ctkSliderWidget() self.alphaSlider.setDecimals(1) self.alphaSlider.singleStep = 0.1 self.alphaSlider.minimum = 0.0 self.alphaSlider.maximum = 100.0 self.alphaSlider.value = 0.0 self.alphaSlider.setToolTip('') vtkDelaunay3DFormLayout.addRow('Alpha: ', self.alphaSlider) self.toleranceSlider = ctk.ctkSliderWidget() self.toleranceSlider.setDecimals(2) self.toleranceSlider.singleStep = 0.01 self.toleranceSlider.minimum = 0.0 self.toleranceSlider.maximum = 1.0 self.toleranceSlider.value = 0.0 self.toleranceSlider.setToolTip('') vtkDelaunay3DFormLayout.addRow('Tolerance: ', self.toleranceSlider) self.offsetSlider = ctk.ctkSliderWidget() self.offsetSlider.setDecimals(1) self.offsetSlider.singleStep = 0.1 self.offsetSlider.minimum = 0.0 self.offsetSlider.maximum = 10.0 self.offsetSlider.value = 2.5 self.offsetSlider.setToolTip('') vtkDelaunay3DFormLayout.addRow('Offset: ', self.offsetSlider) self.boundingComboBox = qt.QComboBox() self.boundingComboBox.addItem('False') self.boundingComboBox.addItem('True') self.boundingComboBox.setCurrentIndex(0) self.boundingComboBox.setToolTip('') vtkDelaunay3DFormLayout.addRow('Bounding Triangulations: ', self.boundingComboBox) self.vtkDelaunay3DButton = qt.QPushButton("Apply") self.vtkDelaunay3DButton.enabled = False self.vtkDelaunay3DButton.checkable = True vtkDelaunay3DFormLayout.addRow(self.vtkDelaunay3DButton) self.surfaceVisibleCheckBox = qt.QCheckBox('Surface Visibility: ') self.surfaceVisibleCheckBox.checked = True self.surfaceVisibleCheckBox.enabled = True self.surfaceVisibleCheckBox.setLayoutDirection(1) surfaceFormLayout.addRow(self.surfaceVisibleCheckBox) # connections self.vtkCleanPolyDataButton.connect('clicked(bool)', self.vtkCleanPolyDataClicked) self.vtkPointSetOutlierRemovalButton.connect( 'clicked(bool)', self.vtkPointSetOutlierRemovalClicked) self.vtkPointSetNormalEstimationButton.connect( 'clicked(bool)', self.vtkPointSetNormalEstimationClicked) self.vtkPolyDataNormalsButton.connect('clicked(bool)', self.vtkPolyDataNormalsClicked) self.vtkPoissionReconstructionButton.connect( 'clicked(bool)', self.vtkPoissionReconstructionClicked) self.vtkDelaunay3DButton.connect('clicked(bool)', self.vtkDelaunay3DClicked) self.inputSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onSelect) self.graphTypeComboBox.connect('currentIndexChanged(const QString &)', self.onGraphTypeChanged) self.modeTypeComboBox.connect('currentIndexChanged(const QString &)', self.onModeChanged) self.surfaceVisibleCheckBox.connect('stateChanged(int)', self.onSurfaceVisible) self.normalsVisibleCheckBox.connect('stateChanged(int)', self.onNormalsVisible) self.inputPointSizeSlider.connect('valueChanged (double)', self.onInputPointSliderModified) # Add vertical spacer self.layout.addStretch(1) # Refresh self.onSelect() lm = slicer.app.layoutManager() lm.setLayout(4) # One 3D-view