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
