def create(self):
super(FastMarchingEffectOptions, self).create()
self.defaultMaxPercent = 30
self.percentLabel = qt.QLabel(
'Expected structure volume as % of image volume:', self.frame)
self.percentLabel.setToolTip(
'Segmentation will grow from the seed label until this value is reached'
)
self.frame.layout().addWidget(self.percentLabel)
self.widgets.append(self.percentLabel)
self.percentMax = ctk.ctkSliderWidget(self.frame)
self.percentMax.minimum = 0
self.percentMax.maximum = 100
self.percentMax.singleStep = 1
self.percentMax.value = self.defaultMaxPercent
self.percentMax.setToolTip(
'Approximate volume of the structure to be segmented relative to the total volume of the image'
)
self.frame.layout().addWidget(self.percentMax)
self.widgets.append(self.percentMax)
self.percentMax.connect('valueChanged(double)', self.percentMaxChanged)
self.march = qt.QPushButton("March", self.frame)
self.march.setToolTip(
"Perform the Marching operation into the current label map")
self.frame.layout().addWidget(self.march)
self.widgets.append(self.march)
self.percentVolume = qt.QLabel('Maximum volume of the structure: ')
self.percentVolume.setToolTip('Total maximum volume')
self.frame.layout().addWidget(self.percentVolume)
self.widgets.append(self.percentVolume)
self.marcher = ctk.ctkSliderWidget(self.frame)
self.marcher.minimum = 0
self.marcher.maximum = 1
self.marcher.singleStep = 0.01
self.marcher.enabled = False
self.frame.layout().addWidget(self.marcher)
self.widgets.append(self.marcher)
self.marcher.connect('valueChanged(double)', self.onMarcherChanged)
HelpButton(
self.frame,
"To use FastMarching effect, first mark the areas that belong to the structure of interest to initialize the algorithm. Define the expected volume of the structure you are trying to segment, and hit March.\nAfter computation is complete, use the Marcher slider to go over the segmentation history."
)
self.march.connect('clicked()', self.onMarch)
# Add vertical spacer
self.frame.layout().addStretch(1)
self.percentMaxChanged(self.percentMax.value)
def create(self):
super(FastMarchingEffectOptions,self).create()
import SelectDirection
self.SelectionDirection = SelectDirection.SelectDirection(self.frame)
self.SelectionDirection.AxiCBox.connect("stateChanged(int)", self.UpdatePercentText)
self.SelectionDirection.SagCBox.connect("stateChanged(int)", self.UpdatePercentText)
self.SelectionDirection.CorCBox.connect("stateChanged(int)", self.UpdatePercentText)
self.defaultMaxPercent = 30
self.percentLabel = qt.QLabel('Expected structure volume as % of image volume:',self.frame)
self.percentLabel.setToolTip('Segmentation will grow from the seed label until this value is reached')
self.frame.layout().addWidget(self.percentLabel)
self.widgets.append(self.percentLabel)
self.percentMax = ctk.ctkSliderWidget(self.frame)
self.percentMax.minimum = 0
self.percentMax.maximum = 100
self.percentMax.singleStep = 1
self.percentMax.value = self.defaultMaxPercent
self.percentMax.setToolTip('Approximate volume of the structure to be segmented relative to the total volume of the image')
self.frame.layout().addWidget(self.percentMax)
self.widgets.append(self.percentMax)
self.percentMax.connect('valueChanged(double)', self.percentMaxChanged)
self.march = qt.QPushButton("March", self.frame)
self.march.setToolTip("Perform the Marching operation into the current label map")
self.frame.layout().addWidget(self.march)
self.widgets.append(self.march)
self.percentVolume = qt.QLabel('Maximum volume of the structure: ')
self.percentVolume.setToolTip('Total maximum volume')
self.frame.layout().addWidget(self.percentVolume)
self.widgets.append(self.percentVolume)
self.marcher = ctk.ctkSliderWidget(self.frame)
self.marcher.minimum = 0
self.marcher.maximum = 1
self.marcher.singleStep = 0.01
self.marcher.enabled = False
self.frame.layout().addWidget(self.marcher)
self.widgets.append(self.marcher)
self.marcher.connect('valueChanged(double)',self.onMarcherChanged)
HelpButton(self.frame, "To use FastMarching effect, first mark the areas that belong to the structure of interest to initialize the algorithm. Define the expected volume of the structure you are trying to segment, and hit March.\nAfter computation is complete, use the Marcher slider to go over the segmentation history.")
self.march.connect('clicked()', self.onMarch)
# Add vertical spacer
self.frame.layout().addStretch(1)
self.percentMaxChanged(self.percentMax.value)
def CreateSliders(self):
self.sliders = {}
for param in self.params:
self.sliders[param] = ctk.ctkSliderWidget()
self.sliders[param].setDecimals(self.params[param][0])
self.sliders[param].singleStep = self.params[param][1]
self.sliders[param].minimum = self.params[param][2]
self.sliders[param].maximum = self.params[param][3]
self.sliders[param].value = self.params[param][4]
self.sliders[param].setToolTip(self.params[param][5])
def CreateSliders(self):
self.sliders = {}
for param in self.params:
self.sliders[param] = ctk.ctkSliderWidget()
self.sliders[param].setDecimals(self.params[param][0])
self.sliders[param].singleStep = self.params[param][1]
self.sliders[param].minimum = self.params[param][2]
self.sliders[param].maximum = self.params[param][3]
self.sliders[param].value = self.params[param][4]
self.sliders[param].setToolTip(self.params[param][5])
def setup(self):
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# Import model
#
self.inputModel = qt.QFileDialog.getOpenFileName()
parametersFormLayout.addRow("Input Model: ",
qt.QLabel(self.inputModel))
# Principal Component selection scroller
self.pcSlider = ctk.ctkSliderWidget()
self.pcSlider.decimals = 0
self.pcSlider.minimum = 0
self.pcSlider.maximum = 10
parametersFormLayout.addRow("PC", self.pcSlider)
# Standard variation selection scroller
self.stdSlider = ctk.ctkSliderWidget()
self.stdSlider.decimals = 0
self.stdSlider.minimum = -10
self.stdSlider.maximum = 10
parametersFormLayout.addRow("std", self.stdSlider)
# make connections
self.pcSlider.connect('valueChanged(double)', self.onSelect)
self.stdSlider.connect('valueChanged(double)', self.onSelect)
# make an instance of the logic for use by the slots
self.logic = ScriptedSSMBuildingLogic()
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# Import model
#
self.inputModel = qt.QFileDialog.getOpenFileName()
parametersFormLayout.addRow("Input Model: ", qt.QLabel(self.inputModel))
# Principal Component selection scroller
self.pcSlider = ctk.ctkSliderWidget()
self.pcSlider.decimals = 0
self.pcSlider.minimum = 0
self.pcSlider.maximum = 10
parametersFormLayout.addRow("PC", self.pcSlider)
# Standard variation selection scroller
self.stdSlider = ctk.ctkSliderWidget()
self.stdSlider.decimals = 0
self.stdSlider.minimum = -10
self.stdSlider.maximum = 10
parametersFormLayout.addRow("std", self.stdSlider)
# make connections
self.pcSlider.connect('valueChanged(double)', self.onSelect)
self.stdSlider.connect('valueChanged(double)', self.onSelect)
# make an instance of the logic for use by the slots
self.logic = ScriptedSSMBuildingLogic()
# Add vertical spacer
self.layout.addStretch(1)
def setupFrameControlFrame(self):
# TODO: initialize the slider based on the contents of the labels array
self.frameSlider = ctk.ctkSliderWidget()
self.frameLabel = QLabel('Current frame number')
self.playButton = QPushButton('Play')
self.playButton.toolTip = 'Iterate over multivolume frames'
self.playButton.checkable = True
frameControlHBox = QHBoxLayout()
frameControlHBox.addWidget(self.frameLabel)
frameControlHBox.addWidget(self.frameSlider)
frameControlHBox.addWidget(self.playButton)
self.inputFrameLayout.addRow(frameControlHBox)
def setup(self):
#super(makeROIWidget,self).setup()
QCLib.genericPanel.setup(self)
applicationLogic = slicer.app.applicationLogic()
selectionNode = applicationLogic.GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(None)
selectionNode.SetReferenceActiveLabelVolumeID(None)
selectionNode.SetReferenceSecondaryVolumeID(None)
applicationLogic.PropagateVolumeSelection(0)
self.masterWhenMergeWasSet = None
self.label = ctk.ctkCollapsibleButton(self.frame)
self.label.setText("ROI")
self.framelayout.addWidget(self.label)
parametersFormLayout=qt.QFormLayout(self.label)
#
# Volume of ROI in master percentage
#
self.volumeratioslider = ctk.ctkSliderWidget()
self.volumeratioslider.singleStep = 1.0
self.volumeratioslider.minimum = 0.0
self.volumeratioslider.maximum = 100.0
self.volumeratioslider.value = 80.0
self.volumeratioslider.enabled = False
self.volumeratioslider.setToolTip("Set ROI volume as percentage of master volume")
parametersFormLayout.addRow("ROI Area Percentage", self.volumeratioslider)
self.sliceslider = slicer.qMRMLSliceControllerWidget()
self.sliceslider.enabled=False
parametersFormLayout.addRow("Slice for Area Ratio", self.sliceslider)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Create a ROI for QC"
self.applyButton.enabled = False
#parametersFormLayout.addRow(self.applyButton)
self.framelayout.addWidget(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.masterSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelectMaster)
self.masterSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
#self.labelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.framelayout.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 = "TestRobotPlacement 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 = ( ("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." )
parametersFormLayout.addRow("Input Model: ", self.inputSelector)
#
# Sphere model
#
self.sphereModel = slicer.mrmlScene.CreateNodeByClass('vtkMRMLModelNode')
self.sphereModel.SetName("SphereModel")
slicer.mrmlScene.AddNode(self.sphereModel)
displayNode = slicer.mrmlScene.CreateNodeByClass("vtkMRMLModelDisplayNode")
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetOpacity(0.35)
displayNode.SetColor(1.0,0.0,0.0)
self.sphereModel.SetAndObserveDisplayNodeID(displayNode.GetID())
#
# Seed point
#
self.sphereSeedListSelector = slicer.qMRMLNodeComboBox()
self.sphereSeedListSelector.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" )
self.sphereSeedListSelector.baseName = "SeedPoint"
self.sphereSeedListSelector.selectNodeUponCreation = True
self.sphereSeedListSelector.addEnabled = True
self.sphereSeedListSelector.removeEnabled = True
self.sphereSeedListSelector.noneEnabled = False
self.sphereSeedListSelector.showHidden = False
self.sphereSeedListSelector.showChildNodeTypes = False
self.sphereSeedListSelector.setMRMLScene( slicer.mrmlScene )
self.sphereSeedListSelector.setToolTip( "Seed list" )
parametersFormLayout.addRow("Seed Point: ", self.sphereSeedListSelector)
#
# Sphere radius
#
self.sphereRadiusSliderWidget = ctk.ctkSliderWidget()
self.sphereRadiusSliderWidget.singleStep = 1.0
self.sphereRadiusSliderWidget.minimum = 1.0
self.sphereRadiusSliderWidget.maximum = 100.0
self.sphereRadiusSliderWidget.value = 40.0
self.sphereRadiusSliderWidget.setToolTip("Set sphere radius in mm.")
parametersFormLayout.addRow("Sphere Radius (mm)", self.sphereRadiusSliderWidget)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.sphereSeedListSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSeedListChanged)
self.sphereRadiusSliderWidget.connect("valueChanged(double)", self.updateSphere)
# Add vertical spacer
self.layout.addStretch(1)
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 = ['vtkMRMLMarkupsFiducialNode', '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 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 = "AddManyMarkupsFiducialTest 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)
#
# number of fiducials to add
#
self.numToAddSliderWidget = ctk.ctkSliderWidget()
self.numToAddSliderWidget.singleStep = 1.0
self.numToAddSliderWidget.minimum = 0.0
self.numToAddSliderWidget.maximum = 1000.0
self.numToAddSliderWidget.value = 100.0
self.numToAddSliderWidget.toolTip = "Set the number of fiducials to add."
parametersFormLayout.addRow("Number of Fiducials to Add", self.numToAddSliderWidget)
#
# check box to trigger fewer modify events, adding all the new points
# is wrapped inside of a StartModify/EndModify block
#
self.fewerModifyFlagCheckBox = qt.QCheckBox()
self.fewerModifyFlagCheckBox.checked = 0
self.fewerModifyFlagCheckBox.toolTip = 'If checked, wrap adding points inside of a StartModify - EndModify block'
parametersFormLayout.addRow("Fewer Modify Events", self.fewerModifyFlagCheckBox)
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
# 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 = "NeurosurgicalPlanningTutorialMarkupsSelfTest 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)
#
# 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.")
parametersFormLayout.addRow("Screenshot scale factor", self.screenshotScaleFactorSliderWidget)
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
self.dir = os.path.dirname(os.path.realpath(__file__))
#
# Setup
#
setupWindow = ctk.ctkCollapsibleButton()
setupWindow.text = 'Setup'
self.layout.addWidget(setupWindow)
self.setupLayout = qt.QFormLayout(setupWindow)
# Input box
inputBox = ctk.ctkCollapsibleGroupBox()
inputBox.setTitle('Input:')
self.setupLayout.addRow(inputBox)
self.inputBoxLayout = qt.QFormLayout(inputBox)
# Bevel angle slider
self.bevelAngleSlider = ctk.ctkSliderWidget()
self.bevelAngleSlider.connect('valueChanged(double)', self.bevel_angle_changed)
self.bevelAngleSlider.decimals = 0
self.bevelAngleSlider.minimum = 0
self.bevelAngleSlider.maximum = 360
self.inputBoxLayout.addRow("Bevel Angle:", self.bevelAngleSlider)
# R-Axis Entry Error
self.entryErrR = qt.QLineEdit()
self.entryErrR.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("R-Axis Entry Error:", self.entryErrR)
# A-Axis Entry Error
self.entryErrA = qt.QLineEdit()
self.entryErrA.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("A-Axis Entry Error:", self.entryErrA)
# S-Axis Entry Error
self.entryErrS = qt.QLineEdit()
self.entryErrS.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("S-Axis Entry Error:", self.entryErrS)
# Curve Radius
self.curveRadius = qt.QLineEdit()
self.curveRadius.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("Curve Radius:", self.curveRadius)
# Insertion Length
self.insertionLength = qt.QLineEdit()
self.insertionLength.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("Insertion Length:", self.insertionLength)
# Needle length in prostate
self.len1 = qt.QLineEdit()
self.len1.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("Needle length in prostate:", self.len1)
# Needle Length in pelvic diaphragm
self.len2 = qt.QLineEdit()
self.len2.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("Needle length in pelvic diaphragm:", self.len2)
# Needle length in bulbospongiosus
self.len3 = qt.QLineEdit()
self.len3.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("Needle length in bulbospongiousus:", self.len3)
# Needle length in ischiocavernosus
self.len4 = qt.QLineEdit()
self.len4.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("Needle length in ischiocavernosus:", self.len4)
# Needle length in unsegmented tissue
self.len5 = qt.QLineEdit()
self.len5.setPlaceholderText("Enter length (mm)")
self.inputBoxLayout.addRow("Needle length in unsegmented tissue:", self.len5)
# Calculate Error
self.calculateError = qt.QPushButton("Calculate Error")
self.calculateError.clicked.connect(self.run_regressions)
self.setupLayout.addWidget(self.calculateError)
# Disable calculation until data is entered
self.calculateError.setEnabled(0)
self.calculateError.setText('Enter all data first!')
#
# Output
#
outputWindow = ctk.ctkCollapsibleButton()
outputWindow.text = 'Output'
self.layout.addWidget(outputWindow)
self.outputLayout = qt.QFormLayout(outputWindow)
# Output box
outputBoxCollapsible = ctk.ctkCollapsibleGroupBox()
outputBoxCollapsible.setTitle('Output')
self.outputLayout.addRow(outputBoxCollapsible)
self.outputBox = qt.QFormLayout(outputBoxCollapsible)
# Initial output text
self.outputLabel = qt.QLabel("")
self.outputBox.addRow(self.outputLabel)
self.outputLabel.setText("The needle has a probability of 00.00% to hit the \ntarget, a probability of 00.00% "
"to deflect to the right,\nand a probability of 00.00% to deflect to the top.")
# Initial visual output
image = qt.QPixmap(self.dir + "/NeedleDeviationPredictor GUI/empty.png")
self.label1 = qt.QLabel("")
# Scaling and sizing
self.label1.setScaledContents(True)
self.label1.setMargin(0)
self.label1.setPixmap(image)
qSize = qt.QSizePolicy()
self.label1.setSizePolicy(qSize)
self.outputBox.addRow(self.label1)
# Vertical spacer
self.layout.addStretch(1)
# Check all entered values are floats
values = [self.entryErrR, self.entryErrA, self.entryErrS, self.curveRadius,
self.insertionLength, self.len1, self.len2, self.len3, self.len4, self.len5]
for value in values:
value.textChanged.connect(self.check_inputs)
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 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
#TODO Make is so correct models are loaded into scroll slots, its a
# pain to keep clicking to insert models
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload this module."
self.reloadButton.name = "HDRMould Reload"
reloadFormLayout.addWidget(self.reloadButton)
# Reload and Test button
self.reloadAndTestButton = qt.QPushButton("Reload and Test")
self.reloadAndTestButton.setToolTip("""Reload this module and then run
the self tests.""")
reloadFormLayout.addWidget(self.reloadAndTestButton)
# Make TestObject Mould - button
self.createTestObjectButton = qt.QPushButton()
self.createTestObjectButton.setText("Create Test Object")
self.createTestObjectButton.toolTip = "Creates a mask of a specified \
thickness from the face of interest. Catheter paths are carved out \
along the line connecting the pairs of fiducials. This overwrites \
the Output Model."
self.createTestObjectButton.enabled = True
reloadFormLayout.addRow(self.createTestObjectButton)
# Parameters Area
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
#Debug Mode Check Box:
# Layout within the collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
# target surface model ComboBox - drop down menu
self.surfaceModelComboBox = slicer.qMRMLNodeComboBox()
self.surfaceModelComboBox.nodeTypes = (("vtkMRMLModelNode"), "")
self.surfaceModelComboBox.selectNodeUponCreation = True
self.surfaceModelComboBox.addEnabled = False
self.surfaceModelComboBox.removeEnabled = False
self.surfaceModelComboBox.noneEnabled = False
self.surfaceModelComboBox.showHidden = False
self.surfaceModelComboBox.showChildNodeTypes = False
self.surfaceModelComboBox.setMRMLScene(slicer.mrmlScene)
self.surfaceModelComboBox.setToolTip(
"Choose the skin surface model for \
the surface mould to be made for")
parametersFormLayout.addRow("Skin Surface Model ",
self.surfaceModelComboBox)
# output model ComboBox (overwritten) - drop down menu
self.ouputMouldComboBox = slicer.qMRMLNodeComboBox()
self.ouputMouldComboBox.nodeTypes = (("vtkMRMLModelNode"), "")
self.ouputMouldComboBox.renameEnabled = True
self.ouputMouldComboBox.selectNodeUponCreation = True
self.ouputMouldComboBox.addEnabled = True
self.ouputMouldComboBox.removeEnabled = True
self.ouputMouldComboBox.noneEnabled = False
self.ouputMouldComboBox.showHidden = False
self.ouputMouldComboBox.showChildNodeTypes = False
self.ouputMouldComboBox.setMRMLScene(slicer.mrmlScene)
self.ouputMouldComboBox.setToolTip("This model will be overwritten \
with the output surface mould")
parametersFormLayout.addRow("Output Mould Model ",
self.ouputMouldComboBox)
# ROI node comboBox - drop down menu
self.roiComboBox = slicer.qMRMLNodeComboBox()
self.roiComboBox.nodeTypes = (("vtkMRMLAnnotationROINode"), "")
self.roiComboBox.renameEnabled = True
self.roiComboBox.selectNodeUponCreation = True
self.roiComboBox.addEnabled = False
self.roiComboBox.removeEnabled = True
self.roiComboBox.noneEnabled = False
self.roiComboBox.showHidden = False
self.roiComboBox.showChildNodeTypes = False
self.roiComboBox.setMRMLScene(slicer.mrmlScene)
self.roiComboBox.setToolTip("Choose the area of the skin \
surface that the mould is to be made for. This determines the final size \
of the mould. ")
parametersFormLayout.addRow("Region of Interest ", self.roiComboBox)
# Ruler node comboBox - drop down menu
self.rulerComboBox = slicer.qMRMLNodeComboBox()
self.rulerComboBox.nodeTypes = (("vtkMRMLAnnotationRulerNode"), "")
self.rulerComboBox.renameEnabled = True
self.rulerComboBox.selectNodeUponCreation = True
self.rulerComboBox.addEnabled = False
self.rulerComboBox.removeEnabled = True
self.rulerComboBox.noneEnabled = False
self.rulerComboBox.showHidden = False
self.rulerComboBox.showChildNodeTypes = False
self.rulerComboBox.setMRMLScene(slicer.mrmlScene)
self.rulerComboBox.setToolTip("This ruler and the pairs of points\
, will be used to define a plane used in path generation")
parametersFormLayout.addRow("Ruler ", self.rulerComboBox)
# First catheter start point fiducial selector - drop down menu
self.startPointComboBox = slicer.qMRMLNodeComboBox()
self.startPointComboBox.nodeTypes = (("vtkMRMLMarkupsFiducialNode"),
"")
self.startPointComboBox.renameEnabled = True
self.startPointComboBox.selectNodeUponCreation = True
self.startPointComboBox.addEnabled = False
self.startPointComboBox.removeEnabled = True
self.startPointComboBox.noneEnabled = False
self.startPointComboBox.showHidden = False
self.startPointComboBox.showChildNodeTypes = False
self.startPointComboBox.setMRMLScene(slicer.mrmlScene)
self.startPointComboBox.setToolTip("Choose the markup list that \
contains the starting points of the catheter paths")
parametersFormLayout.addRow("Catheter Start Points ",
self.startPointComboBox)
# Second catheter fiducial selector - drop down menu
self.endPointComboBox = slicer.qMRMLNodeComboBox()
self.endPointComboBox.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "")
self.endPointComboBox.renameEnabled = True
self.endPointComboBox.selectNodeUponCreation = True
self.endPointComboBox.addEnabled = False
self.endPointComboBox.removeEnabled = True
self.endPointComboBox.noneEnabled = False
self.endPointComboBox.showHidden = False
self.endPointComboBox.showChildNodeTypes = False
self.endPointComboBox.setMRMLScene(slicer.mrmlScene)
self.endPointComboBox.setToolTip("""Choose the markup list node that,
contains the end points of the catheter paths""")
parametersFormLayout.addRow("Catheter End Points ",
self.endPointComboBox)
# Minimum catheter distance from target surface - slider and spinbox
self.minCathDistanceSlider = ctk.ctkSliderWidget()
self.minCathDistanceSlider.setToolTip(
""" The closest absolute distance
a catheter is aloud to get to the skin""")
self.minCathDistanceSlider.minimum = 1.5
self.minCathDistanceSlider.maximum = 10
self.minCathDistanceSlider.value = 2
parametersFormLayout.addRow("Distance from Skin",
self.minCathDistanceSlider)
# Minimum catheter distance from target surface - slider and spinbox
self.slitThickness = ctk.ctkSliderWidget()
self.slitThickness.setToolTip(
""" The thickness of the slit instantiated
into the mould.""")
self.slitThickness.minimum = 0.5
self.slitThickness.maximum = 10
self.slitThickness.value = 1.0
parametersFormLayout.addRow("Slit Thickness (mm)", self.slitThickness)
# Catheter tube radius value - slider and spinbox
self.cathRadiusSlider = ctk.ctkSliderWidget()
self.cathRadiusSlider.toolTip = """Defines the radius of the catheter
tubes, in mm. Default: 2mm"""
self.cathRadiusSlider.minimum = 1.5
self.cathRadiusSlider.maximum = 10
self.cathRadiusSlider.value = 1.4
parametersFormLayout.addRow("Catheter Radius ", self.cathRadiusSlider)
# Catheter path minimum radius of curvature value - slider and spinbox
self.minCurvatureSlider = ctk.ctkSliderWidget()
self.minCurvatureSlider.toolTip = "Defines the minimum radius of \
curvature of any point along the catheter paths, in mm. "
self.minCurvatureSlider.minimum = 0
self.minCurvatureSlider.maximum = 60
self.minCurvatureSlider.value = 14
parametersFormLayout.addRow("Catheter Curvature ",
self.minCurvatureSlider)
# Output mould model resolution value - slider and spinbox
self.algorythm = ctk.ctkSliderWidget()
self.algorythm.toolTip = "How Many Cycles to smooth"
self.algorythm.minimum = 0
self.algorythm.maximum = 1000
self.algorythm.value = 500
parametersFormLayout.addRow("AlgorythmRunning ", self.algorythm)
# Make Brachytherapy Surface Mould - button
self.createMouldButton = qt.QPushButton()
self.createMouldButton.setText("Apply Mould")
self.createMouldButton.toolTip = "Creates a mask of a specified \
thickness from the face of interest. Catheter paths are carved out \
along the line connecting the pairs of fiducials. This overwrites \
the Output Model."
self.createMouldButton.enabled = True
parametersFormLayout.addRow(self.createMouldButton)
# Add vertical spacer
self.layout.addStretch(7)
# connections
self.createMouldButton.connect('clicked(bool)', self.CreateMould)
self.createTestObjectButton.connect('clicked(bool)',
self.CreateTestObject)
self.reloadButton.connect('clicked()', self.onReload)
self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest)
# Saves time with loading the module names in
self.QuickSetup() # Mark Schumacher, added This For convenience
def createUserInterface( self ):
'''
'''
print "1"
anno = slicer.modules.annotations.logic()
anno.AddHierarchy()
rulerNode = slicer.mrmlScene.GetNodeByID('vtkMRMLAnnotationHierarchyNode4')
rulerNode.AddObserver('ModifiedEvent', self.rulerAdded)
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)
'''
print self.fidLabels
print self.fidLevels
print 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'))
#print self.vertebra
#print self.inst_length
#self.levelselection = []
#for i in range(self.levels.index(self.vertebra),self.levels.index(self.vertebra)+int(self.inst_length)):
# print self.levels[i]
# self.levelselection.append(self.levels[i])
#print 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().setResizeMode(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):
#print self.levelselection[i] + "loop"
Label = qt.QTableWidgetItem(str(self.fidLabels[i]))
print Label
Level = qt.QTableWidgetItem(str(self.fidLevels[i]))
print Level
Side = qt.QTableWidgetItem(str(self.fidSides[i]))
print 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):
# 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 setup( self ):
# check if the SlicerVmtk module is installed properly
# self.__vmtkInstalled = SlicerVmtkCommonLib.Helper.CheckIfVmtkIsInstalled()
# Helper.Debug("VMTK found: " + self.__vmtkInstalled)
#
# the I/O panel
#
ioCollapsibleButton = ctk.ctkCollapsibleButton()
ioCollapsibleButton.text = "Input/Output"
self.layout.addWidget( ioCollapsibleButton )
ioFormLayout = qt.QFormLayout( ioCollapsibleButton )
# inputVolume selector
self.__inputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__inputVolumeNodeSelector.objectName = 'inputVolumeNodeSelector'
self.__inputVolumeNodeSelector.toolTip = "Select the input volume. This should always be the original image and not a vesselness image, if possible."
self.__inputVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__inputVolumeNodeSelector.noneEnabled = False
self.__inputVolumeNodeSelector.addEnabled = False
self.__inputVolumeNodeSelector.removeEnabled = False
self.__inputVolumeNodeSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", "0" )
ioFormLayout.addRow( "Input Volume:", self.__inputVolumeNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__inputVolumeNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
self.__inputVolumeNodeSelector.connect( 'currentNodeChanged(vtkMRMLNode*)', self.onInputVolumeChanged )
self.__inputVolumeNodeSelector.connect( 'nodeActivated(vtkMRMLNode*)', self.onInputVolumeChanged )
# seed selector
self.__seedFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.__seedFiducialsNodeSelector.objectName = 'seedFiducialsNodeSelector'
self.__seedFiducialsNodeSelector.toolTip = "Select a hierarchy containing the fiducials to use as Seeds."
self.__seedFiducialsNodeSelector.nodeTypes = ['vtkMRMLAnnotationHierarchyNode']
self.__seedFiducialsNodeSelector.baseName = "Seeds"
self.__seedFiducialsNodeSelector.noneEnabled = False
self.__seedFiducialsNodeSelector.addEnabled = False
self.__seedFiducialsNodeSelector.removeEnabled = False
ioFormLayout.addRow( "Seeds:", self.__seedFiducialsNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__seedFiducialsNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
self.__ioAdvancedToggle = qt.QCheckBox( "Show Advanced I/O Properties" )
self.__ioAdvancedToggle.setChecked( False )
ioFormLayout.addRow( self.__ioAdvancedToggle )
#
# I/O advanced panel
#
self.__ioAdvancedPanel = qt.QFrame( ioCollapsibleButton )
self.__ioAdvancedPanel.hide()
self.__ioAdvancedPanel.setFrameStyle( 6 )
ioFormLayout.addRow( self.__ioAdvancedPanel )
self.__ioAdvancedToggle.connect( "clicked()", self.onIOAdvancedToggle )
ioAdvancedFormLayout = qt.QFormLayout( self.__ioAdvancedPanel )
# inputVolume selector
self.__vesselnessVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__vesselnessVolumeNodeSelector.objectName = 'vesselnessVolumeNodeSelector'
self.__vesselnessVolumeNodeSelector.toolTip = "Select the input vesselness volume. This is optional input."
self.__vesselnessVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__vesselnessVolumeNodeSelector.noneEnabled = True
self.__vesselnessVolumeNodeSelector.addEnabled = False
self.__vesselnessVolumeNodeSelector.removeEnabled = False
self.__vesselnessVolumeNodeSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", "0" )
ioAdvancedFormLayout.addRow( "Vesselness Volume:", self.__vesselnessVolumeNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__vesselnessVolumeNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
self.__vesselnessVolumeNodeSelector.setCurrentNode( None )
# stopper selector
self.__stopperFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.__stopperFiducialsNodeSelector.objectName = 'stopperFiducialsNodeSelector'
self.__stopperFiducialsNodeSelector.toolTip = "Select a hierarchy containing the fiducials to use as Stoppers. Whenever one stopper is reached, the segmentation stops."
self.__stopperFiducialsNodeSelector.nodeTypes = ['vtkMRMLAnnotationHierarchyNode']
self.__stopperFiducialsNodeSelector.baseName = "Stoppers"
self.__stopperFiducialsNodeSelector.noneEnabled = False
self.__stopperFiducialsNodeSelector.addEnabled = True
self.__stopperFiducialsNodeSelector.removeEnabled = False
ioAdvancedFormLayout.addRow( "Stoppers:", self.__stopperFiducialsNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__stopperFiducialsNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
# outputVolume selector
self.__outputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__outputVolumeNodeSelector.toolTip = "Select the output labelmap."
self.__outputVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__outputVolumeNodeSelector.baseName = "LevelSetSegmentation"
self.__outputVolumeNodeSelector.noneEnabled = False
self.__outputVolumeNodeSelector.addEnabled = True
self.__outputVolumeNodeSelector.selectNodeUponCreation = True
self.__outputVolumeNodeSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", "1" )
self.__outputVolumeNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow( "Output Labelmap:", self.__outputVolumeNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__outputVolumeNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
# outputModel selector
self.__outputModelNodeSelector = slicer.qMRMLNodeComboBox()
self.__outputModelNodeSelector.objectName = 'outputModelNodeSelector'
self.__outputModelNodeSelector.toolTip = "Select the output model."
self.__outputModelNodeSelector.nodeTypes = ['vtkMRMLModelNode']
self.__outputModelNodeSelector.baseName = "LevelSetSegmentationModel"
self.__outputModelNodeSelector.hideChildNodeTypes = ['vtkMRMLAnnotationNode'] # hide all annotation nodes
self.__outputModelNodeSelector.noneEnabled = False
self.__outputModelNodeSelector.addEnabled = True
self.__outputModelNodeSelector.selectNodeUponCreation = True
self.__outputModelNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow( "Output Model:", self.__outputModelNodeSelector )
self.parent.connect( 'mrmlSceneChanged(vtkMRMLScene*)',
self.__outputModelNodeSelector, 'setMRMLScene(vtkMRMLScene*)' )
#
# the segmentation panel
#
segmentationCollapsibleButton = ctk.ctkCollapsibleButton()
segmentationCollapsibleButton.text = "Segmentation"
self.layout.addWidget( segmentationCollapsibleButton )
segmentationFormLayout = qt.QFormLayout( segmentationCollapsibleButton )
# Threshold slider
thresholdLabel = qt.QLabel()
thresholdLabel.text = "Thresholding" + SlicerVmtkCommonLib.Helper.CreateSpace( 7 )
thresholdLabel.toolTip = "Choose the intensity range to segment."
thresholdLabel.setAlignment( 4 )
segmentationFormLayout.addRow( thresholdLabel )
self.__thresholdSlider = slicer.qMRMLRangeWidget()
segmentationFormLayout.addRow( self.__thresholdSlider )
self.__thresholdSlider.connect( 'valuesChanged(double,double)', self.onThresholdSliderChanged )
self.__segmentationAdvancedToggle = qt.QCheckBox( "Show Advanced Segmentation Properties" )
self.__segmentationAdvancedToggle.setChecked( False )
segmentationFormLayout.addRow( self.__segmentationAdvancedToggle )
#
# segmentation advanced panel
#
self.__segmentationAdvancedPanel = qt.QFrame( segmentationCollapsibleButton )
self.__segmentationAdvancedPanel.hide()
self.__segmentationAdvancedPanel.setFrameStyle( 6 )
segmentationFormLayout.addRow( self.__segmentationAdvancedPanel )
self.__segmentationAdvancedToggle.connect( "clicked()", self.onSegmentationAdvancedToggle )
segmentationAdvancedFormLayout = qt.QFormLayout( self.__segmentationAdvancedPanel )
# inflation slider
inflationLabel = qt.QLabel()
inflationLabel.text = "less inflation <-> more inflation" + SlicerVmtkCommonLib.Helper.CreateSpace( 14 )
inflationLabel.setAlignment( 4 )
inflationLabel.toolTip = "Define how fast the segmentation expands."
segmentationAdvancedFormLayout.addRow( inflationLabel )
self.__inflationSlider = ctk.ctkSliderWidget()
self.__inflationSlider.decimals = 0
self.__inflationSlider.minimum = -100
self.__inflationSlider.maximum = 100
self.__inflationSlider.singleStep = 10
self.__inflationSlider.toolTip = inflationLabel.toolTip
segmentationAdvancedFormLayout.addRow( self.__inflationSlider )
# curvature slider
curvatureLabel = qt.QLabel()
curvatureLabel.text = "less curvature <-> more curvature" + SlicerVmtkCommonLib.Helper.CreateSpace( 14 )
curvatureLabel.setAlignment( 4 )
curvatureLabel.toolTip = "Choose a high curvature to generate a smooth segmentation."
segmentationAdvancedFormLayout.addRow( curvatureLabel )
self.__curvatureSlider = ctk.ctkSliderWidget()
self.__curvatureSlider.decimals = 0
self.__curvatureSlider.minimum = -100
self.__curvatureSlider.maximum = 100
self.__curvatureSlider.singleStep = 10
self.__curvatureSlider.toolTip = curvatureLabel.toolTip
segmentationAdvancedFormLayout.addRow( self.__curvatureSlider )
# attraction slider
attractionLabel = qt.QLabel()
attractionLabel.text = "less attraction to gradient <-> more attraction to gradient" + SlicerVmtkCommonLib.Helper.CreateSpace( 14 )
attractionLabel.setAlignment( 4 )
attractionLabel.toolTip = "Configure how the segmentation travels towards gradient ridges (vessel lumen wall)."
segmentationAdvancedFormLayout.addRow( attractionLabel )
self.__attractionSlider = ctk.ctkSliderWidget()
self.__attractionSlider.decimals = 0
self.__attractionSlider.minimum = -100
self.__attractionSlider.maximum = 100
self.__attractionSlider.singleStep = 10
self.__attractionSlider.toolTip = attractionLabel.toolTip
segmentationAdvancedFormLayout.addRow( self.__attractionSlider )
# iteration spinbox
self.__iterationSpinBox = qt.QSpinBox()
self.__iterationSpinBox.minimum = 0
self.__iterationSpinBox.maximum = 5000
self.__iterationSpinBox.singleStep = 10
self.__iterationSpinBox.toolTip = "Choose the number of evolution iterations."
segmentationAdvancedFormLayout.addRow( SlicerVmtkCommonLib.Helper.CreateSpace( 100 ) + "Iterations:", self.__iterationSpinBox )
#
# Reset, preview and apply buttons
#
self.__buttonBox = qt.QDialogButtonBox()
self.__resetButton = self.__buttonBox.addButton( self.__buttonBox.RestoreDefaults )
self.__resetButton.toolTip = "Click to reset all input elements to default."
self.__previewButton = self.__buttonBox.addButton( self.__buttonBox.Discard )
self.__previewButton.setIcon( qt.QIcon() )
self.__previewButton.text = "Preview.."
self.__previewButton.toolTip = "Click to refresh the preview."
self.__startButton = self.__buttonBox.addButton( self.__buttonBox.Apply )
self.__startButton.setIcon( qt.QIcon() )
self.__startButton.text = "Start!"
self.__startButton.enabled = False
self.__startButton.toolTip = "Click to start the filtering."
self.layout.addWidget( self.__buttonBox )
self.__resetButton.connect( "clicked()", self.restoreDefaults )
self.__previewButton.connect( "clicked()", self.onRefreshButtonClicked )
self.__startButton.connect( "clicked()", self.onStartButtonClicked )
# be ready for events
self.__updating = 0
# set default values
self.restoreDefaults()
# compress the layout
self.layout.addStretch( 1 )
def __init__(self, anglePlanes, id, pointlocatordictionary):
qt.QFrame.__init__(self)
self.id = id
self.setLayout(qt.QFormLayout())
self.pointLocatorDictionary = pointlocatordictionary
landmarkLayout = qt.QHBoxLayout()
planeLabel = qt.QLabel('Plane ' + str(id) + ":")
landmarkLayout.addWidget(planeLabel)
self.logic = AnglePlanesLogic(id)
label1 = qt.QLabel(' L1:')
self.landmark1ComboBox = qt.QComboBox()
landmark1ComboBox = self.landmark1ComboBox
landmark1ComboBox.addItem("Select")
landmark1ComboBox.connect('currentIndexChanged(QString)', self.placePlaneClicked)
landmarkLayout.addWidget(label1)
landmarkLayout.addWidget(landmark1ComboBox)
label2 = qt.QLabel(' L2:')
self.landmark2ComboBox = qt.QComboBox()
landmark2ComboBox = self.landmark2ComboBox
landmark2ComboBox.addItem("Select")
landmark2ComboBox.connect('currentIndexChanged(QString)', self.placePlaneClicked)
landmarkLayout.addWidget(label2)
landmarkLayout.addWidget(landmark2ComboBox)
label3 = qt.QLabel(' L3:')
self.landmark3ComboBox = qt.QComboBox()
landmark3ComboBox = self.landmark3ComboBox
landmark3ComboBox.addItem("Select")
landmark3ComboBox.connect('currentIndexChanged(QString)', self.placePlaneClicked)
landmarkLayout.addWidget(label3)
landmarkLayout.addWidget(landmark3ComboBox)
addFiducialLabel = qt.QLabel('Add')
addFiducialButton = qt.QPushButton(qt.QIcon(":/Icons/MarkupsAddFiducial.png"), " ")
addFiducialButton.setFixedSize(50,25)
addFiducialButton.connect('clicked()', self.addLandMarkClicked)
addFiducialButton.setEnabled(True)
landmarkLayout.addWidget(addFiducialLabel)
landmarkLayout.addWidget(addFiducialButton)
#fiducial list for the plane
fidNode = self.logic.getFiducialList()
for i in range(0, fidNode.GetNumberOfFiducials()):
label = fidNode.GetNthFiducialLabel(i)
landmark1ComboBox.addItem(label)
landmark2ComboBox.addItem(label)
landmark3ComboBox.addItem(label)
anglePlanes.landmarkComboBox1MidPoint.addItem(label)
anglePlanes.landmarkComboBox2MidPoint.addItem(label)
anglePlanes.midPointFiducialDictionaryID[label] = fidNode.GetNthMarkupID(i)
fidNode.AddObserver(fidNode.MarkupAddedEvent, self.onFiducialAdded)
fidNode.AddObserver(fidNode.MarkupRemovedEvent, self.onFiducialRemoved)
self.setPointModifiedEventId = fidNode.AddObserver(fidNode.PointModifiedEvent, self.onPointModifiedEvent)
# This observers are in AnglePlaneWidgets, they listen to any fiducial being added
#
fidNode.AddObserver(fidNode.MarkupAddedEvent, anglePlanes.onFiducialAddedMidPoint)
fidNode.AddObserver(fidNode.MarkupRemovedEvent, anglePlanes.onFiducialRemovedMidPoint)
self.layout().addRow(landmarkLayout)
self.slider = ctk.ctkSliderWidget()
slider = self.slider
slider.singleStep = 0.1
slider.minimum = 0.1
slider.maximum = 10
slider.value = 1.0
slider.toolTip = "Set the size of your plane."
self.slideOpacity = ctk.ctkSliderWidget()
slideOpacity = self.slideOpacity
slideOpacity.singleStep = 0.1
slideOpacity.minimum = 0.1
slideOpacity.maximum = 1
slideOpacity.value = 1.0
slideOpacity.toolTip = "Set the opacity of your plane."
slider.connect('valueChanged(double)', self.placePlaneClicked)
slideOpacity.connect('valueChanged(double)', self.placePlaneClicked)
landmarkSliderLayout = qt.QHBoxLayout()
label = qt.QLabel(' Size:')
label2 = qt.QLabel(' Opacity:')
landmarkSliderLayout.addWidget(label)
landmarkSliderLayout.addWidget(self.slider)
landmarkSliderLayout.addWidget(label2)
landmarkSliderLayout.addWidget(self.slideOpacity)
self.surfaceDeplacementCheckBox = qt.QCheckBox("On Surface")
self.surfaceDeplacementCheckBox.setChecked(True)
self.surfaceDeplacementCheckBox.connect('stateChanged(int)', self.onSurfaceDeplacementStateChanged)
landmarkSliderLayout.addWidget(self.surfaceDeplacementCheckBox)
self.layout().addRow(landmarkSliderLayout)
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 = "LineProfile Reload"
reloadFormLayout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# input volume selector
#
self.inputVolumeSelector = slicer.qMRMLNodeComboBox()
self.inputVolumeSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
self.inputVolumeSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 0 )
self.inputVolumeSelector.selectNodeUponCreation = True
self.inputVolumeSelector.addEnabled = False
self.inputVolumeSelector.removeEnabled = False
self.inputVolumeSelector.noneEnabled = False
self.inputVolumeSelector.showHidden = False
self.inputVolumeSelector.showChildNodeTypes = False
self.inputVolumeSelector.setMRMLScene( slicer.mrmlScene )
self.inputVolumeSelector.setToolTip( "Pick the input to the algorithm which will be sampled along the line." )
parametersFormLayout.addRow("Input Volume: ", self.inputVolumeSelector)
#
# input ruler selector
#
self.inputRulerSelector = slicer.qMRMLNodeComboBox()
self.inputRulerSelector.nodeTypes = ( ("vtkMRMLAnnotationRulerNode"), "" )
self.inputRulerSelector.selectNodeUponCreation = True
self.inputRulerSelector.addEnabled = False
self.inputRulerSelector.removeEnabled = False
self.inputRulerSelector.noneEnabled = False
self.inputRulerSelector.showHidden = False
self.inputRulerSelector.showChildNodeTypes = False
self.inputRulerSelector.setMRMLScene( slicer.mrmlScene )
self.inputRulerSelector.setToolTip( "Pick the ruler that defines the sampling line." )
parametersFormLayout.addRow("Input ruler: ", self.inputRulerSelector)
#
# output volume selector
#
self.outputArraySelector = slicer.qMRMLNodeComboBox()
self.outputArraySelector.nodeTypes = ( ("vtkMRMLDoubleArrayNode"), "" )
self.outputArraySelector.addEnabled = True
self.outputArraySelector.removeEnabled = True
self.outputArraySelector.noneEnabled = False
self.outputArraySelector.showHidden = False
self.outputArraySelector.showChildNodeTypes = False
self.outputArraySelector.setMRMLScene( slicer.mrmlScene )
self.outputArraySelector.setToolTip( "Pick the output to the algorithm." )
parametersFormLayout.addRow("Output array: ", self.outputArraySelector)
#
# scale factor for screen shots
#
self.lineResolutionSliderWidget = ctk.ctkSliderWidget()
self.lineResolutionSliderWidget.singleStep = 1
self.lineResolutionSliderWidget.minimum = 2
self.lineResolutionSliderWidget.maximum = 1000
self.lineResolutionSliderWidget.value = 100
self.lineResolutionSliderWidget.setToolTip("Number of points to sample along the line.")
parametersFormLayout.addRow("Line resolution", self.lineResolutionSliderWidget)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
self.onSelect()
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputVolumeSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.inputRulerSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.outputArraySelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
# make an instance of the logic
self.logic = TwoTensorModelVizLogic()
#
# Model Selection Area
#
modelCollapsibleButton = ctk.ctkCollapsibleButton()
modelCollapsibleButton.text = "Basic"
self.layout.addWidget(modelCollapsibleButton)
modelFormLayout = qt.QFormLayout(modelCollapsibleButton)
# ============Fiber model selector===================
self.modelSelector = slicer.qMRMLNodeComboBox()
self.modelSelector.nodeTypes = ( ("vtkMRMLFiberBundleNode"), "" )
self.modelSelector.selectNodeUponCreation = True
self.modelSelector.addEnabled = False
self.modelSelector.removeEnabled = False
self.modelSelector.noneEnabled = False
self.modelSelector.showHidden = False
self.modelSelector.showChildNodeTypes = False
self.modelSelector.setMRMLScene( slicer.mrmlScene )
self.modelSelector.setToolTip( "Pick a bundle of fibers." )
modelFormLayout.addRow("Fiber bundles: ", self.modelSelector)
self.modelSelector.connect('currentNodeChanged(vtkMRMLNode*)', \
self.onModelSelect)
# ============Glyph Space scroller=================
self.sliderGlyphSpace = ctk.ctkSliderWidget()
self.sliderGlyphSpace.decimals = 0
self.sliderGlyphSpace.minimum=1
self.sliderGlyphSpace.maximum=100
self.sliderGlyphSpace.value=10
self.sliderGlyphSpace.enabled = False
modelFormLayout.addRow("Glyph Space:", self.sliderGlyphSpace)
self.sliderGlyphSpace.connect('valueChanged(double)', \
self.onGlyphSpaceChanged)
# ============Glyph Scale scroller=================
self.sliderGlyphScale = ctk.ctkSliderWidget()
self.sliderGlyphScale.decimals = 0
self.sliderGlyphScale.minimum=1
self.sliderGlyphScale.maximum=10000
self.sliderGlyphScale.value=2000
self.sliderGlyphScale.enabled = False
modelFormLayout.addRow("Glyph Scale:", self.sliderGlyphScale)
self.sliderGlyphScale.connect('valueChanged(double)', \
self.onGlyphScaleChanged)
modelGridLayout=qt.QGridLayout()
modelFormLayout.addRow("View Items:",modelGridLayout)
# ============Check Box for showing lines==============
self.checkboxLines=qt.QCheckBox("Lines")
self.checkboxLines.toolTip="When checked, fiber lines are shown."
self.checkboxLines.checked=True
self.checkboxLines.enabled=False
#modelFormLayout.addRow(self.checkboxLines)
modelGridLayout.addWidget(self.checkboxLines,0,0)
# ============Check Box for showing tensor 1==============
self.checkboxTensor1=qt.QCheckBox("Tensor 1")
self.checkboxTensor1.toolTip="When checked, cylinder glyphs are shown for tensor 1."
self.checkboxTensor1.checked=True
self.checkboxTensor1.enabled=False
modelGridLayout.addWidget(self.checkboxTensor1,0,1)
# ============Check Box for showing tensor 2==============
self.checkboxTensor2=qt.QCheckBox("Tensor 2")
self.checkboxTensor2.toolTip="When checked, cylinder glyphs are shown for tensor 2."
self.checkboxTensor2.checked=True
self.checkboxTensor2.enabled=False
modelGridLayout.addWidget(self.checkboxTensor2,0,2)
# ============Check Box for showing tube==============
self.checkboxTubes=qt.QCheckBox("Tubes")
self.checkboxTubes.toolTip="When checked, tubes will be shown."
self.checkboxTubes.checked=True
self.checkboxTubes.enabled=False
modelGridLayout.addWidget(self.checkboxTubes,0,3)
#
# Fiber Filter Area
#
filterCollapsibleButton = ctk.ctkCollapsibleButton()
filterCollapsibleButton.text = "Fiber Filter"
self.layout.addWidget(filterCollapsibleButton)
filterFormLayout = qt.QFormLayout(filterCollapsibleButton)
# ============Line Space scroller=================
self.sliderLineSpace = ctk.ctkSliderWidget()
self.sliderLineSpace.decimals = 0
self.sliderLineSpace.minimum=1
self.sliderLineSpace.maximum=100
self.sliderLineSpace.value=10
self.sliderLineSpace.enabled = False
filterFormLayout.addRow("One of n Fibers:", self.sliderLineSpace)
self.sliderLineSpace.connect('valueChanged(double)', \
self.onLineSpaceChanged)
# ============Line Num scroller=================
self.sliderLineNum = ctk.ctkSliderWidget()
self.sliderLineNum.decimals = 0
self.sliderLineNum.minimum=1
self.sliderLineNum.maximum=100
self.sliderLineNum.value=1
self.sliderLineNum.enabled = False
filterFormLayout.addRow("Specific Fiber No:", self.sliderLineNum)
self.sliderLineNum.connect('valueChanged(double)', \
self.onLineNumChanged)
# ============Check Box for showing one fiber==============
self.checkboxOnlyOneLine=qt.QCheckBox("Only show the specific fiber")
self.checkboxOnlyOneLine.toolTip="When checked, only the specified fiber is shown."
self.checkboxOnlyOneLine.checked=False
self.checkboxOnlyOneLine.enabled=False
filterFormLayout.addWidget(self.checkboxOnlyOneLine)
#
# Cylinder Color Mapping Area
#
cylinderColorCollapsibleButton = ctk.ctkCollapsibleButton()
cylinderColorCollapsibleButton.text = "Cylinder Boby Color"
self.layout.addWidget(cylinderColorCollapsibleButton)
cylinderVBoxLayOut = qt.QVBoxLayout(cylinderColorCollapsibleButton)
# Add a TabWidget
cylinderTabWidget=qt.QTabWidget()
cylinderVBoxLayOut.addWidget(cylinderTabWidget)
# Create four pages and the GridLayOut
redPage=qt.QWidget()
redGrid=qt.QGridLayout(redPage)
cylinderTabWidget.addTab(redPage,'Red')
greenPage=qt.QWidget()
greenGrid=qt.QGridLayout(greenPage)
cylinderTabWidget.addTab(greenPage,'Green')
bluePage=qt.QWidget()
blueGrid=qt.QGridLayout(bluePage)
cylinderTabWidget.addTab(bluePage,'Blue')
alphaPage=qt.QWidget()
alphaGrid=qt.QGridLayout(alphaPage)
cylinderTabWidget.addTab(alphaPage,'Alpha')
#========= Set the Red page ==============
groupBox=qt.QGroupBox()
grid = qt.QGridLayout(groupBox)
redGrid.addWidget(groupBox,0,1)
self.bodRadioR1=qt.QRadioButton("Fixed to:")
self.bodRadioR2=qt.QRadioButton("Mapped to:")
self.bodRadioR1.checked=True
self.bodSliderR = ctk.ctkSliderWidget()
self.bodSliderR.decimals = 0
self.bodSliderR.minimum=0
self.bodSliderR.maximum=255
self.bodSliderR.value=1
self.bodSliderR.enabled = True
self.bodComboR = qt.QComboBox()
self.bodComboR.duplicatesEnabled= False
grid.addWidget(self.bodRadioR1,0,0)
grid.addWidget(self.bodRadioR2,1,0)
grid.addWidget(self.bodSliderR,0,1)
grid.addWidget(self.bodComboR,1,1)
#========= Set the Green page ==============
groupBox=qt.QGroupBox()
grid = qt.QGridLayout(groupBox)
greenGrid.addWidget(groupBox,0,1)
self.bodRadioG1=qt.QRadioButton("Fixed to:")
self.bodRadioG2=qt.QRadioButton("Mapped to:")
self.bodRadioG1.checked=True
self.bodSliderG = ctk.ctkSliderWidget()
self.bodSliderG.decimals = 0
self.bodSliderG.minimum=0
self.bodSliderG.maximum=255
self.bodSliderG.value=1
self.bodSliderG.enabled = True
self.bodComboG = qt.QComboBox()
self.bodComboG.duplicatesEnabled= False
grid.addWidget(self.bodRadioG1,0,0)
grid.addWidget(self.bodRadioG2,1,0)
grid.addWidget(self.bodSliderG,0,1)
grid.addWidget(self.bodComboG,1,1)
#========= Set the Blue page ==============
groupBox=qt.QGroupBox()
grid = qt.QGridLayout(groupBox)
blueGrid.addWidget(groupBox,0,1)
self.bodRadioB1=qt.QRadioButton("Fixed to:")
self.bodRadioB2=qt.QRadioButton("Mapped to:")
self.bodRadioB1.checked=True
self.bodSliderB = ctk.ctkSliderWidget()
self.bodSliderB.decimals = 0
self.bodSliderB.minimum=0
self.bodSliderB.maximum=255
self.bodSliderB.value=1
self.bodSliderB.enabled = True
self.bodComboB = qt.QComboBox()
self.bodComboB.duplicatesEnabled= False
grid.addWidget(self.bodRadioB1,0,0)
grid.addWidget(self.bodRadioB2,1,0)
grid.addWidget(self.bodSliderB,0,1)
grid.addWidget(self.bodComboB,1,1)
#========= Set the Alpha page ==============
groupBox=qt.QGroupBox()
grid = qt.QGridLayout(groupBox)
alphaGrid.addWidget(groupBox,0,1)
self.bodRadioA1=qt.QRadioButton("Fixed to:")
self.bodRadioA2=qt.QRadioButton("Mapped to:")
self.bodRadioA1.checked=True
self.bodSliderA = ctk.ctkSliderWidget()
self.bodSliderA.decimals = 0
self.bodSliderA.minimum=0
self.bodSliderA.maximum=255
self.bodSliderA.value=1
self.bodSliderA.enabled = True
self.bodComboA = qt.QComboBox()
self.bodComboA.duplicatesEnabled= False
grid.addWidget(self.bodRadioA1,0,0)
grid.addWidget(self.bodRadioA2,1,0)
grid.addWidget(self.bodSliderA,0,1)
grid.addWidget(self.bodComboA,1,1)
#
# Tube Mapping Area
#
tubeColorCollapsibleButton = ctk.ctkCollapsibleButton()
tubeColorCollapsibleButton.text = "Tube Mapping"
self.layout.addWidget(tubeColorCollapsibleButton)
tubeVboxLayOut = qt.QVBoxLayout(tubeColorCollapsibleButton)
# Add a TabWidget
tubeTabWidget=qt.QTabWidget()
tubeVboxLayOut.addWidget(tubeTabWidget)
# Create three pages and the GridLayOut
tubeColorPage=qt.QWidget()
tubeColorGrid=qt.QGridLayout(tubeColorPage)
tubeTabWidget.addTab(tubeColorPage,'Color')
tubeSizePage=qt.QWidget()
tubeSizeGrid=qt.QGridLayout(tubeSizePage)
tubeTabWidget.addTab(tubeSizePage,'Size')
#========= Set the color page ==============
groupBox=qt.QGroupBox()
grid = qt.QGridLayout(groupBox)
tubeColorGrid.addWidget(groupBox,0,0)
self.tubeRadioFixedTo=qt.QRadioButton("Fixed to")
self.tubeRadioByOrientation=qt.QRadioButton("Color by orientation")
self.tubeRadioSameAsCylinderBody=qt.QRadioButton("Same as Cylinder Body")
self.tubeRadioByOrientation.checked=True
grid.addWidget(self.tubeRadioFixedTo,0,0)
grid.addWidget(self.tubeRadioByOrientation,1,0)
grid.addWidget(self.tubeRadioSameAsCylinderBody,2,0)
self.tubeColorButton=qt.QPushButton('Specifying Color')
self.tubeColorButton.setAutoFillBackground(True)
grid.addWidget(self.tubeColorButton,0,1)
self.tubeColorButton.connect('clicked()', \
self.onTubeFixedColor)
#========= Set the size page ==============
self.tubeSizeRadio1=qt.QRadioButton("Fixed to:")
self.tubeSizeRadio2=qt.QRadioButton("Mapped to:")
self.tubeSizeRadio1.checked=True
self.tubeSizeSlider = ctk.ctkSliderWidget()
self.tubeSizeSlider.decimals = 2
self.tubeSizeSlider.minimum=0.0
self.tubeSizeSlider.maximum=5.0
self.tubeSizeSlider.value=0.1
self.tubeSizeSlider.enabled = True
self.tubeComboBox = qt.QComboBox()
self.tubeComboBox.duplicatesEnabled= False
tubeSizeGrid.addWidget(self.tubeSizeRadio1,0,0)
tubeSizeGrid.addWidget(self.tubeSizeRadio2,1,0)
tubeSizeGrid.addWidget(self.tubeSizeSlider,0,1)
tubeSizeGrid.addWidget(self.tubeComboBox,1,1)
# ============Scale scroller=================
label=qt.QLabel('Tube Scale:')
self.sliderTubeScale = ctk.ctkSliderWidget()
self.sliderTubeScale.decimals = 0
self.sliderTubeScale.minimum=1
self.sliderTubeScale.maximum=100
self.sliderTubeScale.value=5
self.sliderTubeScale.enabled = False
tubeSizeGrid.addWidget(label,2,0)
tubeSizeGrid.addWidget(self.sliderTubeScale,2,1)
self.sliderTubeScale.connect('valueChanged(double)', \
self.onTubeScaleChanged)
#
# ============Apply button=================
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Apply the visualization."
self.applyButton.enabled = False
self.applyButton.setPalette(qt.QPalette(qt.QColor(128,255,128)))
self.parent.layout().addWidget(self.applyButton)
self.applyButton.connect('clicked()', \
self.onApply)
#
# ============Clear button=================
#
self.clearButton = qt.QPushButton("Clear")
self.clearButton.toolTip = "Clear objects rendered in 3D view windows."
self.clearButton.enabled = False
self.clearButton.setPalette(qt.QPalette(qt.QColor(255,128,128)))
self.parent.layout().addWidget(self.clearButton)
self.clearButton.connect('clicked()', \
self.onClear)
# ===========Finally, Add vertical spacer================
self.layout.addStretch(2)
def __init__(self,logic):
super(VisualizationWidget,self).__init__()
self.logic = logic
self.volumes = ("Fixed", "Moving", "Transformed",)
self.layoutOptions = ("Axial", "Coronal", "Sagittal", "Axi/Sag/Cor",)
self.layoutOption = 'Axi/Sag/Cor'
self.volumeDisplayCheckboxes = {}
# mimic the structure of the LandmarksWidget for visual
# consistency (it needs sub widget so it can delete and refresh the internals)
self.widget = qt.QWidget()
self.layout = qt.QFormLayout(self.widget)
self.boxHolder = qt.QWidget()
self.boxHolder.setLayout(qt.QVBoxLayout())
self.layout.addRow(self.boxHolder)
self.groupBox = qt.QGroupBox("Visualization")
self.groupBoxLayout = qt.QFormLayout(self.groupBox)
self.boxHolder.layout().addWidget(self.groupBox)
#
# layout selection
#
layoutHolder = qt.QWidget()
layout = qt.QHBoxLayout()
layoutHolder.setLayout(layout)
for layoutOption in self.layoutOptions:
layoutButton = qt.QPushButton(layoutOption)
layoutButton.connect('clicked()', lambda lo=layoutOption: self.selectLayout(lo))
layout.addWidget(layoutButton)
self.groupBoxLayout.addRow("Layout", layoutHolder)
#
# Volume display selection
#
checkboxHolder = qt.QWidget()
layout = qt.QHBoxLayout()
checkboxHolder.setLayout(layout)
for volume in self.volumes:
checkBox = qt.QCheckBox()
checkBox.text = volume
checkBox.checked = True
checkBox.connect('toggled(bool)', self.updateVisualization)
layout.addWidget(checkBox)
self.volumeDisplayCheckboxes[volume] = checkBox
self.groupBoxLayout.addRow("Display", checkboxHolder)
#
# fade slider
#
self.fadeSlider = ctk.ctkSliderWidget()
self.fadeSlider.minimum = 0
self.fadeSlider.maximum = 1.0
self.fadeSlider.value = 0.5
self.fadeSlider.singleStep = 0.05
self.fadeSlider.connect('valueChanged(double)', self.onFadeChanged)
self.groupBoxLayout.addRow("Cross Fade", self.fadeSlider)
#
# zoom control
#
zoomHolder = qt.QWidget()
layout = qt.QHBoxLayout()
zoomHolder.setLayout(layout)
zooms = {"+": 0.9, "-": 1.1, "Fit": "Fit",}
for zoomLabel,zoomFactor in zooms.items():
zoomButton = qt.QPushButton(zoomLabel)
zoomButton.connect('clicked()', lambda zf=zoomFactor: self.onZoom(zf))
layout.addWidget(zoomButton)
self.groupBoxLayout.addRow("Zoom", zoomHolder)
def createUserInterface(self):
self.__layout = self.__parent.createUserInterface()
'''
# Input fiducials node selector
#self.inputFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.inputFiducialsNodeSelector.toolTip = "Select a fiducial to define an insertion point for a screw."
self.inputFiducialsNodeSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "")
self.inputFiducialsNodeSelector.addEnabled = False
self.inputFiducialsNodeSelector.removeEnabled = False
self.inputFiducialsNodeSelector.setMRMLScene( slicer.mrmlScene )
self.inputFiducialsNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.fidChanged)
self.__layout.addRow("Select Insertion Point:", self.inputFiducialsNodeSelector)
self.fid = self.inputFiducialsNodeSelector.currentNode()
self.sliceChange()
'''
'''
# Input model selector
self.inputScrewSelector = ctk.ctkComboBox()
self.inputScrewSelector.toolTip = "Select a screw to insert."
screwList = ['Select a screw','475x30', '475x35', '475x45', '550x30', '550x40', '550x45', '625x35', '625x40', '625x45', '625x50', '700x35', '700x40', '700x45', '700x50']
self.inputScrewSelector.addItems(screwList)
self.connect(self.inputScrewSelector, PythonQt.QtCore.SIGNAL('activated(QString)'), self.combo_chosen)
self.__layout.addRow("Choose Screw:", self.inputScrewSelector)
vText = qt.QLabel("1st Instrumented Level:")
iText = qt.QLabel("# to Instrument:")
aText = qt.QLabel("Approach Direction:")
self.vSelector = qt.QComboBox()
self.vSelector.setMaximumWidth(120)
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")
self.vSelector.addItems(self.levels)
self.iSelector = qt.QComboBox()
self.iSelector.setMaximumWidth(120)
self.iSelector.addItems(['1','2','3','4','5','6','7','8','9','10','11','12'])
self.aSelector = qt.QComboBox()
self.aSelector.setMaximumWidth(120)
self.aSelector.addItems(['Posterior','Anterior','Left','Right'])
blank = qt.QLabel(" ")
blank.setMaximumWidth(30)
#self.__layout.addWidget(vText)
#self.__layout.addWidget(self.vSelector)
#self.__layout.addWidget(iText)
#self.__layout.addWidget(self.iSelector)
self.vertebraeGridBox = qt.QGridLayout()
self.vertebraeGridBox.addWidget(vText,0,0)
self.vertebraeGridBox.addWidget(self.vSelector,1,0)
self.vertebraeGridBox.addWidget(blank,0,1)
self.vertebraeGridBox.addWidget(iText,0,2)
self.vertebraeGridBox.addWidget(blank,1,1)
self.vertebraeGridBox.addWidget(self.iSelector,1,2)
self.vertebraeGridBox.addWidget(blank,0,3)
self.vertebraeGridBox.addWidget(aText,0,4)
self.vertebraeGridBox.addWidget(blank,1,3)
self.vertebraeGridBox.addWidget(self.aSelector,1,4)
self.__layout.addRow(self.vertebraeGridBox)
'''
self.fiducial = ctk.ctkComboBox()
self.fiducial.toolTip = "Select an insertion site."
self.fiducial.addItems(self.fiduciallist)
self.connect(self.fiducial,
PythonQt.QtCore.SIGNAL('activated(QString)'),
self.fiducial_chosen)
#self.screwGridLayout.addWidget(self.fiducial,0,0)
self.__layout.addRow("Insertion Site:", self.fiducial)
self.__fiducial = ''
measuredText1 = qt.QLabel(" Measured:")
measuredText2 = qt.QLabel(" Measured:")
lengthText = qt.QLabel("Screw Length: ")
widthText = qt.QLabel("Screw Width: ")
self.length = ctk.ctkComboBox()
self.length.toolTip = "Select a screw to insert."
screwList = ['Select a length (mm)', '475', '550', '625', '700']
self.length.addItems(screwList)
self.connect(self.length, PythonQt.QtCore.SIGNAL('activated(QString)'),
self.length_chosen)
self.lengthMeasure = qt.QLineEdit()
#self.__layout.addRow("Screw Length:", self.length)
#self.__layout.addRow("Measured Pedicle Length:", self.lengthMeasure)
self.__length = ''
self.QHBox1 = qt.QHBoxLayout()
self.QHBox1.addWidget(lengthText)
self.QHBox1.addWidget(self.length)
self.QHBox1.addWidget(measuredText1)
self.QHBox1.addWidget(self.lengthMeasure)
self.__layout.addRow(self.QHBox1)
self.diameter = ctk.ctkComboBox()
self.diameter.toolTip = "Select a screw to insert."
screwList = ['Select a diameter (mm)', '30', '35', '45', '50']
self.diameter.addItems(screwList)
self.widthMeasure = qt.QLineEdit()
self.connect(self.diameter,
PythonQt.QtCore.SIGNAL('activated(QString)'),
self.diameter_chosen)
#self.__layout.addRow("Screw Diameter:", self.diameter)
#self.__layout.addRow("Measured Pedicle Width:", self.widthMeasure)
self.__diameter = ''
self.QHBox2 = qt.QHBoxLayout()
self.QHBox2.addWidget(widthText)
self.QHBox2.addWidget(self.diameter)
self.QHBox2.addWidget(measuredText2)
self.QHBox2.addWidget(self.widthMeasure)
self.__layout.addRow(self.QHBox2)
# Load Screw Button
self.__loadScrewButton = qt.QPushButton("Load Screw")
self.__loadScrewButton.enabled = False
#self.__layout.addWidget(self.__loadScrewButton)
self.__loadScrewButton.connect('clicked(bool)', self.loadScrew)
# Delete Screw Button
self.__delScrewButton = qt.QPushButton("Delete Screw")
self.__delScrewButton.enabled = True
#self.__layout.addWidget(self.__delScrewButton)
self.__delScrewButton.connect('clicked(bool)', self.delScrew)
self.QHBox3 = qt.QHBoxLayout()
self.QHBox3.addWidget(self.__loadScrewButton)
self.QHBox3.addWidget(self.__delScrewButton)
self.__layout.addRow(self.QHBox3)
# Input model node selector
self.modelNodeSelector = slicer.qMRMLNodeComboBox()
self.modelNodeSelector.toolTip = "."
self.modelNodeSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.modelNodeSelector.addEnabled = False
self.modelNodeSelector.removeEnabled = False
self.modelNodeSelector.setMRMLScene(slicer.mrmlScene)
#self.__layout.addRow("Current Screws:", self.modelNodeSelector)
self.transformGrid = qt.QGridLayout()
vText = qt.QLabel("Vertical Adjustment:")
iText = qt.QLabel("Horizontal Adjustment:")
self.transformGrid.addWidget(vText, 0, 0)
self.transformGrid.addWidget(iText, 0, 2)
self.b = ctk.ctkDoubleSpinBox()
self.b.minimum = -45
self.b.maximum = 45
self.transformGrid.addWidget(self.b, 1, 0)
# Transform Sliders
self.transformSlider1 = ctk.ctkDoubleSlider()
self.transformSlider1.minimum = -45
self.transformSlider1.maximum = 45
self.transformSlider1.connect('valueChanged(double)',
self.transformSlider1ValueChanged)
self.transformSlider1.connect('valueChanged(double)', self.b.setValue)
self.transformSlider1.setMinimumHeight(120)
#self.__layout.addRow("Rotate IS", self.transformSlider1)
self.transformGrid.addWidget(self.transformSlider1, 1, 1)
self.b.connect('valueChanged(double)', self.transformSlider1.setValue)
# Transform Sliders
self.transformSlider2 = ctk.ctkSliderWidget()
self.transformSlider2.minimum = -45
self.transformSlider2.maximum = 45
self.transformSlider2.connect('valueChanged(double)',
self.transformSlider2ValueChanged)
self.transformSlider2.setMaximumWidth(200)
#self.__layout.addRow("Rotate LR", self.transformSlider2)
self.transformGrid.addWidget(self.transformSlider2, 1, 2)
self.__layout.addRow(self.transformGrid)
'''
# Transfors Sliders
self.transformSlider3 = ctk.ctkSliderWidget()
self.transformSlider3.minimum = 0
self.transformSlider3.maximum = 100
self.transformSlider3.connect('valueChanged(double)', self.transformSlider3ValueChanged)
self.__layout.addRow("Drive Screw", self.transformSlider3)
'''
# Insert Screw Button
self.insertScrewButton = qt.QPushButton("Insert Screw")
self.insertScrewButton.enabled = True
#self.__layout.addWidget(self.__loadScrewButton)
self.insertScrewButton.connect('clicked(bool)', self.insertScrew)
# Backout Screw Button
self.backoutScrewButton = qt.QPushButton("Backout Screw")
self.backoutScrewButton.enabled = False
#self.__layout.addWidget(self.__delScrewButton)
self.backoutScrewButton.connect('clicked(bool)', self.backoutScrew)
# Reset Screw Button
self.resetScrewButton = qt.QPushButton("Reset Screw")
self.resetScrewButton.enabled = True
#self.__layout.addWidget(self.__delScrewButton)
self.resetScrewButton.connect('clicked(bool)', self.resetScrew)
self.QHBox4 = qt.QHBoxLayout()
self.QHBox4.addWidget(self.insertScrewButton)
self.QHBox4.addWidget(self.backoutScrewButton)
self.QHBox4.addWidget(self.resetScrewButton)
self.__layout.addRow(self.QHBox4)
# Hide ROI Details
#measurementsTable = ctk.ctkCollapsibleButton()
#measurementsTable.text = "Measurements Table"
#self.__layout.addWidget(measurementsTable)
#measurementsTable.collapsed = True
'''
self.view = qt.QTableView()
self.model = qt.QStandardItemModel()
self.view.setModel(self.model)
item = qt.QStandardItem()
item.setText("item")
self.model.setItem(0,0,item)
self.__layout.addWidget(self.view)
'''
#self.__layout.addRow(self.screwGridLayout)
# self.updateWidgetFromParameters(self.parameterNode())
qt.QTimer.singleShot(0, self.killButton)
self.currentFidIndex = self.fiducial.currentIndex
self.currentFidLabel = self.fiducial.currentText
self.fidNode.GetNthFiducialPosition(self.currentFidIndex, self.coords)
logging.debug("Coords: {0}".format(self.coords))
self.updateMeasurements()
self.cameraFocus(self.coords)
def setup(self):
# Instantiate and connect widgets ...
self.ApplicatorModel = None
self.ApplicatorTrajectoryModel = None
self.DamageTemplateModel = None
self.SolverDamageModel = None
self.SourceLandmarkFileName = "./SourceLandmarks"
self.TargetLandmarkFileName = "./TargetLandmarks"
# define constant parameters
# diffusing tip is 10. mm axial
# diffusing tip is 1.5 mm radial
self.DiffusingTipLength = 10. #mm
self.DiffusingTipRadius = .75 #mm
# In canine brain and transmissible venereal tumours, up to 18.11.4mm lesions were achieved. It is concluded
self.AblationMinorAxis = 18.0/2. #mm
self.AblationMajorAxis = 22.0/2. #mm
#
# Reload and Test area
#
reloadCollapsibleButton = ctk.ctkCollapsibleButton()
reloadCollapsibleButton.text = "Main"
self.layout.addWidget(reloadCollapsibleButton)
reloadFormLayout = qt.QFormLayout(reloadCollapsibleButton)
if self.developerMode:
# 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 = "PyLITTPlan 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 fiducials node selector
inputFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
inputFiducialsNodeSelector.nodeTypes = ['vtkMRMLMarkupsFiducialNode', 'vtkMRMLAnnotationHierarchyNode', 'vtkMRMLFiducialListNode']
inputFiducialsNodeSelector.objectName = 'inputFiducialsNodeSelector'
inputFiducialsNodeSelector.selectNodeUponCreation = True
inputFiducialsNodeSelector.noneEnabled = False
inputFiducialsNodeSelector.addEnabled = False
inputFiducialsNodeSelector.removeEnabled = False
inputFiducialsNodeSelector.showHidden = False
inputFiducialsNodeSelector.showChildNodeTypes = False
inputFiducialsNodeSelector.setMRMLScene( slicer.mrmlScene )
self.inputFiducialsNodeSelector = inputFiducialsNodeSelector
inputFiducialsNodeSelector.toolTip = "Select a fiducial list to define control points for the path."
reloadFormLayout.addRow("Input Fiducials:", self.inputFiducialsNodeSelector)
#
# output volume selector
#
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
self.outputSelector.addAttribute( "vtkMRMLScalarVolumeNode", "LabelMap", 1 )
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." )
reloadFormLayout.addRow("Output Volume: ", self.outputSelector)
#
# Power Value
#
self.PowerValueSliderWidget = ctk.ctkSliderWidget()
self.PowerValueSliderWidget.singleStep = 0.5
self.PowerValueSliderWidget.minimum = 1.0
self.PowerValueSliderWidget.maximum = 30.0
self.PowerValueSliderWidget.value = 12.0
self.PowerValueSliderWidget.setToolTip("Set Power Value")
reloadFormLayout.addRow("Power [W]", self.PowerValueSliderWidget)
#
# Time Length Value
#
self.TimeValueSliderWidget = ctk.ctkSliderWidget()
self.TimeValueSliderWidget.singleStep = 5.0
self.TimeValueSliderWidget.minimum = 5.0
self.TimeValueSliderWidget.maximum = 300.0
self.TimeValueSliderWidget.value = 50.0
self.TimeValueSliderWidget.setToolTip("Laser On Duration")
reloadFormLayout.addRow("Time [s]", self.TimeValueSliderWidget)
#
# Damage Iso Value
#
self.DamageValueSliderWidget = ctk.ctkSliderWidget()
self.DamageValueSliderWidget.singleStep = 1.0
self.DamageValueSliderWidget.minimum = 0.01
self.DamageValueSliderWidget.maximum = 100.0
self.DamageValueSliderWidget.value = 57.0
self.DamageValueSliderWidget.setToolTip("Set Damage Value")
reloadFormLayout.addRow("Damage", self.DamageValueSliderWidget)
#
# Locate Applicator Button
#
self.referenceButton = qt.QPushButton("Locate Applicator")
self.referenceButton.toolTip = "Locate the Applicator for Reference"
self.referenceButton.enabled = False
reloadFormLayout.addRow(self.referenceButton)
#
# Treat Button
#
self.applyButton = qt.QPushButton("Treat")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
reloadFormLayout.addRow(self.applyButton)
#
# Damage Iso Value
#
self.PullBackValueSliderWidget = ctk.ctkSliderWidget()
self.PullBackValueSliderWidget.singleStep = 0.5
self.PullBackValueSliderWidget.minimum = -80.0
self.PullBackValueSliderWidget.maximum = 80.0
self.PullBackValueSliderWidget.value = 0.0
self.PullBackValueSliderWidget.setToolTip("Set Pullback Length")
reloadFormLayout.addRow("Pullback [mm]", self.PullBackValueSliderWidget)
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
parametersCollapsibleButton.collapsed = True
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# 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.PerfusionValueSliderWidget = ctk.ctkSliderWidget()
self.PerfusionValueSliderWidget.singleStep = 1.0
self.PerfusionValueSliderWidget.minimum = 0.0
self.PerfusionValueSliderWidget.maximum = 50.0
self.PerfusionValueSliderWidget.value = 6.0
self.PerfusionValueSliderWidget.setToolTip("Set Perfusion Value")
parametersFormLayout.addRow("Perfusion [kg/s/m^3]", self.PerfusionValueSliderWidget)
#
# scale factor for screen shots
#
self.AbsorptionValueSliderWidget = ctk.ctkSliderWidget()
self.AbsorptionValueSliderWidget.singleStep = 0.5
self.AbsorptionValueSliderWidget.minimum = 0.05
self.AbsorptionValueSliderWidget.maximum = 5.e2
self.AbsorptionValueSliderWidget.value = 5.0
self.AbsorptionValueSliderWidget.setToolTip("Set mu_a Value")
parametersFormLayout.addRow("mu_a [1/m]", self.AbsorptionValueSliderWidget)
# connections
self.inputFiducialsNodeSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.referenceButton.connect('clicked(bool)', self.onReferenceButton)
self.applyButton.connect('clicked(bool)', self.onApplyButton)
# 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)
#
# 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 = True
self.outputSelector.addEnabled = True
self.outputSelector.removeEnabled = True
self.outputSelector.noneEnabled = True
self.outputSelector.showHidden = False
self.outputSelector.showChildNodeTypes = False
self.outputSelector.setMRMLScene(slicer.mrmlScene)
self.outputSelector.setToolTip("Pick the output to the algorithm.")
parametersFormLayout.addRow("Output Volume: ", self.outputSelector)
#
# threshold value
#
self.imageThresholdSliderWidget = ctk.ctkSliderWidget()
self.imageThresholdSliderWidget.singleStep = 0.1
self.imageThresholdSliderWidget.minimum = -100
self.imageThresholdSliderWidget.maximum = 100
self.imageThresholdSliderWidget.value = 0.5
self.imageThresholdSliderWidget.setToolTip(
"Set threshold value for computing the output image. Voxels that have intensities lower than this value will set to zero."
)
parametersFormLayout.addRow("Image threshold",
self.imageThresholdSliderWidget)
#
# check box to trigger taking screen shots for later use in tutorials
#
self.enableScreenshotsFlagCheckBox = qt.QCheckBox()
self.enableScreenshotsFlagCheckBox.checked = 0
self.enableScreenshotsFlagCheckBox.setToolTip(
"If checked, take screen shots for tutorials. Use Save Data to write them to disk."
)
parametersFormLayout.addRow("Enable Screenshots",
self.enableScreenshotsFlagCheckBox)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
# Refresh Apply button state
self.onSelect()
def setup(self):
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
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)
#
# 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.")
parametersFormLayout.addRow("Screenshot scale factor", self.screenshotScaleFactorSliderWidget)
#
# 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 ...
#
# 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 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):
# check if the SlicerVmtk module is installed properly
# self.__vmtkInstalled = SlicerVmtkCommonLib.Helper.CheckIfVmtkIsInstalled()
# Helper.Debug("VMTK found: " + self.__vmtkInstalled)
#
# the I/O panel
#
ioCollapsibleButton = ctk.ctkCollapsibleButton()
ioCollapsibleButton.text = "Input/Output"
self.layout.addWidget(ioCollapsibleButton)
ioFormLayout = qt.QFormLayout(ioCollapsibleButton)
# inputVolume selector
self.__inputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__inputVolumeNodeSelector.objectName = "inputVolumeNodeSelector"
self.__inputVolumeNodeSelector.toolTip = "Select the input volume."
self.__inputVolumeNodeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.__inputVolumeNodeSelector.noneEnabled = False
self.__inputVolumeNodeSelector.addEnabled = False
self.__inputVolumeNodeSelector.removeEnabled = False
self.__inputVolumeNodeSelector.addAttribute("vtkMRMLScalarVolumeNode", "LabelMap", "0")
ioFormLayout.addRow("Input Volume:", self.__inputVolumeNodeSelector)
self.parent.connect(
"mrmlSceneChanged(vtkMRMLScene*)", self.__inputVolumeNodeSelector, "setMRMLScene(vtkMRMLScene*)"
)
self.__inputVolumeNodeSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onInputVolumeChanged)
# seed selector
self.__seedFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.__seedFiducialsNodeSelector.objectName = "seedFiducialsNodeSelector"
self.__seedFiducialsNodeSelector.toolTip = "Select a fiducial to use as a Seed to detect the maximal diameter."
self.__seedFiducialsNodeSelector.nodeTypes = ["vtkMRMLAnnotationFiducialNode"]
self.__seedFiducialsNodeSelector.baseName = "DiameterSeed"
self.__seedFiducialsNodeSelector.noneEnabled = False
self.__seedFiducialsNodeSelector.addEnabled = False
self.__seedFiducialsNodeSelector.removeEnabled = False
ioFormLayout.addRow("Seed in largest Vessel:", self.__seedFiducialsNodeSelector)
self.parent.connect(
"mrmlSceneChanged(vtkMRMLScene*)", self.__seedFiducialsNodeSelector, "setMRMLScene(vtkMRMLScene*)"
)
self.__seedFiducialsNodeSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSeedChanged)
self.__ioAdvancedToggle = qt.QCheckBox("Show Advanced Properties")
self.__ioAdvancedToggle.setChecked(False)
ioFormLayout.addRow(self.__ioAdvancedToggle)
#
# I/O advanced panel
#
self.__ioAdvancedPanel = qt.QFrame(ioCollapsibleButton)
self.__ioAdvancedPanel.hide()
self.__ioAdvancedPanel.setFrameStyle(6)
ioFormLayout.addRow(self.__ioAdvancedPanel)
self.__ioAdvancedToggle.connect("clicked()", self.onIOAdvancedToggle)
ioAdvancedFormLayout = qt.QFormLayout(self.__ioAdvancedPanel)
# lock button
self.__detectPushButton = qt.QPushButton()
self.__detectPushButton.text = "Detect parameters automatically"
self.__detectPushButton.checkable = True
self.__detectPushButton.checked = True
# self.__unLockPushButton.connect("clicked()", self.calculateParameters())
ioAdvancedFormLayout.addRow(self.__detectPushButton)
# outputVolume selector
self.__outputVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__outputVolumeNodeSelector.toolTip = "Select the output labelmap."
self.__outputVolumeNodeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.__outputVolumeNodeSelector.baseName = "VesselnessFiltered"
self.__outputVolumeNodeSelector.noneEnabled = False
self.__outputVolumeNodeSelector.addEnabled = True
self.__outputVolumeNodeSelector.selectNodeUponCreation = True
self.__outputVolumeNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow("Output Volume:", self.__outputVolumeNodeSelector)
self.parent.connect(
"mrmlSceneChanged(vtkMRMLScene*)", self.__outputVolumeNodeSelector, "setMRMLScene(vtkMRMLScene*)"
)
# previewVolume selector
self.__previewVolumeNodeSelector = slicer.qMRMLNodeComboBox()
self.__previewVolumeNodeSelector.toolTip = "Select the preview volume."
self.__previewVolumeNodeSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.__previewVolumeNodeSelector.baseName = "VesselnessPreview"
self.__previewVolumeNodeSelector.noneEnabled = False
self.__previewVolumeNodeSelector.addEnabled = True
self.__previewVolumeNodeSelector.selectNodeUponCreation = True
self.__previewVolumeNodeSelector.removeEnabled = True
ioAdvancedFormLayout.addRow("Preview Volume:", self.__previewVolumeNodeSelector)
self.parent.connect(
"mrmlSceneChanged(vtkMRMLScene*)", self.__previewVolumeNodeSelector, "setMRMLScene(vtkMRMLScene*)"
)
self.__minimumDiameterSpinBox = qt.QSpinBox()
self.__minimumDiameterSpinBox.minimum = 0
self.__minimumDiameterSpinBox.maximum = 1000
self.__minimumDiameterSpinBox.singleStep = 1
self.__minimumDiameterSpinBox.toolTip = "Specify the minimum Diameter manually."
ioAdvancedFormLayout.addRow("Minimum Diameter [vx]:", self.__minimumDiameterSpinBox)
self.__maximumDiameterSpinBox = qt.QSpinBox()
self.__maximumDiameterSpinBox.minimum = 0
self.__maximumDiameterSpinBox.maximum = 1000
self.__maximumDiameterSpinBox.singleStep = 1
self.__maximumDiameterSpinBox.toolTip = "Specify the maximum Diameter manually."
ioAdvancedFormLayout.addRow("Maximum Diameter [vx]:", self.__maximumDiameterSpinBox)
# add empty row
ioAdvancedFormLayout.addRow("", qt.QWidget())
# alpha slider
alphaLabel = qt.QLabel()
alphaLabel.text = "more Tubes <-> more Plates" + SlicerVmtkCommonLib.Helper.CreateSpace(16)
alphaLabel.setAlignment(4)
alphaLabel.toolTip = "A lower value detects tubes rather than plate-like structures."
ioAdvancedFormLayout.addRow(alphaLabel)
self.__alphaSlider = ctk.ctkSliderWidget()
self.__alphaSlider.decimals = 1
self.__alphaSlider.minimum = 0.1
self.__alphaSlider.maximum = 500
self.__alphaSlider.singleStep = 0.1
self.__alphaSlider.toolTip = alphaLabel.toolTip
ioAdvancedFormLayout.addRow(self.__alphaSlider)
# beta slider
betaLabel = qt.QLabel()
betaLabel.text = "more Blobs <-> more Tubes" + SlicerVmtkCommonLib.Helper.CreateSpace(16)
betaLabel.setAlignment(4)
betaLabel.toolTip = "A higher value detects tubes rather than blobs."
ioAdvancedFormLayout.addRow(betaLabel)
self.__betaSlider = ctk.ctkSliderWidget()
self.__betaSlider.decimals = 1
self.__betaSlider.minimum = 0.1
self.__betaSlider.maximum = 500
self.__betaSlider.singleStep = 0.1
self.__betaSlider.toolTip = betaLabel.toolTip
ioAdvancedFormLayout.addRow(self.__betaSlider)
# contrast slider
contrastLabel = qt.QLabel()
contrastLabel.text = "low Input Contrast <-> high Input Contrast" + SlicerVmtkCommonLib.Helper.CreateSpace(14)
contrastLabel.setAlignment(4)
contrastLabel.toolTip = "If the intensity contrast in the input image between vessel and background is high, choose a high value else choose a low value."
ioAdvancedFormLayout.addRow(contrastLabel)
self.__contrastSlider = ctk.ctkSliderWidget()
self.__contrastSlider.decimals = 0
self.__contrastSlider.minimum = 0
self.__contrastSlider.maximum = 500
self.__contrastSlider.singleStep = 10
self.__contrastSlider.toolTip = contrastLabel.toolTip
ioAdvancedFormLayout.addRow(self.__contrastSlider)
#
# Reset, preview and apply buttons
#
self.__buttonBox = qt.QDialogButtonBox()
self.__resetButton = self.__buttonBox.addButton(self.__buttonBox.RestoreDefaults)
self.__resetButton.toolTip = "Click to reset all input elements to default."
self.__previewButton = self.__buttonBox.addButton(self.__buttonBox.Discard)
self.__previewButton.setIcon(qt.QIcon())
self.__previewButton.text = "Preview.."
self.__previewButton.toolTip = "Click to refresh the preview."
self.__startButton = self.__buttonBox.addButton(self.__buttonBox.Apply)
self.__startButton.setIcon(qt.QIcon())
self.__startButton.text = "Start!"
self.__startButton.enabled = False
self.__startButton.toolTip = "Click to start the filtering."
self.layout.addWidget(self.__buttonBox)
self.__resetButton.connect("clicked()", self.restoreDefaults)
self.__previewButton.connect("clicked()", self.onRefreshButtonClicked)
self.__startButton.connect("clicked()", self.onStartButtonClicked)
# be ready for events
self.__updating = 0
# set default values
self.restoreDefaults()
# compress the layout
self.layout.addStretch(1)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Instantiate and connect widgets ...
self.logic = BreachWarningLightLogic()
#
# 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.breachWarningSelector = slicer.qMRMLNodeComboBox()
self.breachWarningSelector.nodeTypes = ( ("vtkMRMLBreachWarningNode"), "" )
self.breachWarningSelector.selectNodeUponCreation = True
self.breachWarningSelector.addEnabled = False
self.breachWarningSelector.removeEnabled = False
self.breachWarningSelector.noneEnabled = False
self.breachWarningSelector.showHidden = False
self.breachWarningSelector.showChildNodeTypes = False
self.breachWarningSelector.setMRMLScene( slicer.mrmlScene )
self.breachWarningSelector.setToolTip( "Pick the breach warning node to observe." )
parametersFormLayout.addRow("Breach warning node: ", self.breachWarningSelector)
#
# output volume selector
#
self.connectorSelector = slicer.qMRMLNodeComboBox()
self.connectorSelector.nodeTypes = ( ("vtkMRMLIGTLConnectorNode"), "" )
self.connectorSelector.selectNodeUponCreation = True
self.connectorSelector.addEnabled = False
self.connectorSelector.removeEnabled = False
self.connectorSelector.noneEnabled = False
self.connectorSelector.showHidden = False
self.connectorSelector.showChildNodeTypes = False
self.connectorSelector.setMRMLScene( slicer.mrmlScene )
self.connectorSelector.setToolTip( "Pick the OpenIGTLink connector node to send light control commands to" )
parametersFormLayout.addRow("Connector: ", self.connectorSelector)
#
# marginSizeMm value
#
self.marginSizeMmSliderWidget = ctk.ctkSliderWidget()
self.marginSizeMmSliderWidget.singleStep = 0.1
self.marginSizeMmSliderWidget.minimum = 0
self.marginSizeMmSliderWidget.maximum = 10
self.marginSizeMmSliderWidget.value = 2.0
self.marginSizeMmSliderWidget.setToolTip("Set the desired margin size in mm. Light pattern will indicate 'good position' if the distance is smaller than this value.")
parametersFormLayout.addRow("Margin size (mm)", self.marginSizeMmSliderWidget)
#
# check box to trigger taking screen shots for later use in tutorials
#
self.enableLightFeedbackFlagCheckBox = qt.QCheckBox()
self.enableLightFeedbackFlagCheckBox.checked = 0
self.enableLightFeedbackFlagCheckBox.setToolTip("If checked, then light pattern will be updated whenever the breach warning state is changed.")
parametersFormLayout.addRow("Enable light feedback", self.enableLightFeedbackFlagCheckBox)
# connections
self.enableLightFeedbackFlagCheckBox.connect('stateChanged(int)', self.setEnableLightFeedback)
self.marginSizeMmSliderWidget.connect('valueChanged(double)', self.setMarginChanged)
# 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 setup(self):
# Instantiate and connect widgets ...
# Reload button
# (use this during development, but remove it when delivering
# your module to users)
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload this module."
self.reloadButton.name = "CMRToolkitRegistration Reload"
self.layout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
# Register Volume collapsible button
collapsibleButton = ctk.ctkCollapsibleButton()
collapsibleButton.text = "Register Volume"
self.layout.addWidget(collapsibleButton)
# Layout within the dummy collapsible button
formLayout = qt.QFormLayout(collapsibleButton)
# The image volume selectors
self.fixedFrame = qt.QFrame(collapsibleButton)
self.fixedFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.fixedFrame)
self.fixedSelector = qt.QLabel("Image Volume One (Fixed): ", self.fixedFrame)
self.fixedFrame.layout().addWidget(self.fixedSelector)
self.fixedSelector = slicer.qMRMLNodeComboBox(self.fixedFrame)
self.fixedSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
self.fixedSelector.addEnabled = False
self.fixedSelector.removeEnabled = False
self.fixedSelector.renameEnabled = True
self.fixedSelector.setMRMLScene( slicer.mrmlScene )
self.fixedFrame.layout().addWidget(self.fixedSelector)
self.movingFrame = qt.QFrame(collapsibleButton)
self.movingFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.movingFrame)
self.movingSelector = qt.QLabel("Image Volume Two (Moving): ", self.movingFrame)
self.movingFrame.layout().addWidget(self.movingSelector)
self.movingSelector = slicer.qMRMLNodeComboBox(self.movingFrame)
self.movingSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
self.movingSelector.addEnabled = False
self.movingSelector.removeEnabled = False
self.movingSelector.renameEnabled = True
self.movingSelector.setMRMLScene( slicer.mrmlScene )
self.movingFrame.layout().addWidget(self.movingSelector)
self.outputFrame = qt.QFrame(collapsibleButton)
self.outputFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.outputFrame)
self.outputSelector = qt.QLabel("Output Image Volume: ", self.outputFrame)
self.outputFrame.layout().addWidget(self.outputSelector)
self.outputSelector = slicer.qMRMLNodeComboBox(self.outputFrame)
self.outputSelector.nodeTypes = ( ("vtkMRMLScalarVolumeNode"), "" )
self.outputSelector.setMRMLScene( slicer.mrmlScene )
self.outputSelector.addEnabled = True
self.outputSelector.renameEnabled = True
self.outputSelector.baseName = "Registered Volume"
self.outputFrame.layout().addWidget(self.outputSelector)
# Imaging Modality selection
self.presetFrame = qt.QFrame(collapsibleButton)
self.presetFrame.setLayout(qt.QHBoxLayout())
formLayout.addWidget(self.presetFrame)
self.presetSelector = qt.QLabel("Imaging Modality: ", self.presetFrame)
self.presetFrame.layout().addWidget(self.presetSelector)
self.presetComboBox = qt.QComboBox()
self.presetComboBox.addItem("LGE-MRI to LGE-MRI")
self.presetComboBox.addItem("MRA to LGE-MRI")
self.presetComboBox.addItem("MRA to MRA")
self.presetComboBox.addItem("CT to LGE-MRI")
self.presetComboBox.addItem("Acute Scar to LGE-MRI")
self.presetComboBox.setCurrentIndex(-1)
self.presetFrame.layout().addWidget(self.presetComboBox)
# Connect Imaging Modality widget to parameters widgets
self.presetComboBox.connect('currentIndexChanged(QString)', self.setParameters)
# Check box
self.cropCheckBox = qt.QCheckBox("Image volumes are cropped to area around LA", collapsibleButton)
self.cropCheckBox.toolTip = "For best registration, indicate whether the volumes have been cropped to the LA ROI"
formLayout.addWidget(self.cropCheckBox)
# Connect check box to registration parameters
self.cropCheckBox.connect('stateChanged(int)', self.croppedImagesParameters)
# Register Volume button
registerButton = qt.QPushButton("Apply Registration")
registerButton.toolTip = "Register Volume Two (Moving) onto Volume One (Fixed)."
formLayout.addWidget(registerButton)
registerButton.connect('clicked(bool)', self.onRegisterButtonClicked)
# Advanced Registration Parameters collapsible button
collapsibleButton2 = ctk.ctkCollapsibleButton()
collapsibleButton2.text = "Advanced Registration Parameters"
collapsibleButton2.collapsedHeight = 350
collapsibleButton2.collapsed = True
self.layout.addWidget(collapsibleButton2)
formLayout2 = qt.QFormLayout(collapsibleButton2)
# Registration options
self.regnFrame = qt.QFrame(collapsibleButton2)
self.regnFrame.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.regnFrame)
self.regnSelector = qt.QLabel("Select the Type of Registration: ", self.regnFrame)
self.regnFrame.layout().addWidget(self.regnSelector)
self.regnComboBox = qt.QComboBox()
self.regnComboBox.addItem("Rigid")
self.regnComboBox.addItem("Affine")
self.regnComboBox.addItem("BSpline")
self.regnComboBox.addItem("PipelineRigid")
self.regnComboBox.addItem("PipelineAffine")
self.regnComboBox.addItem("PipelineBSpline")
self.regnComboBox.setCurrentIndex(-1)
self.regnFrame.layout().addWidget(self.regnComboBox)
# Metric options
self.metFrame = qt.QFrame(collapsibleButton2)
self.metFrame.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.metFrame)
self.metSelector = qt.QLabel("Select the Type of Metric: ", self.metFrame)
self.metFrame.layout().addWidget(self.metSelector)
self.metComboBox = qt.QComboBox()
self.metComboBox.setLayout(qt.QHBoxLayout())
self.metComboBox.addItem("MattesMI")
self.metComboBox.addItem("NormCorr")
self.metComboBox.addItem("MeanSqrd")
self.metComboBox.setCurrentIndex(-1)
self.metFrame.layout().addWidget(self.metComboBox)
# Initialization options
self.initFrame = qt.QFrame(collapsibleButton2)
self.initFrame.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.initFrame)
self.initSelector = qt.QLabel("Select the Type of Initialization: ", self.initFrame)
self.initFrame.layout().addWidget(self.initSelector)
self.initComboBox = qt.QComboBox()
self.initComboBox.setLayout(qt.QHBoxLayout())
self.initComboBox.addItem("ImageCenters")
self.initComboBox.addItem("CentersOfMass")
self.initComboBox.addItem("SecondMoments")
self.initComboBox.setCurrentIndex(-1)
self.initFrame.layout().addWidget(self.initComboBox)
# Interpolation options
self.interpFrame = qt.QFrame(collapsibleButton2)
self.interpFrame.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.interpFrame)
self.interpSelector = qt.QLabel("Select the Type of Interpolation: ", self.interpFrame)
self.interpFrame.layout().addWidget(self.interpSelector)
self.interpComboBox = qt.QComboBox()
self.interpComboBox.setLayout(qt.QHBoxLayout())
self.interpComboBox.addItem("NearestNeighbor")
self.interpComboBox.addItem("Linear")
self.interpComboBox.addItem("BSpline")
self.interpComboBox.setCurrentIndex(-1)
self.interpFrame.layout().addWidget(self.interpComboBox)
# Maximum number of iterations
self.iterFrame = qt.QFrame(collapsibleButton2)
self.iterFrame.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.iterFrame)
self.iterEditSelector = qt.QLabel("Enter the Maximum Number of Iterations: ", self.iterFrame)
self.iterFrame.layout().addWidget(self.iterEditSelector)
self.iterSpinBox = qt.QSpinBox()
self.iterSpinBox.setLayout(qt.QHBoxLayout())
self.iterSpinBox.setMinimum(1)
self.iterSpinBox.setMaximum(2000)
self.iterSpinBox.setValue(0)
self.iterSpinBox.toolTip = "The maximum number of iterations to try before failing to converge."
self.iterFrame.layout().addWidget(self.iterSpinBox)
# Sampling Ratio Slider
self.sampframe = qt.QFrame(collapsibleButton2)
self.sampframe.setLayout(qt.QHBoxLayout())
formLayout2.addWidget(self.sampframe)
self.sampSliderSelector = qt.QLabel("Sampling Ratio (Accuracy of Registration): ", self.sampframe)
self.sampframe.layout().addWidget(self.sampSliderSelector)
self.sampSliderFrame = ctk.ctkSliderWidget()
self.sampSliderFrame.minimum = 0
self.sampSliderFrame.maximum = 1
self.sampSliderFrame.decimals = 2
self.sampSliderFrame.singleStep = 0.01
self.sampframe.layout().addWidget(self.sampSliderFrame)
# Sample from fixed/moving overlap check box
self.sampleCheckBox = qt.QCheckBox("Sample from fixed/moving image overlap", collapsibleButton2)
self.sampleCheckBox.toolTip = "Limit metric evaluation to the fixed image region overlapped by the moving image"
formLayout2.addWidget(self.sampleCheckBox)
# Set local var as instance attribute
self.registerButton = registerButton
def setup(self):
# Instantiate and connect widgets ...
# reload button
self.reloadButton = qt.QPushButton("Reload")
self.reloadButton.toolTip = "Reload this module."
self.reloadButton.name = "Regmatic Reload"
self.layout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
#
# io Collapsible button
#
ioCollapsibleButton = ctk.ctkCollapsibleButton()
ioCollapsibleButton.text = "Volume and Transform Parameters"
self.layout.addWidget(ioCollapsibleButton)
# Layout within the parameter collapsible button
ioFormLayout = qt.QFormLayout(ioCollapsibleButton)
# Fixed Volume node selector
self.fixedSelector = slicer.qMRMLNodeComboBox()
self.fixedSelector.objectName = 'fixedSelector'
self.fixedSelector.toolTip = "The fixed volume."
self.fixedSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.fixedSelector.noneEnabled = False
self.fixedSelector.addEnabled = False
self.fixedSelector.removeEnabled = False
ioFormLayout.addRow("Fixed Volume:", self.fixedSelector)
self.fixedSelector.setMRMLScene(slicer.mrmlScene)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.fixedSelector, 'setMRMLScene(vtkMRMLScene*)')
# Moving Volume node selector
self.movingSelector = slicer.qMRMLNodeComboBox()
self.movingSelector.objectName = 'movingSelector'
self.movingSelector.toolTip = "The moving volume."
self.movingSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.movingSelector.noneEnabled = False
self.movingSelector.addEnabled = False
self.movingSelector.removeEnabled = False
ioFormLayout.addRow("Moving Volume:", self.movingSelector)
self.movingSelector.setMRMLScene(slicer.mrmlScene)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.movingSelector, 'setMRMLScene(vtkMRMLScene*)')
# Fiducial node selector
self.__fiducialSelector = slicer.qMRMLNodeComboBox()
self.__fiducialSelector.objectName = 'fiducialSelector'
self.__fiducialSelector.toolTip = "The fiducial."
self.__fiducialSelector.nodeTypes = ['vtkMRMLAnnotationFiducialNode']
self.__fiducialSelector.noneEnabled = False
self.__fiducialSelector.addEnabled = False
self.__fiducialSelector.removeEnabled = False
ioFormLayout.addRow("Fiducial:", self.__fiducialSelector)
self.__fiducialSelector.setMRMLScene(slicer.mrmlScene)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.__fiducialSelector, 'setMRMLScene(vtkMRMLScene*)')
#check button for moving rotation point
self.__moverotCenterButton = qt.QCheckBox()
self.__moverotCenterButton.setEnabled(1)
moverotLabel = qt.QLabel('Define fiducial point as rotation center')
ioFormLayout.addRow(moverotLabel, self.__moverotCenterButton)
self.__moverotCenterButton.connect('stateChanged(int)', self.updateLogicFromGUI)
# Transform node selector
self.transformSelector = slicer.qMRMLNodeComboBox()
self.transformSelector.objectName = 'transformSelector'
self.transformSelector.toolTip = "The transform volume."
self.transformSelector.nodeTypes = ['vtkMRMLLinearTransformNode']
self.transformSelector.noneEnabled = False
self.transformSelector.addEnabled = False
self.transformSelector.removeEnabled = False
ioFormLayout.addRow("Moving To Fixed Transform:", self.transformSelector)
self.transformSelector.setMRMLScene(slicer.mrmlScene)
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.transformSelector, 'setMRMLScene(vtkMRMLScene*)')
selectors = (self.fixedSelector, self.movingSelector, self.transformSelector,self.__fiducialSelector)
for selector in selectors:
selector.connect('currentNodeChanged(vtkMRMLNode*)', self.updateLogicFromGUI)
#
# opt Collapsible button
#
optCollapsibleButton = ctk.ctkCollapsibleButton()
optCollapsibleButton.text = "Optimizer Parameters"
self.layout.addWidget(optCollapsibleButton)
# Layout within the parameter collapsible button
optFormLayout = qt.QFormLayout(optCollapsibleButton)
# gradient window slider
self.sampleSpacingSlider = ctk.ctkSliderWidget()
self.sampleSpacingSlider.decimals = 2
self.sampleSpacingSlider.singleStep = 0.01
self.sampleSpacingSlider.minimum = 0.01
self.sampleSpacingSlider.maximum = 100
self.sampleSpacingSlider.toolTip = "Multiple of spacing used when extracting pixels to evaluate objective function"
optFormLayout.addRow("Sample Spacing:", self.sampleSpacingSlider)
# gradient window slider
self.gradientWindowSlider = ctk.ctkSliderWidget()
self.gradientWindowSlider.decimals = 2
self.gradientWindowSlider.singleStep = 0.01
self.gradientWindowSlider.minimum = 0.01
self.gradientWindowSlider.maximum = 5
self.gradientWindowSlider.toolTip = "Multiple of spacing used when estimating objective function gradient"
optFormLayout.addRow("Gradient Window:", self.gradientWindowSlider)
# step size slider
self.stepSizeSlider = ctk.ctkSliderWidget()
self.stepSizeSlider.decimals = 2
self.stepSizeSlider.singleStep = 0.01
self.stepSizeSlider.minimum = 0.01
self.stepSizeSlider.maximum = 20
self.stepSizeSlider.toolTip = "Multiple of spacing used when taking an optimization step"
optFormLayout.addRow("Rotation Step Size:", self.stepSizeSlider)
# get default values from logic
self.sampleSpacingSlider.value = self.logic.sampleSpacing
self.gradientWindowSlider.value = self.logic.gradientWindow
self.stepSizeSlider.value = self.logic.stepSize
sliders = (self.sampleSpacingSlider, self.gradientWindowSlider, self.stepSizeSlider)
for slider in sliders:
slider.connect('valueChanged(double)', self.updateLogicFromGUI)
# Run button
self.runButton = qt.QPushButton("Interaction")
self.runButton.toolTip = "Run registration bot."
self.runButton.checkable = True
optFormLayout.addRow(self.runButton)
self.runButton.connect('toggled(bool)', self.onRunButtonToggled)
# Optimize button
self.optimizeButton = qt.QPushButton("Optimize Translation")
self.optimizeButton.toolTip = "Run optimization."
self.optimizeButton.checkable = True
optFormLayout.addRow(self.optimizeButton)
self.optimizeButton.connect('toggled(bool)', self.onOptimizeButtonToggled)
# Optimize Rotation button
self.optimizeRotationButton = qt.QPushButton("Optimize Rotation")
self.optimizeRotationButton.toolTip = "Run optimization."
self.optimizeRotationButton.checkable = True
optFormLayout.addRow(self.optimizeRotationButton)
self.optimizeRotationButton.connect('toggled(bool)', self.onOptimizeRotationButtonToggled)
# to support quicker development:
import os
if os.getenv('USERNAME') == 'guillaume' or os.getenv('USERNAME') == 'Guillaume':
self.logic.testingData()
self.fixedSelector.setCurrentNode(slicer.util.getNode('MRHead*'))
self.movingSelector.setCurrentNode(slicer.util.getNode('neutral*'))
self.transformSelector.setCurrentNode(slicer.util.getNode('movingToFixed*'))
# 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)
#
# input fiducial list selector
#
fiducialWarningLabel = qt.QLabel("Note: Parent transforms of fiducials are not used. Fiducials should be defined in the coordinate system that is being registered.")
fiducialWarningLabel.setWordWrap(True)
parametersFormLayout.addRow(fiducialWarningLabel)
self.inputFiducialSelector = slicer.qMRMLNodeComboBox()
self.inputFiducialSelector.nodeTypes = (("vtkMRMLMarkupsFiducialNode"), "")
self.inputFiducialSelector.selectNodeUponCreation = True
self.inputFiducialSelector.addEnabled = False
self.inputFiducialSelector.removeEnabled = False
self.inputFiducialSelector.noneEnabled = False
self.inputFiducialSelector.showHidden = False
self.inputFiducialSelector.showChildNodeTypes = False
self.inputFiducialSelector.setMRMLScene(slicer.mrmlScene)
self.inputFiducialSelector.setToolTip("Pick the input fiducial list for the algorithm.")
parametersFormLayout.addRow("Input fiducials: ", self.inputFiducialSelector)
#
# input model selector
#
self.inputModelSelector = slicer.qMRMLNodeComboBox()
self.inputModelSelector.nodeTypes = (("vtkMRMLModelNode"), "")
self.inputModelSelector.selectNodeUponCreation = True
self.inputModelSelector.addEnabled = False
self.inputModelSelector.removeEnabled = False
self.inputModelSelector.noneEnabled = False
self.inputModelSelector.showHidden = False
self.inputModelSelector.showChildNodeTypes = False
self.inputModelSelector.setMRMLScene(slicer.mrmlScene)
self.inputModelSelector.setToolTip("Pick the input model for the algorithm.")
parametersFormLayout.addRow("Input model: ", self.inputModelSelector)
#
# output transform selector
#
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = (("vtkMRMLLinearTransformNode"), "")
self.outputSelector.selectNodeUponCreation = True
self.outputSelector.addEnabled = True
self.outputSelector.removeEnabled = True
self.outputSelector.noneEnabled = False
self.outputSelector.showHidden = False
self.outputSelector.showChildNodeTypes = False
self.outputSelector.renameEnabled = True
self.outputSelector.setMRMLScene(slicer.mrmlScene)
self.outputSelector.setToolTip("Pick the output to the algorithm.")
parametersFormLayout.addRow("Output transform: ", self.outputSelector)
#
# check box to trigger taking screen shots for later use in tutorials
#
self.enableScreenshotsFlagCheckBox = qt.QCheckBox()
self.enableScreenshotsFlagCheckBox.checked = 0
self.enableScreenshotsFlagCheckBox.setToolTip("If checked, take screen shots for tutorials. Use Save Data to write them to disk.")
# parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox)
#
# scale factor for screen shots
#
self.screenshotScaleFactorSliderWidget = ctk.ctkSliderWidget()
self.screenshotScaleFactorSliderWidget.singleStep = 1.0
self.screenshotScaleFactorSliderWidget.minimum = 1.0
self.screenshotScaleFactorSliderWidget.maximum = 50.0
self.screenshotScaleFactorSliderWidget.value = 1.0
self.screenshotScaleFactorSliderWidget.setToolTip("Set scale factor for the screen shots.")
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
#
# Output panel
#
outputCollapsibleButton = ctk.ctkCollapsibleButton()
outputCollapsibleButton.text = "Output"
self.layout.addWidget(outputCollapsibleButton)
outputFormLayout = qt.QFormLayout(outputCollapsibleButton)
self.outputLine = qt.QLineEdit()
self.outputLine.setReadOnly(True)
outputFormLayout.addRow("Mean distance after registration:", self.outputLine)
#
# Advanced parameters
#
advancedCollapsibleButton = ctk.ctkCollapsibleButton()
advancedCollapsibleButton.text = "Advanced"
self.layout.addWidget(advancedCollapsibleButton)
# Layout
advancedCollapsibleButton.collapsed = True
advancedFormLayout = qt.QFormLayout(advancedCollapsibleButton)
#
# Transform type selector
#
self.typeSelector = qt.QComboBox()
self.typeSelector.insertItem(0, "Rigid")
self.typeSelector.insertItem(1, "Similarity")
self.typeSelector.insertItem(2, "Affine")
advancedFormLayout.addRow("Transform type: ", self.typeSelector)
#
# Iteration selector
#
self.iterationSpin = qt.QSpinBox()
self.iterationSpin.setMaximum(1000)
self.iterationSpin.setValue(100)
advancedFormLayout.addRow("Number of iterations:", self.iterationSpin)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputModelSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.inputFiducialSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
# Instantiate the logic class
self.logic = FiducialsToModelRegistrationLogic()
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Instantiate and connect widgets ...
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# input volume selector
#
self.inputSelector = slicer.qMRMLNodeComboBox()
self.inputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.inputSelector.selectNodeUponCreation = True
self.inputSelector.addEnabled = False
self.inputSelector.removeEnabled = False
self.inputSelector.noneEnabled = False
self.inputSelector.showHidden = False
self.inputSelector.showChildNodeTypes = False
self.inputSelector.setMRMLScene( slicer.mrmlScene )
self.inputSelector.setToolTip( "Pick the input to the algorithm." )
parametersFormLayout.addRow("Input Volume: ", self.inputSelector)
#
# output volume selector
#
self.outputSelector = slicer.qMRMLNodeComboBox()
self.outputSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.outputSelector.selectNodeUponCreation = True
self.outputSelector.addEnabled = True
self.outputSelector.removeEnabled = True
self.outputSelector.noneEnabled = True
self.outputSelector.showHidden = False
self.outputSelector.showChildNodeTypes = False
self.outputSelector.setMRMLScene( slicer.mrmlScene )
self.outputSelector.setToolTip( "Pick the output to the algorithm." )
parametersFormLayout.addRow("Output Volume: ", self.outputSelector)
#
# threshold value
#
self.imageThresholdSliderWidget = ctk.ctkSliderWidget()
self.imageThresholdSliderWidget.singleStep = 0.1
self.imageThresholdSliderWidget.minimum = -100
self.imageThresholdSliderWidget.maximum = 100
self.imageThresholdSliderWidget.value = 0.5
self.imageThresholdSliderWidget.setToolTip("Set threshold value for computing the output image. Voxels that have intensities lower than this value will set to zero.")
parametersFormLayout.addRow("Image threshold", self.imageThresholdSliderWidget)
#
# check box to trigger taking screen shots for later use in tutorials
#
self.enableScreenshotsFlagCheckBox = qt.QCheckBox()
self.enableScreenshotsFlagCheckBox.checked = 0
self.enableScreenshotsFlagCheckBox.setToolTip("If checked, take screen shots for tutorials. Use Save Data to write them to disk.")
parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.outputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
# Refresh Apply button state
self.onSelect()
def setup(self):
self.PathRecorderModuleDirectoryPath = slicer.modules.pathrecorder.path.replace(
"PathRecorder.py", "")
# 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 = "PathRecorder 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 fiducial node selector
#
self.inputFiducialsNodeSelector = slicer.qMRMLNodeComboBox()
self.inputFiducialsNodeSelector.nodeTypes = [
'vtkMRMLMarkupsFiducialNode'
]
self.inputFiducialsNodeSelector.selectNodeUponCreation = True
self.inputFiducialsNodeSelector.addEnabled = True
self.inputFiducialsNodeSelector.removeEnabled = False
self.inputFiducialsNodeSelector.noneEnabled = True
self.inputFiducialsNodeSelector.showHidden = False
self.inputFiducialsNodeSelector.showChildNodeTypes = False
self.inputFiducialsNodeSelector.setMRMLScene(slicer.mrmlScene)
self.inputFiducialsNodeSelector.objectName = 'inputFiducialsNodeSelector'
self.inputFiducialsNodeSelector.toolTip = "Select storage node for the recorded points (Markup-Fiducial-Node)."
#inputFiducialsNodeSelector.connect('currentNodeChanged(bool)', self.enableOrDisableCreateButton)
parametersFormLayout.addRow("Storage Node:",
self.inputFiducialsNodeSelector)
#self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', inputFiducialsNodeSelector, 'setMRMLScene(vtkMRMLScene*)')
# Input Tracker node selector
#
self.inputTrackerNodeSelector = slicer.qMRMLNodeComboBox()
self.inputTrackerNodeSelector.nodeTypes = [
'vtkMRMLLinearTransformNode'
]
self.inputTrackerNodeSelector.selectNodeUponCreation = True
self.inputTrackerNodeSelector.addEnabled = False
self.inputTrackerNodeSelector.removeEnabled = False
self.inputTrackerNodeSelector.noneEnabled = True
self.inputTrackerNodeSelector.showHidden = False
self.inputTrackerNodeSelector.showChildNodeTypes = False
self.inputTrackerNodeSelector.setMRMLScene(slicer.mrmlScene)
self.inputTrackerNodeSelector.objectName = 'inputTrackerNodeSelector'
self.inputTrackerNodeSelector.toolTip = "Select the tracker linear transform node."
#inputTrackerNodeSelector.connect('currentNodeChanged(bool)', self.enableOrDisableCreateButton)
parametersFormLayout.addRow("Tracker Transform:",
self.inputTrackerNodeSelector)
#self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', inputTrackerNodeSelector, 'setMRMLScene(vtkMRMLScene*)')
#
# Status Area
#
statusCollapsibleButton = ctk.ctkCollapsibleButton()
statusCollapsibleButton.text = "Tracker Status"
self.layout.addWidget(statusCollapsibleButton)
# Layout within the status collapsible button
statusFormLayout = qt.QFormLayout(statusCollapsibleButton)
#
# Status Button
#
self.statusRedIcon = qt.QIcon(self.PathRecorderModuleDirectoryPath +
'/Resources/Icons/icon_DotRed.png')
self.statusGreenIcon = qt.QIcon(self.PathRecorderModuleDirectoryPath +
'/Resources/Icons/icon_DotGreen.png')
self.statusButton = qt.QPushButton("")
#self.statusButton.toolTip = "Tracker Status"
self.statusButton.enabled = False
self.statusButton.setIcon(self.statusRedIcon)
self.statusButton.setMaximumWidth(25)
# Bold and large font for needle label
largeFont = qt.QFont()
largeFont.setPixelSize(14)
#
# Label for showing the tracker position
#
self.currentCoordinatesLabel = qt.QLabel('[ NaN , NaN , NaN ]')
self.currentCoordinatesLabel.setToolTip("Tracker Position")
statusFormLayout.addRow(self.statusButton,
self.currentCoordinatesLabel)
#
# Collect Area
#
collectCollapsibleButton = ctk.ctkCollapsibleButton()
collectCollapsibleButton.text = "Acquire Points"
self.layout.addWidget(collectCollapsibleButton)
# Layout within the collect collapsible button
collectFormLayout = qt.QFormLayout(collectCollapsibleButton)
#
# Name base line-edit
#
self.nameBaseLineEdit = qt.QLineEdit()
self.nameBaseLineEdit.setToolTip("Fiducials Name Base")
collectFormLayout.addRow("Fiducials Name Base:", self.nameBaseLineEdit)
#
# Single Acquire Button
#
self.singleAcquireButton = qt.QPushButton("Single Point")
self.singleAcquireButton.toolTip = "Acquire a single point at the current position."
self.singleAcquireButton.enabled = True
collectFormLayout.addRow(self.singleAcquireButton)
#
# Continuous Acquire Button
#
self.recordButtonIcon = qt.QIcon(self.PathRecorderModuleDirectoryPath +
'/Resources/Icons/icon_Record.png')
self.stopButtonIcon = qt.QIcon(self.PathRecorderModuleDirectoryPath +
'/Resources/Icons/icon_Stop.png')
self.acquireButton = qt.QPushButton("Continuous")
self.acquireButton.toolTip = "Start acquiring points continiously."
self.acquireButton.enabled = True
self.acquireButton.checkable = True
self.acquireButton.setIcon(self.recordButtonIcon)
#self.acquireButton.setMinimumWidth(80)
#self.acquireButton.setMaximumWidth(80)
collectFormLayout.addRow(self.acquireButton)
#
# Distance-based Radio Button
#
self.distanceBasedButton = qt.QRadioButton("Minimum Distance:")
self.distanceBasedButton.setChecked(1)
#collectFormLayout.addRow()
# Distance slider
distanceSlider = ctk.ctkSliderWidget()
#distanceSlider.decimals = 0
distanceSlider.minimum = 0.1
distanceSlider.maximum = 100
distanceSlider.suffix = " mm"
distanceSlider.value = 1
distanceSlider.toolTip = "Set minimum distance between recorded points"
self.distanceSlider = distanceSlider
collectFormLayout.addRow("Minimum Distance:", distanceSlider)
#
# Delete Button
#
self.deleteButton = qt.QPushButton("Delete")
self.deleteButton.toolTip = "Delete all the points."
self.deleteButton.enabled = True
collectFormLayout.addRow(self.deleteButton)
#
# Export Area
#
exportCollapsibleButton = ctk.ctkCollapsibleButton()
exportCollapsibleButton.text = "Export Points"
self.layout.addWidget(exportCollapsibleButton)
# Layout within the dummy collapsible button
exportFormLayout = qt.QFormLayout(exportCollapsibleButton)
#
# Load Button
#
self.exportDirectoryButton = ctk.ctkDirectoryButton()
exportFormLayout.addRow(self.exportDirectoryButton)
#
# Name base line-edit
#
self.fileNameBaseLineEdit = qt.QLineEdit()
self.fileNameBaseLineEdit.setToolTip("File name base")
self.fileNameBaseLineEdit.text = 'PathRecorder'
exportFormLayout.addRow("File Name Base:", self.fileNameBaseLineEdit)
#
# Save Button
#
saveButtonIcon = qt.QIcon(self.PathRecorderModuleDirectoryPath +
'/Resources/Icons/icon_Save.png')
self.exportButton = qt.QPushButton()
self.exportButton.setIcon(saveButtonIcon)
self.exportButton.toolTip = "Save points."
self.exportButton.enabled = True
exportFormLayout.addRow(self.exportButton)
# connections
self.inputFiducialsNodeSelector.connect(
'currentNodeChanged(vtkMRMLNode*)',
self.setAnnotationHierarchyNode)
self.inputTrackerNodeSelector.connect(
'currentNodeChanged(vtkMRMLNode*)', self.setTransformNode)
self.distanceBasedButton.connect('toggled(bool)',
self.distanceBasedSelected)
self.acquireButton.connect('toggled(bool)',
self.onAcquireButtonToggled)
self.singleAcquireButton.connect('clicked()',
self.onSingleAcButtonClicked)
self.deleteButton.connect('clicked()', self.onDeleteButtonClicked)
self.exportButton.connect('clicked()', self.onExportButtonClicked)
#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 ...
self.logic = BreachWarningLightLogic()
#
# 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.breachWarningSelector = slicer.qMRMLNodeComboBox()
self.breachWarningSelector.nodeTypes = (("vtkMRMLBreachWarningNode"),
"")
self.breachWarningSelector.selectNodeUponCreation = True
self.breachWarningSelector.addEnabled = False
self.breachWarningSelector.removeEnabled = False
self.breachWarningSelector.noneEnabled = False
self.breachWarningSelector.showHidden = False
self.breachWarningSelector.showChildNodeTypes = False
self.breachWarningSelector.setMRMLScene(slicer.mrmlScene)
self.breachWarningSelector.setToolTip(
"Pick the breach warning node to observe.")
parametersFormLayout.addRow("Breach warning node: ",
self.breachWarningSelector)
#
# output volume selector
#
self.connectorSelector = slicer.qMRMLNodeComboBox()
self.connectorSelector.nodeTypes = (("vtkMRMLIGTLConnectorNode"), "")
self.connectorSelector.selectNodeUponCreation = True
self.connectorSelector.addEnabled = False
self.connectorSelector.removeEnabled = False
self.connectorSelector.noneEnabled = False
self.connectorSelector.showHidden = False
self.connectorSelector.showChildNodeTypes = False
self.connectorSelector.setMRMLScene(slicer.mrmlScene)
self.connectorSelector.setToolTip(
"Pick the OpenIGTLink connector node to send light control commands to"
)
parametersFormLayout.addRow("Connector: ", self.connectorSelector)
#
# marginSizeMm value
#
self.marginSizeMmSliderWidget = ctk.ctkSliderWidget()
self.marginSizeMmSliderWidget.singleStep = 0.1
self.marginSizeMmSliderWidget.minimum = 0
self.marginSizeMmSliderWidget.maximum = 10
self.marginSizeMmSliderWidget.value = 2.0
self.marginSizeMmSliderWidget.setToolTip(
"Set the desired margin size in mm. Light pattern will indicate 'good position' if the distance is smaller than this value."
)
parametersFormLayout.addRow("Margin size (mm)",
self.marginSizeMmSliderWidget)
#
# check box to trigger taking screen shots for later use in tutorials
#
self.enableLightFeedbackFlagCheckBox = qt.QCheckBox()
self.enableLightFeedbackFlagCheckBox.checked = 0
self.enableLightFeedbackFlagCheckBox.setToolTip(
"If checked, then light pattern will be updated whenever the breach warning state is changed."
)
parametersFormLayout.addRow("Enable light feedback",
self.enableLightFeedbackFlagCheckBox)
# connections
self.enableLightFeedbackFlagCheckBox.connect(
'stateChanged(int)', self.setEnableLightFeedback)
self.marginSizeMmSliderWidget.connect('valueChanged(double)',
self.setMarginChanged)
# 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 = "TestRobotPlacement 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 = (("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.")
parametersFormLayout.addRow("Input Model: ", self.inputSelector)
#
# Sphere model
#
self.sphereModel = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLModelNode')
self.sphereModel.SetName("SphereModel")
slicer.mrmlScene.AddNode(self.sphereModel)
displayNode = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLModelDisplayNode")
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetOpacity(0.35)
displayNode.SetColor(1.0, 0.0, 0.0)
self.sphereModel.SetAndObserveDisplayNodeID(displayNode.GetID())
#
# Seed point
#
self.sphereSeedListSelector = slicer.qMRMLNodeComboBox()
self.sphereSeedListSelector.nodeTypes = ((
"vtkMRMLMarkupsFiducialNode"), "")
self.sphereSeedListSelector.baseName = "SeedPoint"
self.sphereSeedListSelector.selectNodeUponCreation = True
self.sphereSeedListSelector.addEnabled = True
self.sphereSeedListSelector.removeEnabled = True
self.sphereSeedListSelector.noneEnabled = False
self.sphereSeedListSelector.showHidden = False
self.sphereSeedListSelector.showChildNodeTypes = False
self.sphereSeedListSelector.setMRMLScene(slicer.mrmlScene)
self.sphereSeedListSelector.setToolTip("Seed list")
parametersFormLayout.addRow("Seed Point: ",
self.sphereSeedListSelector)
#
# Sphere radius
#
self.sphereRadiusSliderWidget = ctk.ctkSliderWidget()
self.sphereRadiusSliderWidget.singleStep = 1.0
self.sphereRadiusSliderWidget.minimum = 1.0
self.sphereRadiusSliderWidget.maximum = 100.0
self.sphereRadiusSliderWidget.value = 40.0
self.sphereRadiusSliderWidget.setToolTip("Set sphere radius in mm.")
parametersFormLayout.addRow("Sphere Radius (mm)",
self.sphereRadiusSliderWidget)
#
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.sphereSeedListSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onSeedListChanged)
self.sphereRadiusSliderWidget.connect("valueChanged(double)",
self.updateSphere)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
# Instantiate and connect widgets ...
self.RingOff = None
self.RingOn = None
# Tags to manage event observers
self.tagSourceNode = None
self.tagDestinationNode = None
#####################
## For debugging
##
## 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 = "CurveMaker Reload"
#reloadFormLayout.addWidget(self.reloadButton)
#self.reloadButton.connect('clicked()', self.onReload)
##
#####################
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# Source points (vtkMRMLMarkupsFiducialNode)
#
self.SourceSelector = slicer.qMRMLNodeComboBox()
self.SourceSelector.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" )
self.SourceSelector.addEnabled = True
self.SourceSelector.removeEnabled = False
self.SourceSelector.noneEnabled = True
self.SourceSelector.showHidden = False
self.SourceSelector.renameEnabled = True
self.SourceSelector.showChildNodeTypes = False
self.SourceSelector.setMRMLScene( slicer.mrmlScene )
self.SourceSelector.setToolTip( "Pick up a Markups node listing fiducials." )
parametersFormLayout.addRow("Source points: ", self.SourceSelector)
#
# Target point (vtkMRMLMarkupsFiducialNode)
#
self.DestinationSelector = slicer.qMRMLNodeComboBox()
self.DestinationSelector.nodeTypes = ( ("vtkMRMLModelNode"), "" )
self.DestinationSelector.addEnabled = True
self.DestinationSelector.removeEnabled = False
self.DestinationSelector.noneEnabled = True
self.DestinationSelector.showHidden = False
self.DestinationSelector.renameEnabled = True
self.DestinationSelector.selectNodeUponCreation = True
self.DestinationSelector.showChildNodeTypes = False
self.DestinationSelector.setMRMLScene( slicer.mrmlScene )
self.DestinationSelector.setToolTip( "Pick up or create a Model node." )
parametersFormLayout.addRow("Curve model: ", self.DestinationSelector)
#
# Radius for the tube
#
self.RadiusSliderWidget = ctk.ctkSliderWidget()
self.RadiusSliderWidget.singleStep = 1.0
self.RadiusSliderWidget.minimum = 1.0
self.RadiusSliderWidget.maximum = 50.0
self.RadiusSliderWidget.value = 5.0
self.RadiusSliderWidget.setToolTip("Set the raidus of the tube.")
parametersFormLayout.addRow("Radius (mm): ", self.RadiusSliderWidget)
#
# Radio button to select interpolation method
#
self.InterpolationLayout = qt.QHBoxLayout()
self.InterpolationNone = qt.QRadioButton("None")
self.InterpolationCardinalSpline = qt.QRadioButton("Cardinal Spline")
self.InterpolationHermiteSpline = qt.QRadioButton("Hermite Spline (for Endoscopy)")
self.InterpolationLayout.addWidget(self.InterpolationNone)
self.InterpolationLayout.addWidget(self.InterpolationCardinalSpline)
self.InterpolationLayout.addWidget(self.InterpolationHermiteSpline)
self.InterpolationGroup = qt.QButtonGroup()
self.InterpolationGroup.addButton(self.InterpolationNone)
self.InterpolationGroup.addButton(self.InterpolationCardinalSpline)
self.InterpolationGroup.addButton(self.InterpolationHermiteSpline)
parametersFormLayout.addRow("Interpolation: ", self.InterpolationLayout)
#
# Interpolation Resolution
#
self.InterpResolutionSliderWidget = ctk.ctkSliderWidget()
self.InterpResolutionSliderWidget.singleStep = 1.0
self.InterpResolutionSliderWidget.minimum = 5.0
self.InterpResolutionSliderWidget.maximum = 50.0
self.InterpResolutionSliderWidget.value = 25.0
self.InterpResolutionSliderWidget.setToolTip("Number of interpolation points between control points. Default is 25.")
parametersFormLayout.addRow("Resolution: ", self.InterpResolutionSliderWidget)
#
# Radio button for ring mode
#
self.RingLayout = qt.QHBoxLayout()
self.RingOff = qt.QRadioButton("Off")
self.RingOn = qt.QRadioButton("On")
self.RingLayout.addWidget(self.RingOff)
self.RingLayout.addWidget(self.RingOn)
self.RingGroup = qt.QButtonGroup()
self.RingGroup.addButton(self.RingOff)
self.RingGroup.addButton(self.RingOn)
parametersFormLayout.addRow("Ring mode: ", self.RingLayout)
#
# Check box to start curve visualization
#
self.EnableAutoUpdateCheckBox = qt.QCheckBox()
self.EnableAutoUpdateCheckBox.checked = 0
self.EnableAutoUpdateCheckBox.setToolTip("If checked, the CurveMaker module keeps updating the model as the points are updated.")
parametersFormLayout.addRow("Auto update:", self.EnableAutoUpdateCheckBox)
#
# Button to generate a curve
#
self.GenerateButton = qt.QPushButton("Generate Curve")
self.GenerateButton.toolTip = "Generate Curve"
self.GenerateButton.enabled = True
parametersFormLayout.addRow("", self.GenerateButton)
# Connections
self.InterpolationNone.connect('clicked(bool)', self.onSelectInterpolationNone)
self.InterpolationCardinalSpline.connect('clicked(bool)', self.onSelectInterpolationCardinalSpline)
self.InterpolationHermiteSpline.connect('clicked(bool)', self.onSelectInterpolationHermiteSpline)
self.RingOff.connect('clicked(bool)', self.onRingOff)
self.RingOn.connect('clicked(bool)', self.onRingOn)
self.EnableAutoUpdateCheckBox.connect('toggled(bool)', self.onEnableAutoUpdate)
self.SourceSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSourceSelected)
self.DestinationSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onDestinationSelected)
self.RadiusSliderWidget.connect("valueChanged(double)", self.onTubeUpdated)
self.InterpResolutionSliderWidget.connect("valueChanged(double)", self.onInterpResolutionUpdated)
self.GenerateButton.connect('clicked(bool)', self.onGenerateCurve)
# Set default
## default interpolation method
self.InterpolationCardinalSpline.setChecked(True)
self.onSelectInterpolationCardinalSpline(True)
## default ring mode
self.RingOff.setChecked(True)
self.onRingOff(True)
#
# Curve Length area
#
lengthCollapsibleButton = ctk.ctkCollapsibleButton()
lengthCollapsibleButton.text = "Length"
self.layout.addWidget(lengthCollapsibleButton)
lengthFormLayout = qt.QFormLayout(lengthCollapsibleButton)
lengthCollapsibleButton.collapsed = True
#-- Curve length
self.lengthLineEdit = qt.QLineEdit()
self.lengthLineEdit.text = '--'
self.lengthLineEdit.readOnly = True
self.lengthLineEdit.frame = True
self.lengthLineEdit.styleSheet = "QLineEdit { background:transparent; }"
self.lengthLineEdit.cursor = qt.QCursor(qt.Qt.IBeamCursor)
lengthFormLayout.addRow("Curve Length (mm):", self.lengthLineEdit)
#
# Distance Area
#
distanceCollapsibleButton = ctk.ctkCollapsibleButton()
distanceCollapsibleButton.text = "Distance"
distanceCollapsibleButton.collapsed = True
self.layout.addWidget(distanceCollapsibleButton)
distanceFormLayout = qt.QFormLayout(distanceCollapsibleButton)
#-- Point-to-curve distance
# - Markups selector for input points
distanceLayout = qt.QVBoxLayout()
self.targetFiducialsSelector = slicer.qMRMLNodeComboBox()
self.targetFiducialsSelector.nodeTypes = ( ("vtkMRMLMarkupsFiducialNode"), "" )
self.targetFiducialsSelector.selectNodeUponCreation = True
self.targetFiducialsSelector.addEnabled = True
self.targetFiducialsSelector.removeEnabled = True
self.targetFiducialsSelector.noneEnabled = True
self.targetFiducialsSelector.showHidden = False
self.targetFiducialsSelector.showChildNodeTypes = False
self.targetFiducialsSelector.setMRMLScene( slicer.mrmlScene )
self.targetFiducialsSelector.setToolTip( "Select Markups for targets" )
distanceLayout.addWidget(self.targetFiducialsSelector)
self.targetFiducialsNode = None
self.tagDestinationDispNode = None
self.targetFiducialsSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onTargetFiducialsSelected)
self.fiducialsTable = qt.QTableWidget(1, 3)
self.fiducialsTable.setSelectionBehavior(qt.QAbstractItemView.SelectRows)
self.fiducialsTable.setSelectionMode(qt.QAbstractItemView.SingleSelection)
self.fiducialsTableHeaders = ["Name", "Position (mm)", "Distance (mm)"]
self.fiducialsTable.setHorizontalHeaderLabels(self.fiducialsTableHeaders)
self.fiducialsTable.horizontalHeader().setStretchLastSection(True)
distanceLayout.addWidget(self.fiducialsTable)
self.extrapolateCheckBox = qt.QCheckBox()
self.extrapolateCheckBox.checked = 0
self.extrapolateCheckBox.setToolTip("Extrapolate the first and last segment to calculate the distance")
self.extrapolateCheckBox.connect('toggled(bool)', self.updateTargetFiducialsTable)
self.extrapolateCheckBox.text = 'Extrapolate curves to measure the distances'
self.showErrorVectorCheckBox = qt.QCheckBox()
self.showErrorVectorCheckBox.checked = 0
self.showErrorVectorCheckBox.setToolTip("Show error vectors, which is defined by the target point and the closest point on the curve. The vector is perpendicular to the curve, unless the closest point is one end of the curve.")
self.showErrorVectorCheckBox.connect('toggled(bool)', self.updateTargetFiducialsTable)
self.showErrorVectorCheckBox.text = 'Show error vectors'
distanceLayout.addWidget(self.extrapolateCheckBox)
distanceLayout.addWidget(self.showErrorVectorCheckBox)
distanceFormLayout.addRow("Distance from:", distanceLayout)
#
# Curvature Area
#
curvatureCollapsibleButton = ctk.ctkCollapsibleButton()
curvatureCollapsibleButton.text = "Curvature"
curvatureCollapsibleButton.collapsed = True
self.layout.addWidget(curvatureCollapsibleButton)
curvatureFormLayout = qt.QFormLayout(curvatureCollapsibleButton)
#-- Curvature
self.curvatureLayout = qt.QHBoxLayout()
self.curvatureOff = qt.QRadioButton("Off")
self.curvatureOff.connect('clicked(bool)', self.onCurvatureOff)
self.curvatureOn = qt.QRadioButton("On")
self.curvatureOn.connect('clicked(bool)', self.onCurvatureOn)
self.curvatureLayout.addWidget(self.curvatureOff)
self.curvatureLayout.addWidget(self.curvatureOn)
self.curvatureGroup = qt.QButtonGroup()
self.curvatureGroup.addButton(self.curvatureOff)
self.curvatureGroup.addButton(self.curvatureOn)
curvatureFormLayout.addRow("Curvature mode:", self.curvatureLayout)
autoCurvatureRangeFormLayout = qt.QFormLayout(curvatureCollapsibleButton)
self.autoCurvatureRangeLayout = qt.QHBoxLayout()
self.autoCurvatureRangeOff = qt.QRadioButton("Manual")
self.autoCurvatureRangeOff.connect('clicked(bool)', self.onAutoCurvatureRangeOff)
self.autoCurvatureRangeOn = qt.QRadioButton("Auto")
self.autoCurvatureRangeOn.connect('clicked(bool)', self.onAutoCurvatureRangeOn)
self.autoCurvatureRangeLayout.addWidget(self.autoCurvatureRangeOff)
self.autoCurvatureRangeLayout.addWidget(self.autoCurvatureRangeOn)
self.autoCurvatureRangeGroup = qt.QButtonGroup()
self.autoCurvatureRangeGroup.addButton(self.autoCurvatureRangeOff)
self.autoCurvatureRangeGroup.addButton(self.autoCurvatureRangeOn)
curvatureFormLayout.addRow("Color range:", self.autoCurvatureRangeLayout)
#-- Color range
self.curvatureColorRangeWidget = ctk.ctkRangeWidget()
self.curvatureColorRangeWidget.setToolTip("Set color range")
self.curvatureColorRangeWidget.setDecimals(3)
self.curvatureColorRangeWidget.singleStep = 0.001
self.curvatureColorRangeWidget.minimumValue = 0.0
self.curvatureColorRangeWidget.maximumValue = 0.5
self.curvatureColorRangeWidget.minimum = 0.0
self.curvatureColorRangeWidget.maximum = 1.0
curvatureFormLayout.addRow("Color range: ", self.curvatureColorRangeWidget)
self.curvatureColorRangeWidget.connect('valuesChanged(double, double)', self.onUpdateCurvatureColorRange)
#-- Curvature data
self.meanCurvatureLineEdit = qt.QLineEdit()
self.meanCurvatureLineEdit.text = '--'
self.meanCurvatureLineEdit.readOnly = True
self.meanCurvatureLineEdit.frame = True
self.meanCurvatureLineEdit.styleSheet = "QLineEdit { background:transparent; }"
self.meanCurvatureLineEdit.cursor = qt.QCursor(qt.Qt.IBeamCursor)
self.meanCurvatureLineEdit.enabled = False
curvatureFormLayout.addRow("Mean (mm^-1):", self.meanCurvatureLineEdit)
self.minCurvatureLineEdit = qt.QLineEdit()
self.minCurvatureLineEdit.text = '--'
self.minCurvatureLineEdit.readOnly = True
self.minCurvatureLineEdit.frame = True
self.minCurvatureLineEdit.styleSheet = "QLineEdit { background:transparent; }"
self.minCurvatureLineEdit.cursor = qt.QCursor(qt.Qt.IBeamCursor)
self.minCurvatureLineEdit.enabled = False
curvatureFormLayout.addRow("Minimum (mm^-1):", self.minCurvatureLineEdit)
self.maxCurvatureLineEdit = qt.QLineEdit()
self.maxCurvatureLineEdit.text = '--'
self.maxCurvatureLineEdit.readOnly = True
self.maxCurvatureLineEdit.frame = True
self.maxCurvatureLineEdit.styleSheet = "QLineEdit { background:transparent; }"
self.maxCurvatureLineEdit.cursor = qt.QCursor(qt.Qt.IBeamCursor)
self.maxCurvatureLineEdit.enabled = False
curvatureFormLayout.addRow("Maximum (mm^-1):", self.maxCurvatureLineEdit)
## Create a scale for curvature
self.scalarBarWidget = vtk.vtkScalarBarWidget()
actor = self.scalarBarWidget.GetScalarBarActor()
actor.SetOrientationToVertical()
actor.SetNumberOfLabels(11)
actor.SetTitle("Curvature (mm^-1)")
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())
self.lookupTable = vtk.vtkLookupTable()
self.lookupTable.SetRange(0.0, 100.0)
self.scalarBarWidget.GetScalarBarActor().SetLookupTable(self.lookupTable)
## default curvature mode: off
self.curvatureOff.setChecked(True)
self.onCurvatureOff(True)
self.autoCurvatureRangeOff.setChecked(True)
self.onAutoCurvatureRangeOff(True)
# 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 = "BabyBrowser 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)
#
# Data Area
#
dataCollapsibleButton = ctk.ctkCollapsibleButton()
dataCollapsibleButton.text = "Data"
self.layout.addWidget(dataCollapsibleButton)
dataFormLayout = qt.QFormLayout(dataCollapsibleButton)
# pick the data directory and file pattern
self.pathEdit = ctk.ctkPathLineEdit()
self.pathEdit.setCurrentPath('/Users/pieper/data/babybrains/to_mprage-19/')
self.patternEdit = qt.QLineEdit()
self.patternEdit.setText('mprage-%d.nrrd')
self.loadButton = qt.QPushButton()
self.loadButton.text = "Load Data"
self.dataSlider = ctk.ctkSliderWidget()
self.dataSlider.setDecimals(0)
self.dataSlider.enabled = False
dataFormLayout.addRow("Data path: ", self.pathEdit)
dataFormLayout.addRow("Data pattern: ", self.patternEdit)
dataFormLayout.addRow(self.loadButton)
dataFormLayout.addRow("Data Select", self.dataSlider)
self.loadButton.connect('clicked()', self.onLoad)
self.dataSlider.connect('valueChanged(double)', self.onDataSlider)
#
# Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
parametersCollapsibleButton.collapsed = True
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 initMainPanel(self):
# Create main collapsible Button
self.mainCollapsibleBtn = ctk.ctkCollapsibleButton()
self.mainCollapsibleBtn.setStyleSheet(
"ctkCollapsibleButton { background-color: DarkSeaGreen }")
self.mainCollapsibleBtn.text = "Remeshing Tools Selection"
#self.mainCollapsibleBtn.collapsible = True
self.layout.addWidget(self.mainCollapsibleBtn)
self.mainFormLayout = qt.QFormLayout(self.mainCollapsibleBtn)
# Create input Segmentation Selector
self.inputSelectorCoBx = slicer.qMRMLNodeComboBox()
self.inputSelectorCoBx.nodeTypes = ["vtkMRMLModelNode"]
self.inputSelectorCoBx.setFixedWidth(200)
self.inputSelectorCoBx.selectNodeUponCreation = True
self.inputSelectorCoBx.addEnabled = False
self.inputSelectorCoBx.removeEnabled = False
self.inputSelectorCoBx.noneEnabled = False
self.inputSelectorCoBx.showHidden = False
self.inputSelectorCoBx.showChildNodeTypes = False
self.inputSelectorCoBx.setMRMLScene(slicer.mrmlScene)
self.inputSelectorCoBx.setToolTip(
"select an .stl file as the input segmentation")
self.mainFormLayout.addRow("Input segmentation: ",
self.inputSelectorCoBx)
# Create button to show mesh of InputNode
self.showMeshBtn = qt.QPushButton("Show Mesh")
self.showMeshBtn.setFixedHeight(20)
self.showMeshBtn.setFixedWidth(100)
self.showMeshBtn.setStyleSheet(
"QPushButton{ background-color: DarkSeaGreen }")
self.showMeshBtn.toolTip = (
'How to use:'
' Click the Show Mesh Button to show mesh of Input Segmentation ')
self.showMeshBtn.connect('clicked(bool)', self.onShowBtnClick)
self.mainFormLayout.addRow("Input Segmentation: ", self.showMeshBtn)
# Create button to set visibility to 1 of inputNode
self.showBtn = qt.QPushButton("Show Input")
self.showBtn.setFixedHeight(20)
self.showBtn.setFixedWidth(100)
self.showBtn.setStyleSheet(
"QPushButton{ background-color: DarkSeaGreen }")
self.showBtn.toolTip = (
'How to use:'
' Click the Show Mesh Button to show Input Segmentation ')
self.showBtn.connect('clicked(bool)', self.onInputBtnClick)
self.mainFormLayout.addRow("Input Segmentation: ", self.showBtn)
# ---------------------------------------INSTANT MESHING--------------------------------------------
# Create collapsible Button for Instant-Meshing options
self.instantCollapsibleBtn = ctk.ctkCollapsibleButton()
self.instantCollapsibleBtn.text = "Instant-Meshing"
self.layout.addWidget(self.instantCollapsibleBtn)
self.instantFormLayout = qt.QFormLayout(self.instantCollapsibleBtn)
self.instantCollapsibleBtn.connect('clicked(bool)',
self.onInstantClick)
# Create button to run the Instant-Meshing tool
self.imBtn = qt.QPushButton("Run")
self.imBtn.setFixedHeight(40)
self.imBtn.setFixedWidth(100)
self.imBtn.setStyleSheet(
"QPushButton{ background-color: DarkSeaGreen }")
self.imBtn.toolTip = (
'How to use:'
' Click the Run Button to start instant-meshing ')
self.imBtn.connect('clicked(bool)', self.onImBtnClick)
self.instantFormLayout.addRow(self.imBtn, self.imtimeLbl)
# Create check box to display normals
self.checkshowNormals = qt.QCheckBox()
self.checkshowNormals.checked = False
self.checkshowNormals.toolTip = ('If activated:' ' shows normals ')
self.checkshowNormals.stateChanged.connect(
self.onCheckShowNormalsChkBx)
self.instantFormLayout.addRow(
" Show normals: ",
self.checkshowNormals)
# ---------------------------------------ADVANCED USER OPTIONS--------------------------------------------
# Create group box for advanced user options
self.instantCollapsiblegroupBtn = ctk.ctkCollapsibleGroupBox()
self.instantCollapsiblegroupBtn.title = "Advanced Options"
self.layout.addWidget(self.instantCollapsiblegroupBtn)
self.instantCollapsiblegroupBtn.collapsed = True
self.instantFormLayout.addRow(self.instantCollapsiblegroupBtn)
self.instantCGBFormLayout = qt.QFormLayout(
self.instantCollapsiblegroupBtn)
# Create radio buttons for triangle or quad meshing
self.checkTR = qt.QRadioButton()
self.checkTR.text = "Triangles (6/6)"
self.checkTR.checked = True # use triangle meshing by default
self.instantCGBFormLayout.addRow(
"Orientation and Position Symmetry Type: ", self.checkTR)
self.checkQD1 = qt.QRadioButton()
self.checkQD1.text = "Quads (2/4)"
self.instantCGBFormLayout.addRow(
" ", self.checkQD1)
self.checkQD2 = qt.QRadioButton()
self.checkQD2.text = "Quads (4/4)"
self.instantCGBFormLayout.addRow(
" ", self.checkQD2)
# Create check boxes for boolean values
self.checkintrinsic = qt.QCheckBox()
self.checkintrinsic.checked = False # use extrinsic by default
self.checkintrinsic.toolTip = (
'If activated:'
' Measures smoothness directly on the surface instead of natural alignment to surface features '
)
self.checkintrinsic.stateChanged.connect(self.oncheckint)
self.instantCGBFormLayout.addRow("Intrinsic: ", self.checkintrinsic)
self.checkdominant = qt.QCheckBox()
self.checkdominant.checked = False
self.checkdominant.toolTip = (
'If activated:'
' Generates a tri/quad dominant mesh instead of a pure tri/quad mesh '
)
self.checkdominant.stateChanged.connect(self.oncheckdom)
self.instantCGBFormLayout.addRow("Dominant: ", self.checkdominant)
self.checkdetermin = qt.QCheckBox()
self.checkdetermin.checked = False
self.checkdetermin.toolTip = (
'If activated:'
' Prefers (slower) deterministic algorithms ')
self.checkdetermin.stateChanged.connect(self.oncheckdet)
self.instantCGBFormLayout.addRow("Deterministic: ", self.checkdetermin)
# Create slider widget to adjust face count (triangle), prior vertex count (to change back, change -f in cmd to -v)
self.vertSlider = ctk.ctkSliderWidget()
self.vertSlider.minimum = 1000
self.vertSlider.maximum = 10000
self.vertSlider.setFixedWidth(400)
self.vertSlider.value = 2800
self.vertSlider.toolTip = ('What it changes:'
' Desired face count of the output mesh ')
self.instantCGBFormLayout.addRow("Triangle count: ", self.vertSlider)
# Create slider widget to adjust smoothing & ray tracing reprojection steps
self.smoothraySlider = ctk.ctkSliderWidget()
self.smoothraySlider.minimum = 0
self.smoothraySlider.maximum = 10
self.smoothraySlider.setFixedWidth(400)
self.smoothraySlider.value = 2
self.smoothraySlider.toolTip = (
'What it changes:'
' Number of smoothing & ray tracing reprojection steps (default: 2) '
)
self.instantCGBFormLayout.addRow("Smoothing Steps: ",
self.smoothraySlider)
# Create slider widget to adjust Point cloud mode
self.knnSlider = ctk.ctkSliderWidget()
self.knnSlider.minimum = 5
self.knnSlider.maximum = 20
self.knnSlider.setFixedWidth(400)
self.knnSlider.value = 10
self.knnSlider.toolTip = (
'Point cloud mode:'
' Number of adjacent points to consider (default: 10) ')
self.instantCGBFormLayout.addRow("Adjacent Points: ", self.knnSlider)
# Create slider widget to adjust Dihedral angle threshold
self.angleSlider = ctk.ctkSliderWidget()
self.angleSlider.minimum = -1
self.angleSlider.maximum = 90
self.angleSlider.setFixedWidth(400)
self.angleSlider.value = -1
self.angleSlider.toolTip = (
'What it changes:'
' Dihedral angle threshold for creases, -1 means sharp creases ')
self.instantCGBFormLayout.addRow("Crease Angle: ", self.angleSlider)
# ---------------------------------------ROBUST QUAD/HEX-DOMINANT MESHING--------------------------------------------
# Create collapsible Button for robust quad/hex-dominant meshing options
self.quadhexCollapsibleBtn = ctk.ctkCollapsibleButton()
self.quadhexCollapsibleBtn.text = "Robust Quad/Hex-dominant Meshing"
self.layout.addWidget(self.quadhexCollapsibleBtn)
self.quadhexCollapsibleBtn.collapsed = True
self.quadhexFormLayout = qt.QFormLayout(self.quadhexCollapsibleBtn)
self.quadhexCollapsibleBtn.connect('clicked(bool)',
self.onQuadHexClick)
# Create button to run the tool
self.rmBtn = qt.QPushButton("Run")
self.rmBtn.setFixedHeight(40)
self.rmBtn.setFixedWidth(100)
self.rmBtn.setStyleSheet(
"QPushButton{ background-color: DarkSeaGreen }")
self.rmBtn.toolTip = (
'How to use:'
' Click the Run Button to start robust quad/hex-dominant meshing ')
self.rmBtn.connect('clicked(bool)', self.onRmBtnClick)
self.quadhexFormLayout.addRow(self.rmBtn, self.qhtimeLbl)
# ---------------------------------------ADVANCED USER OPTIONS--------------------------------------------
# Create group box for advanced user options
self.robustCollapsiblegroupBtn = ctk.ctkCollapsibleGroupBox()
self.robustCollapsiblegroupBtn.title = "Advanced Options"
self.layout.addWidget(self.robustCollapsiblegroupBtn)
self.robustCollapsiblegroupBtn.collapsed = True
self.quadhexFormLayout.addRow(self.robustCollapsiblegroupBtn)
self.robustCGBFormLayout = qt.QFormLayout(
self.robustCollapsiblegroupBtn)
# Create radio buttons to adjust dimension
self.checkdim2 = qt.QRadioButton()
self.checkdim2.checked = True # use dimension 2 by default
self.checkdim2.text = "2"
self.robustCGBFormLayout.addRow("Dimension: ", self.checkdim2)
# Create slider widget to adjust scale
self.scaleSlider = ctk.ctkSliderWidget()
self.scaleSlider.minimum = 2
self.scaleSlider.maximum = 10
self.scaleSlider.setFixedWidth(400)
self.scaleSlider.value = 3
self.robustCGBFormLayout.addRow("Scale: ", self.scaleSlider)
# Create slider widget to adjust smooth iterator
self.smoothSlider = ctk.ctkSliderWidget()
self.smoothSlider.minimum = 5
self.smoothSlider.maximum = 20
self.smoothSlider.setFixedWidth(400)
self.smoothSlider.value = 10
self.robustCGBFormLayout.addRow("Smoothing iteration count: ",
self.smoothSlider)
def setup(self):
self.viewMode = 'compare'
self.compare0 = None
self.compare1 = None
self.sidebyside0 = None
self.sidebyside1 = None
# 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 = "VisAIRe Reload"
self.layout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
# reload and test button
# (use this during development, but remove it when delivering
# your module to users)
#self.reloadAndTestButton = qt.QPushButton("Reload and Test")
#self.reloadAndTestButton.toolTip = "Reload this module and then run the self tests."
#self.layout.addWidget(self.reloadAndTestButton)
#self.reloadAndTestButton.connect('clicked()', self.onReloadAndTest)
# entry for the rater name
label = qt.QLabel('Rater name:')
self.raterName = qt.QLineEdit()
self.layout.addWidget(label)
self.layout.addWidget(self.raterName)
# Configuration file picker
label = qt.QLabel('Configuration file:')
self.configFilePicker = qt.QPushButton('N/A')
self.configFilePicker.connect('clicked()',self.onConfigFileSelected)
self.layout.addWidget(label)
self.layout.addWidget(self.configFilePicker)
self.makeSnapshots = qt.QPushButton('Make snapshots')
self.layout.addWidget(self.makeSnapshots)
self.makeSnapshots.connect('clicked()', self.onMakeSnapshots)
# Opacity control
label = qt.QLabel('Foreground/Background opacity:')
self.opacitySlider = ctk.ctkSliderWidget()
self.opacitySlider.connect('valueChanged(double)',self.onOpacityChangeRequested)
self.opacitySlider.minimum = 0.
self.opacitySlider.maximum = 1.
self.opacitySlider.decimals = 1
self.opacitySlider.singleStep = 0.1
self.layout.addWidget(label)
self.layout.addWidget(self.opacitySlider)
# Button to switch between showing background/foreground volumes
self.bgfgButton = qt.QPushButton("Switch Background/Foreground")
self.layout.addWidget(self.bgfgButton)
self.bgfgButton.connect('clicked()', self.onbgfgButtonPressed)
# Select between compare view and editing layouts
groupLabel = qt.QLabel('Review mode:')
self.viewGroup = qt.QButtonGroup()
self.compareSelector = qt.QRadioButton('Compare view')
self.sideBySideSelector = qt.QRadioButton('Side by side')
self.compareSelector.setChecked(1)
self.viewGroup.addButton(self.compareSelector,1)
self.viewGroup.addButton(self.sideBySideSelector,2)
self.groupWidget = qt.QWidget()
self.groupLayout = qt.QFormLayout(self.groupWidget)
self.groupLayout.addRow(self.compareSelector, self.sideBySideSelector)
self.layout.addWidget(self.groupWidget)
# step4Layout.addRow(groupLabel, self.viewGroup)
self.viewGroup.connect('buttonClicked(int)', self.onViewUpdateRequested)
# setup Editor widget
editorWidgetParent = slicer.qMRMLWidget()
editorWidgetParent.setLayout(qt.QVBoxLayout())
editorWidgetParent.setMRMLScene(slicer.mrmlScene)
self.editorWidget = EditorWidget(parent=editorWidgetParent,showVolumesFrame=False)
self.editorWidget.setup()
self.editorParameterNode = self.editUtil.getParameterNode()
self.layout.addWidget(editorWidgetParent)
# Slice control
#label = qt.QLabel('Slice selector:')
#self.sliceSlider = ctk.ctkSliderWidget()
#self.sliceSlider.connect('valueChanged(double)',self.onSliceChangeRequested)
#self.sliceSlider.minimum = 0.
#self.sliceSlider.maximum = 1.
#self.sliceSlider.decimals = 1
#self.sliceSlider.singleStep = 0.1
#self.layout.addWidget(label)
#self.layout.addWidget(self.opacitySlider)
# Collapsible button to keep the content of the form
self.evaluationFrame = ctk.ctkCollapsibleButton()
self.evaluationFrame.text = "Assessment Form"
self.evaluationFrame.collapsed = 0
self.evaluationFrameLayout = qt.QFormLayout(self.evaluationFrame)
self.layout.addWidget(self.evaluationFrame)
self.formEntries = []
self.questions = {'Improved compared to non-registered?':'binary','Diagnostic quality?':'binary','Error quantification (if available)':'numeric'}
self.formEntryMapper = qt.QSignalMapper()
self.formEntryMapper.connect('mapped(const QString&)', self.entrySelected)
self.maxFormEntries = 30
for i in range(self.maxFormEntries):
# populate the assessment form
# create a new sub-frame with the questions
cb = ctk.ctkCollapsibleButton()
cb.visible = False
cb.collapsed = True
self.formEntries.append(cb)
self.formEntryMapper.setMapping(cb, str(i))
cb.connect('contentsCollapsed(bool)', self.formEntryMapper, 'map()')
layout = qt.QFormLayout(cb)
self.evaluationFrameLayout.addRow(cb)
for (q,c) in self.questions.items():
if c == 'binary':
self.addBinaryEntry(q, layout)
elif c == 'numeric':
self.addNumericEntry(q, layout)
# Save button
self.doneButton = qt.QPushButton("Save")
self.doneButton.toolTip = "Click this when done."
self.layout.addWidget(self.doneButton)
self.doneButton.connect('clicked(bool)', self.onDoneButtonClicked)
# Add vertical spacer
self.layout.addStretch(1)
# Initialize internal persistent variables
self.configFile = None
self.movingVolume = None
self.perVolumeForms = []
self.fixedVolumes = []
self.registeredVolumes = []
self.transforms = []
self.caseName = None
# add custom layout for comparing two pairs of volumes
compareViewTwoRows ="<layout type=\"vertical\">"
for i in range(2):
compareViewTwoRows = compareViewTwoRows+" <item>\
<view class=\"vtkMRMLSliceNode\" singletontag=\"Compare"+str(i)+"\">\
<property name=\"orientation\" action=\"default\">Axial</property>\
<property name=\"viewlabel\" action=\"default\">"+str(i)+"</property>\
<property name=\"viewcolor\" action=\"default\">#E17012</property>\
<property name=\"lightboxrows\" action=\"default\">1</property>\
<property name=\"lightboxcolumns\" action=\"default\">6</property>\
<property name=\"lightboxrows\" action=\"relayout\">1</property>\
<property name=\"lightboxcolumns\" action=\"relayout\">6</property>\
</view>\
</item>"
compareViewTwoRows = compareViewTwoRows+"</layout>"
sideBySide = "<layout type=\"horizontal\">\
<item>\
<view class=\"vtkMRMLSliceNode\" singletontag=\"SideBySide0\">\
<property name=\"orientation\" action=\"default\">Axial</property>\
<property name=\"viewlabel\" action=\"default\">Moving</property>\
<property name=\"viewcolor\" action=\"default\">#F34A33</property>\
</view>\
</item>\
<item>\
<view class=\"vtkMRMLSliceNode\" singletontag=\"SideBySide1\">\
<property name=\"orientation\" action=\"default\">Axial</property>\
<property name=\"viewlabel\" action=\"default\">Reference</property>\
<property name=\"viewcolor\" action=\"default\">#EDD54C</property>\
</view>\
</item>\
</layout>"
print(sideBySide)
layoutNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLLayoutNode')
layoutNodes.SetReferenceCount(layoutNodes.GetReferenceCount()-1)
self.layoutNode = layoutNodes.GetItemAsObject(0)
self.CompareLayout = 123
self.ContouringLayout = 124
self.layoutNode.AddLayoutDescription(self.CompareLayout,compareViewTwoRows)
self.layoutNode.AddLayoutDescription(self.ContouringLayout,sideBySide)
self.layoutNode.SetViewArrangement(self.ContouringLayout)
self.layoutNode.SetViewArrangement(self.CompareLayout)
sliceCompositeNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLSliceCompositeNode')
sliceCompositeNodes.SetReferenceCount(sliceCompositeNodes.GetReferenceCount()-1)
sliceNodes = slicer.mrmlScene.GetNodesByClass('vtkMRMLSliceNode')
sliceNodes.SetReferenceCount(sliceNodes.GetReferenceCount()-1)
for i in range(sliceCompositeNodes.GetNumberOfItems()):
scn = sliceCompositeNodes.GetItemAsObject(i)
sn = sliceNodes.GetItemAsObject(i)
sn.SetUseLabelOutline(1)
if sn.GetName() == 'Compare0':
self.compare0 = scn
if sn.GetName() == 'Compare1':
self.compare1 = scn
if sn.GetName() == 'SideBySide0':
self.sidebyside0 = scn
if sn.GetName() == 'SideBySide1':
self.sidebyside1 = scn
def setup(self):
"""Instantiate and connect widgets ..."""
self.scene = slicer.mrmlScene
self.icp = vtk.vtkIterativeClosestPointTransform()
#
# 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 = "SurfaceICPRegistration 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 Surface Volume Collapsible Button
#
inputSurfaceCollapsibleButton = ctk.ctkCollapsibleButton()
inputSurfaceCollapsibleButton.text = "Input Surface Volumes"
self.layout.addWidget(inputSurfaceCollapsibleButton)
inputSurfaceFormLayout = qt.QFormLayout(inputSurfaceCollapsibleButton)
#
# Input Surface Volume Options
#
self.modelSelectors = {}
self.viewNames = ("Fixed Surface Volume", "Moving Surface Volume")
for viewName in self.viewNames:
self.modelSelectors[viewName] = slicer.qMRMLNodeComboBox()
self.modelSelectors[viewName].nodeTypes = (("vtkMRMLModelNode"),
"")
self.modelSelectors[viewName].selectNodeUponCreation = False
self.modelSelectors[viewName].addEnabled = False
self.modelSelectors[viewName].removeEnabled = True
self.modelSelectors[viewName].noneEnabled = True
self.modelSelectors[viewName].showHidden = False
self.modelSelectors[viewName].showChildNodeTypes = True
self.modelSelectors[viewName].setMRMLScene(slicer.mrmlScene)
self.modelSelectors[viewName].setToolTip(
"Pick the %s surface volume." % viewName.lower())
inputSurfaceFormLayout.addRow("%s" % viewName,
self.modelSelectors[viewName])
#
# Input Inicial Transform Options
#
self.volumeInitialTransformSelectors = {}
self.volumeInitialTransformSelectors[
"Initial Transform"] = slicer.qMRMLNodeComboBox()
self.volumeInitialTransformSelectors["Initial Transform"].nodeTypes = (
("vtkMRMLLinearTransformNode"), "")
self.volumeInitialTransformSelectors[
"Initial Transform"].selectNodeUponCreation = False
self.volumeInitialTransformSelectors[
"Initial Transform"].addEnabled = False
self.volumeInitialTransformSelectors[
"Initial Transform"].removeEnabled = True
self.volumeInitialTransformSelectors[
"Initial Transform"].noneEnabled = True
self.volumeInitialTransformSelectors[
"Initial Transform"].showHidden = False
self.volumeInitialTransformSelectors[
"Initial Transform"].showChildNodeTypes = True
self.volumeInitialTransformSelectors["Initial Transform"].setMRMLScene(
slicer.mrmlScene)
self.volumeInitialTransformSelectors["Initial Transform"].setToolTip(
"Pick the initial Transform file")
inputSurfaceFormLayout.addRow(
"(Optional) Initial Transform",
self.volumeInitialTransformSelectors["Initial Transform"])
#
# Input Registration Parameters Collapsible Button
#
inputRegistrationParametersCollapsibleButton = ctk.ctkCollapsibleButton(
)
inputRegistrationParametersCollapsibleButton.text = "Input Registration Parameters"
self.layout.addWidget(inputRegistrationParametersCollapsibleButton)
inputRegistrationParametersFormLayout = qt.QFormLayout(
inputRegistrationParametersCollapsibleButton)
#
# Landmark Transform Mode TYPE SELECTION
# - allows selection of the active registration type to display
#
self.landmarkTransformTypeBox = qt.QGroupBox("Landmark Transform Mode")
self.landmarkTransformTypeBox.setLayout(qt.QFormLayout())
self.landmarkTransformTypeButtons = {}
self.landmarkTransformTypes = ("RigidBody", "Similarity", "Affine")
for landmarkTransformType in self.landmarkTransformTypes:
self.landmarkTransformTypeButtons[
landmarkTransformType] = qt.QRadioButton()
self.landmarkTransformTypeButtons[
landmarkTransformType].text = landmarkTransformType
self.landmarkTransformTypeButtons[
landmarkTransformType].setToolTip(
"Pick the type of registration")
self.landmarkTransformTypeButtons[landmarkTransformType].connect(
"clicked()",
lambda t=landmarkTransformType: self.onLandmarkTrandformType(t
))
self.landmarkTransformTypeBox.layout().addWidget(
self.landmarkTransformTypeButtons[landmarkTransformType])
inputRegistrationParametersFormLayout.addWidget(
self.landmarkTransformTypeBox)
#
# Mean Distance Mode TYPE SELECTION
#
self.meanDistanceTypeBox = qt.QGroupBox("Mean Distance Mode")
self.meanDistanceTypeBox.setLayout(qt.QFormLayout())
self.meanDistanceTypeButtons = {}
self.meanDistanceTypes = ("RMS", "Absolute Value")
inputRegistrationParametersFormLayout.addWidget(
self.landmarkTransformTypeBox)
for meanDistanceType in self.meanDistanceTypes:
self.meanDistanceTypeButtons[meanDistanceType] = qt.QRadioButton()
self.meanDistanceTypeButtons[
meanDistanceType].text = meanDistanceType
self.meanDistanceTypeButtons[meanDistanceType].setToolTip(
"Pick the type of registration")
self.meanDistanceTypeButtons[meanDistanceType].connect(
"clicked()",
lambda t=meanDistanceType: self.onMeanDistanceType(t))
self.meanDistanceTypeBox.layout().addWidget(
self.meanDistanceTypeButtons[meanDistanceType])
inputRegistrationParametersFormLayout.addWidget(
self.meanDistanceTypeBox)
#
# Start by Matching Centroids Options
#
self.startMatchingCentroids = qt.QCheckBox()
self.startMatchingCentroids.checked = True
self.startMatchingCentroids.connect("toggled(bool)",
self.onMatchCentroidsLinearActive)
inputRegistrationParametersFormLayout.addRow(
"Start by matching centroids ", self.startMatchingCentroids)
#
# Check Mean Distance Options
#
self.checkMeanDistance = qt.QCheckBox()
self.checkMeanDistance.checked = True
self.checkMeanDistance.connect("toggled(bool)",
self.onCheckMeanDistanceActive)
inputRegistrationParametersFormLayout.addRow("Check Mean Distance ",
self.checkMeanDistance)
# Number of Iterations
numberOfIterations = ctk.ctkSliderWidget()
numberOfIterations.connect('valueChanged(double)',
self.numberOfIterationsValueChanged)
numberOfIterations.decimals = 0
numberOfIterations.minimum = 50
numberOfIterations.maximum = 80000
numberOfIterations.value = 50
inputRegistrationParametersFormLayout.addRow("Number of Iterations:",
numberOfIterations)
# Number of Landmarks
numberOfLandmarks = ctk.ctkSliderWidget()
numberOfLandmarks.connect('valueChanged(double)',
self.numberOfLandmarksValueChanged)
numberOfLandmarks.decimals = 0
numberOfLandmarks.minimum = 0
numberOfLandmarks.maximum = 10000
numberOfLandmarks.value = 200
inputRegistrationParametersFormLayout.addRow("Number of Landmarks:",
numberOfLandmarks)
# Maximum Distance
maxDistance = ctk.ctkSliderWidget()
maxDistance.connect('valueChanged(double)',
self.maxDistanceValueChanged)
maxDistance.decimals = 4
maxDistance.minimum = 0.0001
maxDistance.maximum = 10
maxDistance.value = 0.01
inputRegistrationParametersFormLayout.addRow("Maximum Distance:",
maxDistance)
#
# Output Surface Collapsible Button
#
outputSurfaceCollapsibleButton = ctk.ctkCollapsibleButton()
outputSurfaceCollapsibleButton.text = "Output Files"
self.layout.addWidget(outputSurfaceCollapsibleButton)
outputSurfaceFormLayout = qt.QFormLayout(
outputSurfaceCollapsibleButton)
#
# Output Surface Volume Options
#
self.modelOutputSurfaceSelectors = {}
self.modelOutputSurfaceSelectors[
"Output Surface Volume"] = slicer.qMRMLNodeComboBox()
self.modelOutputSurfaceSelectors["Output Surface Volume"].nodeTypes = (
("vtkMRMLModelNode"), "")
self.modelOutputSurfaceSelectors[
"Output Surface Volume"].addEnabled = True
self.modelOutputSurfaceSelectors[
"Output Surface Volume"].selectNodeUponCreation = True
self.modelOutputSurfaceSelectors[
"Output Surface Volume"].removeEnabled = True
self.modelOutputSurfaceSelectors[
"Output Surface Volume"].noneEnabled = True
self.modelOutputSurfaceSelectors[
"Output Surface Volume"].showHidden = False
self.modelOutputSurfaceSelectors[
"Output Surface Volume"].showChildNodeTypes = True
self.modelOutputSurfaceSelectors["Output Surface Volume"].setMRMLScene(
slicer.mrmlScene)
self.modelOutputSurfaceSelectors["Output Surface Volume"].setToolTip(
"Pick the Output Surface Volume")
outputSurfaceFormLayout.addRow(
"Output Surface Volume",
self.modelOutputSurfaceSelectors["Output Surface Volume"])
#
# Output Transform Options
#
self.volumeOutputTransformSelectors = {}
self.volumeOutputTransformSelectors[
"Output Transform"] = slicer.qMRMLNodeComboBox()
self.volumeOutputTransformSelectors["Output Transform"].nodeTypes = ((
"vtkMRMLLinearTransformNode"), "")
self.volumeOutputTransformSelectors[
"Output Transform"].selectNodeUponCreation = True
self.volumeOutputTransformSelectors[
"Output Transform"].addEnabled = True
self.volumeOutputTransformSelectors[
"Output Transform"].removeEnabled = True
self.volumeOutputTransformSelectors[
"Output Transform"].noneEnabled = True
self.volumeOutputTransformSelectors[
"Output Transform"].showHidden = False
self.volumeOutputTransformSelectors[
"Output Transform"].showChildNodeTypes = True
self.volumeOutputTransformSelectors["Output Transform"].setMRMLScene(
slicer.mrmlScene)
self.volumeOutputTransformSelectors["Output Transform"].setToolTip(
"Pick the Output Transform file")
outputSurfaceFormLayout.addRow(
"Output Transform",
self.volumeOutputTransformSelectors["Output Transform"])
#
# Apply Button
#
self.applyButton = qt.QPushButton("Run Registration")
self.applyButton.toolTip = "Run the registration algorithm."
self.applyButton.enabled = True
outputSurfaceFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
#for selector in self.volumeSelectors.values():
# selector.connect("currentNodeChanged(vtkMRMLNode*)", self.onApplyButton)
#self.volumeInitialTransformSelectors.values().connect('currentNodeChanged(vtkMRMLNode*)', self.onVolumeInitialTransformSelect)
# listen to the scene
#self.addObservers()
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
# # Instantiate and connect widgets
# ---------------------------- Window Settings -----------------------------
initializationCollapsibleButton = ctk.ctkCollapsibleButton()
initializationCollapsibleButton.text = "Window Initialization"
self.layout.addWidget(initializationCollapsibleButton)
initializationLayout = qt.QFormLayout(initializationCollapsibleButton)
self.stereoCheckBox = qt.QCheckBox()
initializationLayout.addRow("Stereoscopic mode:", self.stereoCheckBox)
self.startButton = qt.QPushButton("Create Windows")
initializationLayout.addRow(self.startButton)
self.showButton = qt.QPushButton("Show Windows")
initializationLayout.addRow(self.showButton)
self.hideButton = qt.QPushButton("Hide Windows")
initializationLayout.addRow(self.hideButton)
# ---------------------------- Stereo Settings -----------------------------
stereoCollapsibleButton = ctk.ctkCollapsibleButton()
stereoCollapsibleButton.text = "Stereoscopic Settings"
self.layout.addWidget(stereoCollapsibleButton)
stereoSettingsLayout = qt.QFormLayout(stereoCollapsibleButton)
self.upViewAngleButton = qt.QPushButton("Increase View Angle")
stereoSettingsLayout.addWidget(self.upViewAngleButton)
self.downViewAngleButton = qt.QPushButton("Decrease View Angle")
stereoSettingsLayout.addWidget(self.downViewAngleButton)
# ------------------- Transform and Tracking Settings ----------------------
trackingCollapsibleButton = ctk.ctkCollapsibleButton()
trackingCollapsibleButton.text = "Update Settings"
self.layout.addWidget(trackingCollapsibleButton)
trackingSettingsLayout = qt.QFormLayout(trackingCollapsibleButton)
self.followNodeSelector = slicer.qMRMLNodeComboBox()
self.followNodeSelector.nodeTypes = ["vtkMRMLMarkupsFiducialNode", "vtkMRMLLinearTransformNode"]
self.followNodeSelector.selectNodeUponCreation = False
self.followNodeSelector.noneEnabled = False
self.followNodeSelector.addEnabled = True
self.followNodeSelector.showHidden = False
self.followNodeSelector.setMRMLScene( slicer.mrmlScene )
self.followNodeSelector.setToolTip( "Pick Fiducial Node or Linear Transform to follow" )
trackingSettingsLayout.addRow("Path node (transform or fiducial)", self.followNodeSelector)
self.oculusNodeSelector = slicer.qMRMLNodeComboBox()
self.oculusNodeSelector.nodeTypes = ["vtkMRMLLinearTransformNode"]
self.oculusNodeSelector.selectNodeUponCreation = False
self.oculusNodeSelector.noneEnabled = False
self.oculusNodeSelector.addEnabled = True
self.oculusNodeSelector.showHidden = False
self.oculusNodeSelector.setMRMLScene( slicer.mrmlScene )
self.oculusNodeSelector.setToolTip( "Pick Transform for Oculus Rift" )
trackingSettingsLayout.addRow("Oculus Transform", self.oculusNodeSelector)
self.updateTrackingButton = qt.QPushButton("Update Tracking")
trackingSettingsLayout.addWidget(self.updateTrackingButton)
# ---------------------------- Update Export Image Settings -----------------------------
updatesCollapsibleButton = ctk.ctkCollapsibleButton()
updatesCollapsibleButton.text = "Update Settings"
self.layout.addWidget(updatesCollapsibleButton)
updateSettingsLayout = qt.QFormLayout(updatesCollapsibleButton)
self.createButton = qt.QPushButton("Create Image")
updateSettingsLayout.addWidget(self.createButton)
self.startRepeatButton = qt.QPushButton("Continually Create Images")
updateSettingsLayout.addWidget(self.startRepeatButton)
self.stopRepeatButton = qt.QPushButton("Stop Creating Images")
updateSettingsLayout.addWidget(self.stopRepeatButton)
# ---------------------------- Lighting Settings -----------------------------
lightingCollapsibleButton = ctk.ctkCollapsibleButton()
lightingCollapsibleButton.text = "Lighting Settings"
self.layout.addWidget(lightingCollapsibleButton)
lightingSettingsLayout = qt.QFormLayout(lightingCollapsibleButton)
# ----- Manual Lighting Control ------
manualLightingGroupBox = ctk.ctkCollapsibleGroupBox()
lightingSettingsLayout.addWidget(manualLightingGroupBox)
manualLightingLayout = qt.QFormLayout(manualLightingGroupBox)
self.lightSliderX = ctk.ctkSliderWidget()
self.lightSliderX.maximum = 500
self.lightSliderX.minimum = -500
self.lightSliderX.value = 0
self.lightSliderX.tracking = True
manualLightingLayout.addRow("X", self.lightSliderX)
self.lightSliderY = ctk.ctkSliderWidget()
self.lightSliderY.maximum = 500
self.lightSliderY.minimum = -500
self.lightSliderY.value = 0
self.lightSliderY.tracking = True
manualLightingLayout.addRow("Y", self.lightSliderY)
self.lightSliderZ = ctk.ctkSliderWidget()
self.lightSliderZ.maximum = 500
self.lightSliderZ.minimum = -500
self.lightSliderZ.value = 300
self.lightSliderZ.tracking = True
manualLightingLayout.addRow("Z", self.lightSliderZ)
# # Connections
self.startButton.connect('clicked(bool)', self.createWindows)
self.showButton.connect('clicked(bool)', self.showWindows)
self.hideButton.connect('clicked(bool)', self.hideWindows)
self.upViewAngleButton.connect('clicked(bool)', self.upViewAngle)
self.downViewAngleButton.connect('clicked(bool)', self.downViewAngle)
self.createButton.connect('clicked(bool)', self.createWindowImages)
self.startRepeatButton.connect('clicked(bool)', self.startCreatingImages)
self.stopRepeatButton.connect('clicked(bool)', self.stopCreatingImages)
self.followNodeSelector.connect('currentNodeChanged(bool)', self.setFollowNode)
self.updateTrackingButton.connect('clicked(bool)', self.updateTracking)
self.lightSliderX.connect('valueChanged(double)', self.onLightSliderChanged)
self.lightSliderY.connect('valueChanged(double)', self.onLightSliderChanged)
self.lightSliderZ.connect('valueChanged(double)', self.onLightSliderChanged)
self.timer = qt.QTimer()
self.timer.timeout.connect(self.createWindowImages)
self.layout.addStretch(1)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
# Instantiate and connect widgets ...
self.logic = NeedleTrackingLogic(None)
self.logic.setWidget(self)
#--------------------------------------------------
# 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 = "Reload"
reloadFormLayout.addWidget(self.reloadButton)
self.reloadButton.connect('clicked()', self.onReload)
#
#--------------------------------------------------
self.nCath = 1 # Number of catheters
#--------------------------------------------------
# GUI components
#
# Connection Area
#
connectionCollapsibleButton = ctk.ctkCollapsibleButton()
connectionCollapsibleButton.text = "Connection (OpenIGTLink)"
self.layout.addWidget(connectionCollapsibleButton)
# Layout within the dummy collapsible button
connectionFormLayout = qt.QFormLayout(connectionCollapsibleButton)
#--------------------------------------------------
# Connector Selector
#--------------------------------------------------
self.igtlConnector1 = NeedleTrackingIGTLConnector("Connector 1")
self.igtlConnector1.port = 18944
self.igtlConnector1.buildGUI(connectionFormLayout)
#--------------------------------------------------
# Catheter
#--------------------------------------------------
catheterCollapsibleButton = ctk.ctkCollapsibleButton()
catheterCollapsibleButton.text = "Tracking Node"
self.layout.addWidget(catheterCollapsibleButton)
catheterFormLayout = qt.QFormLayout(catheterCollapsibleButton)
#--------------------------------------------------
# Tracking node selector
trackingNodeGroupBox = ctk.ctkCollapsibleGroupBox()
trackingNodeGroupBox.title = "Tracking Node"
catheterFormLayout.addWidget(trackingNodeGroupBox)
trackingNodeFormLayout = qt.QFormLayout(trackingNodeGroupBox)
self.trackingDataSelector = slicer.qMRMLNodeComboBox()
self.trackingDataSelector.nodeTypes = ((
"vtkMRMLIGTLTrackingDataBundleNode"), "")
self.trackingDataSelector.selectNodeUponCreation = True
self.trackingDataSelector.addEnabled = True
self.trackingDataSelector.removeEnabled = False
self.trackingDataSelector.noneEnabled = False
self.trackingDataSelector.showHidden = True
self.trackingDataSelector.showChildNodeTypes = False
self.trackingDataSelector.setMRMLScene(slicer.mrmlScene)
self.trackingDataSelector.setToolTip("Incoming tracking data")
trackingNodeFormLayout.addRow("TrackingData: ",
self.trackingDataSelector)
#
# check box to trigger transform conversion
#
self.activeTrackingCheckBox = qt.QCheckBox()
self.activeTrackingCheckBox.checked = 0
self.activeTrackingCheckBox.enabled = 1
self.activeTrackingCheckBox.setToolTip("Activate Tracking")
trackingNodeFormLayout.addRow("Active: ", self.activeTrackingCheckBox)
#--------------------------------------------------
# Catheter Configuration
configGroupBox = ctk.ctkCollapsibleGroupBox()
configGroupBox.title = "Catheter Configuration"
configGroupBox.collapsed = True
catheterFormLayout.addWidget(configGroupBox)
configFormLayout = qt.QFormLayout(configGroupBox)
self.tipLengthSliderWidget = [None] * self.nCath
self.catheterDiameterSliderWidget = [None] * self.nCath
self.catheterOpacitySliderWidget = [None] * self.nCath
for cath in range(self.nCath):
#
# Tip Length (legnth between the catheter tip and the first coil)
#
self.tipLengthSliderWidget[cath] = ctk.ctkSliderWidget()
self.tipLengthSliderWidget[cath].singleStep = 0.5
self.tipLengthSliderWidget[cath].minimum = 0.0
self.tipLengthSliderWidget[cath].maximum = 100.0
self.tipLengthSliderWidget[cath].value = 10.0
self.tipLengthSliderWidget[cath].setToolTip(
"Set the length of the catheter tip.")
configFormLayout.addRow("Cath %d Tip Length (mm): " % cath,
self.tipLengthSliderWidget[cath])
#
# Catheter #1 Catheter diameter
#
self.catheterDiameterSliderWidget[cath] = ctk.ctkSliderWidget()
self.catheterDiameterSliderWidget[cath].singleStep = 0.1
self.catheterDiameterSliderWidget[cath].minimum = 0.1
self.catheterDiameterSliderWidget[cath].maximum = 10.0
self.catheterDiameterSliderWidget[cath].value = 1.0
self.catheterDiameterSliderWidget[cath].setToolTip(
"Set the diameter of the catheter")
configFormLayout.addRow("Cath %d Diameter (mm): " % cath,
self.catheterDiameterSliderWidget[cath])
#
# Catheter #1 Catheter opacity
#
self.catheterOpacitySliderWidget[cath] = ctk.ctkSliderWidget()
self.catheterOpacitySliderWidget[cath].singleStep = 0.1
self.catheterOpacitySliderWidget[cath].minimum = 0.0
self.catheterOpacitySliderWidget[cath].maximum = 1.0
self.catheterOpacitySliderWidget[cath].value = 1.0
self.catheterOpacitySliderWidget[cath].setToolTip(
"Set the opacity of the catheter")
configFormLayout.addRow("Cath %d Opacity: " % cath,
self.catheterOpacitySliderWidget[cath])
#
# Check box to show/hide coil labels
#
self.showCoilLabelCheckBox = qt.QCheckBox()
self.showCoilLabelCheckBox.checked = 0
self.showCoilLabelCheckBox.setToolTip("Show/hide coil labels")
configFormLayout.addRow("Show Coil Labels: ",
self.showCoilLabelCheckBox)
#--------------------------------------------------
# Coordinate System
#
coordinateGroupBox = ctk.ctkCollapsibleGroupBox()
coordinateGroupBox.title = "Coordinate System"
coordinateGroupBox.collapsed = True
catheterFormLayout.addWidget(coordinateGroupBox)
coordinateLayout = qt.QFormLayout(coordinateGroupBox)
self.coordinateRPlusRadioButton = qt.QRadioButton("+X")
self.coordinateRMinusRadioButton = qt.QRadioButton("-X")
self.coordinateRPlusRadioButton.checked = 1
self.coordinateRBoxLayout = qt.QHBoxLayout()
self.coordinateRBoxLayout.addWidget(self.coordinateRPlusRadioButton)
self.coordinateRBoxLayout.addWidget(self.coordinateRMinusRadioButton)
self.coordinateRGroup = qt.QButtonGroup()
self.coordinateRGroup.addButton(self.coordinateRPlusRadioButton)
self.coordinateRGroup.addButton(self.coordinateRMinusRadioButton)
coordinateLayout.addRow("Right:", self.coordinateRBoxLayout)
self.coordinateAPlusRadioButton = qt.QRadioButton("+Y")
self.coordinateAMinusRadioButton = qt.QRadioButton("-Y")
self.coordinateAPlusRadioButton.checked = 1
self.coordinateABoxLayout = qt.QHBoxLayout()
self.coordinateABoxLayout.addWidget(self.coordinateAPlusRadioButton)
self.coordinateABoxLayout.addWidget(self.coordinateAMinusRadioButton)
self.coordinateAGroup = qt.QButtonGroup()
self.coordinateAGroup.addButton(self.coordinateAPlusRadioButton)
self.coordinateAGroup.addButton(self.coordinateAMinusRadioButton)
coordinateLayout.addRow("Anterior:", self.coordinateABoxLayout)
self.coordinateSPlusRadioButton = qt.QRadioButton("+Z")
self.coordinateSMinusRadioButton = qt.QRadioButton("-Z")
self.coordinateSPlusRadioButton.checked = 1
self.coordinateSBoxLayout = qt.QHBoxLayout()
self.coordinateSBoxLayout.addWidget(self.coordinateSPlusRadioButton)
self.coordinateSBoxLayout.addWidget(self.coordinateSMinusRadioButton)
self.coordinateSGroup = qt.QButtonGroup()
self.coordinateSGroup.addButton(self.coordinateSPlusRadioButton)
self.coordinateSGroup.addButton(self.coordinateSMinusRadioButton)
coordinateLayout.addRow("Superior:", self.coordinateSBoxLayout)
#--------------------------------------------------
# Reslice
#
resliceCollapsibleButton = ctk.ctkCollapsibleButton()
resliceCollapsibleButton.text = "Image Reslice"
self.layout.addWidget(resliceCollapsibleButton)
#resliceLayout = qt.QFormLayout(resliceCollapsibleButton)
self.reslice = NeedleTrackingReslice("Image Reslice")
self.reslice.nCath = self.nCath
self.reslice.buildGUI(resliceCollapsibleButton)
#--------------------------------------------------
# Connections
#--------------------------------------------------
self.trackingDataSelector.connect("currentNodeChanged(vtkMRMLNode*)",
self.onTrackingDataSelected)
self.activeTrackingCheckBox.connect('toggled(bool)',
self.onActiveTracking)
for cath in range(self.nCath):
self.tipLengthSliderWidget[cath].connect(
"valueChanged(double)",
functools.partial(self.onTipLengthChanged, cath))
self.catheterDiameterSliderWidget[cath].connect(
"valueChanged(double)",
functools.partial(self.onCatheterDiameterChanged, cath))
self.catheterOpacitySliderWidget[cath].connect(
"valueChanged(double)",
functools.partial(self.onCatheterOpacityChanged, cath))
self.showCoilLabelCheckBox.connect('toggled(bool)',
self.onCoilLabelChecked)
self.coordinateRPlusRadioButton.connect('clicked(bool)',
self.onSelectCoordinate)
self.coordinateRMinusRadioButton.connect('clicked(bool)',
self.onSelectCoordinate)
self.coordinateAPlusRadioButton.connect('clicked(bool)',
self.onSelectCoordinate)
self.coordinateAMinusRadioButton.connect('clicked(bool)',
self.onSelectCoordinate)
self.coordinateSPlusRadioButton.connect('clicked(bool)',
self.onSelectCoordinate)
self.coordinateSMinusRadioButton.connect('clicked(bool)',
self.onSelectCoordinate)
# Add vertical spacer
self.layout.addStretch(1)
def setup(self):
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.onVCMRMLSceneChanged)
w = qt.QWidget()
layout = qt.QGridLayout()
w.setLayout(layout)
self.layout.addWidget(w)
w.show()
self.layout = layout
# create frames
self.inputFrame = ctk.ctkCollapsibleButton()
self.inputFrame.text = "Input"
self.inputFrame.collapsed = 0
inputFrameLayout = qt.QFormLayout(self.inputFrame)
self.layout.addWidget(self.inputFrame)
self.ctrlFrame = ctk.ctkCollapsibleButton()
self.ctrlFrame.text = "Frame control"
self.ctrlFrame.collapsed = 0
ctrlFrameLayout = qt.QGridLayout(self.ctrlFrame)
self.layout.addWidget(self.ctrlFrame)
self.plotFrame = ctk.ctkCollapsibleButton()
self.plotFrame.text = "Plotting"
self.plotFrame.collapsed = 0
plotFrameLayout = qt.QGridLayout(self.plotFrame)
self.layout.addWidget(self.plotFrame)
self.plotSettingsFrame = ctk.ctkCollapsibleButton()
self.plotSettingsFrame.text = "Settings"
self.plotSettingsFrame.collapsed = 1
plotSettingsFrameLayout = qt.QGridLayout(self.plotSettingsFrame)
plotFrameLayout.addWidget(self.plotSettingsFrame, 0, 1)
label = qt.QLabel('Input multivolume')
self.__mvSelector = slicer.qMRMLNodeComboBox()
self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.__mvSelector.setMRMLScene(slicer.mrmlScene)
self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.onVCMRMLSceneChanged)
self.__mvSelector.connect('currentNodeChanged(vtkMRMLNode*)',
self.onInputChanged)
self.__mvSelector.addEnabled = 0
inputFrameLayout.addRow(label, self.__mvSelector)
label = qt.QLabel('Input secondary multivolume')
self.fgSelector = slicer.qMRMLNodeComboBox()
self.fgSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.fgSelector.setMRMLScene(slicer.mrmlScene)
self.fgSelector.addEnabled = 0
self.fgSelector.noneEnabled = 1
self.fgSelector.toolTip = "Secondary multivolume will be used for the secondary \
plot in interactive charting. As an example, this can be used to overlay the \
curve obtained by fitting a model to the data"
inputFrameLayout.addRow(label, self.fgSelector)
# TODO: initialize the slider based on the contents of the labels array
# slider to scroll over metadata stored in the vector container being explored
self.__mdSlider = ctk.ctkSliderWidget()
label = qt.QLabel('Current frame number')
# "play" control
self.playButton = qt.QPushButton('Play')
self.playButton.toolTip = 'Iterate over multivolume frames'
self.playButton.checkable = True
ctrlFrameLayout.addWidget(label, 0, 0)
ctrlFrameLayout.addWidget(self.__mdSlider, 0, 1)
ctrlFrameLayout.addWidget(self.playButton, 0, 2)
self.playButton.connect('toggled(bool)', self.onPlayButtonToggled)
self.__mdSlider.connect('valueChanged(double)', self.onSliderChanged)
label = qt.QLabel('Current frame copy')
self.__vfSelector = slicer.qMRMLNodeComboBox()
self.__vfSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__vfSelector.setMRMLScene(slicer.mrmlScene)
self.__vfSelector.connect('mrmlSceneChanged(vtkMRMLScene*)',
self.onVFMRMLSceneChanged)
self.__vfSelector.addEnabled = 1
self.__vfSelector.enabled = 0
# do not show "children" of vtkMRMLScalarVolumeNode
self.__vfSelector.hideChildNodeTypes = ["vtkMRMLDiffusionWeightedVolumeNode", \
"vtkMRMLDiffusionTensorVolumeNode", "vtkMRMLVectorVolumeNode"]
self.extractFrame = False
self.extractButton = qt.QPushButton('Enable current frame copying')
self.extractButton.checkable = True
self.extractButton.connect('toggled(bool)', self.onExtractFrameToggled)
ctrlFrameLayout.addWidget(label, 1, 0)
ctrlFrameLayout.addWidget(self.__vfSelector, 1, 1, 1, 2)
ctrlFrameLayout.addWidget(self.extractButton, 2, 0, 1, 3)
# initialize slice observers (from DataProbe.py)
# keep list of pairs: [observee,tag] so they can be removed easily
self.styleObserverTags = []
# keep a map of interactor styles to sliceWidgets so we can easily get sliceLogic
self.sliceWidgetsPerStyle = {}
self.refreshObservers()
# label map for probing
label = qt.QLabel('Probed label volume')
self.__fSelector = slicer.qMRMLNodeComboBox()
self.__fSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__fSelector.addAttribute('vtkMRMLScalarVolumeNode', 'LabelMap',
'1')
self.__fSelector.toolTip = 'Label map to be probed'
self.__fSelector.setMRMLScene(slicer.mrmlScene)
self.__fSelector.addEnabled = 0
self.chartButton = qt.QPushButton('Chart')
self.chartButton.checkable = False
self.chartButton.connect('clicked()', self.onChartRequested)
plotSettingsFrameLayout.addWidget(label, 0, 0)
plotSettingsFrameLayout.addWidget(self.__fSelector, 0, 1)
plotSettingsFrameLayout.addWidget(self.chartButton, 0, 2)
self.iCharting = qt.QPushButton()
self.iCharting.text = 'Enable interactive charting'
self.iCharting.checkable = True
plotSettingsFrameLayout.addWidget(self.iCharting, 1, 0, 1, 3)
self.iCharting.setChecked(True)
self.iCharting.connect('toggled(bool)',
self.onInteractiveChartingChanged)
groupLabel = qt.QLabel('Interactive plotting mode:')
self.iChartingMode = qt.QButtonGroup()
self.iChartingIntensity = qt.QRadioButton('Signal intensity')
#self.iChartingIntensity.tooltip = 'Plot range adjusted dynamically to the range over the time course for the selected pixel'
self.iChartingIntensityFixedAxes = qt.QRadioButton(
'Fixed range intensity')
#self.iChartingIntensityFixedAxes.tooltip = "If checked, the extent of the vertical axis of the plot will be fixed to the range of the intensities in the input MultiVolume"
self.iChartingPercent = qt.QRadioButton('Percent change')
#self.iChartingPercent.tooltip = 'Percent change relative to the average of the first N frames (parameter set below)'
self.iChartingIntensity.setChecked(1)
self.groupWidget = qt.QWidget()
self.groupLayout = qt.QFormLayout(self.groupWidget)
self.groupLayout.addRow(groupLabel)
self.groupLayout.addRow(self.iChartingIntensity)
self.groupLayout.addRow(self.iChartingIntensityFixedAxes)
self.groupLayout.addRow(self.iChartingPercent)
self.baselineFrames = qt.QSpinBox()
self.baselineFrames.minimum = 1
label = qt.QLabel('Number of frames for baseline calculation')
self.groupLayout.addRow(label, self.baselineFrames)
self.xLogScaleCheckBox = qt.QCheckBox()
self.xLogScaleCheckBox.setChecked(0)
label = qt.QLabel('Use log scale for X axis')
self.groupLayout.addRow(self.xLogScaleCheckBox, label)
self.xLogScaleCheckBox.connect('stateChanged(int)',
self.onXLogScaleRequested)
self.yLogScaleCheckBox = qt.QCheckBox()
self.yLogScaleCheckBox.setChecked(0)
label = qt.QLabel('Use log scale for Y axis')
self.groupLayout.addRow(self.yLogScaleCheckBox, label)
self.yLogScaleCheckBox.connect('stateChanged(int)',
self.onYLogScaleRequested)
plotSettingsFrameLayout.addWidget(self.groupWidget, 2, 0)
# add chart container widget
self.__chartView = ctk.ctkVTKChartView(w)
plotFrameLayout.addWidget(self.__chartView, 3, 0, 1, 3)
self.__chart = self.__chartView.chart()
self.__chartTable = vtk.vtkTable()
self.__xArray = vtk.vtkFloatArray()
self.__yArray = vtk.vtkFloatArray()
# will crash if there is no name
self.__xArray.SetName('')
self.__yArray.SetName('signal intensity')
self.__chartTable.AddColumn(self.__xArray)
self.__chartTable.AddColumn(self.__yArray)
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
### Parameters Area
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Parameters"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
# fixed image (mrml input)
self.fixedMRMLSelector = slicer.qMRMLNodeComboBox()
self.fixedMRMLSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.fixedMRMLSelector.selectNodeUponCreation = True
self.fixedMRMLSelector.addEnabled = False
self.fixedMRMLSelector.removeEnabled = False
self.fixedMRMLSelector.noneEnabled = False
self.fixedMRMLSelector.showHidden = False
self.fixedMRMLSelector.showChildNodeTypes = False
self.fixedMRMLSelector.setMRMLScene( slicer.mrmlScene )
self.fixedMRMLSelector.setToolTip ("Choose either an image within the MRML scene, or a directory containing a DICOM image")
parametersFormLayout.addRow("Fixed image: ", self.fixedMRMLSelector)
# fixed image (directory input)
self.fixedInputDirectory = ctk.ctkDirectoryButton()
self.fixedInputDirectory.directory = qt.QDir.homePath()
parametersFormLayout.addRow("", self.fixedInputDirectory)
# moving image (mrml input)
self.movingMRMLSelector = slicer.qMRMLNodeComboBox()
self.movingMRMLSelector.nodeTypes = ["vtkMRMLScalarVolumeNode"]
self.movingMRMLSelector.selectNodeUponCreation = True
self.movingMRMLSelector.addEnabled = False
self.movingMRMLSelector.removeEnabled = False
self.movingMRMLSelector.noneEnabled = False
self.movingMRMLSelector.showHidden = False
self.movingMRMLSelector.showChildNodeTypes = False
self.movingMRMLSelector.setMRMLScene( slicer.mrmlScene )
self.fixedMRMLSelector.setToolTip ("Choose either an image within the MRML scene, or a directory containing a DICOM image")
parametersFormLayout.addRow("Moving image: ", self.movingMRMLSelector)
# moving image (directory input)
self.movingInputDirectory = ctk.ctkDirectoryButton()
self.movingInputDirectory.directory = qt.QDir.homePath()
parametersFormLayout.addRow("", self.movingInputDirectory)
# transform (mrml input)
self.xformMRMLSelector = slicer.qMRMLNodeComboBox()
self.xformMRMLSelector.nodeTypes = ["vtkMRMLLinearTransformNode"]
self.xformMRMLSelector.selectNodeUponCreation = True
self.xformMRMLSelector.addEnabled = False
self.xformMRMLSelector.removeEnabled = False
self.xformMRMLSelector.noneEnabled = False
self.xformMRMLSelector.showHidden = False
self.xformMRMLSelector.showChildNodeTypes = False
self.xformMRMLSelector.setMRMLScene( slicer.mrmlScene )
#self.xformMRMLSelector.setToolTip( "Pick the input to the algorithm." )
parametersFormLayout.addRow("Transform: ", self.xformMRMLSelector)
# output directory selector
self.outputDirectory = ctk.ctkDirectoryButton()
self.outputDirectory.directory = qt.QDir.homePath()
parametersFormLayout.addRow("Output Directory: ", self.outputDirectory)
# check box to trigger taking screen shots for later use in tutorials
self.enableScreenshotsFlagCheckBox = qt.QCheckBox()
self.enableScreenshotsFlagCheckBox.checked = 0
self.enableScreenshotsFlagCheckBox.setToolTip("If checked, take screen shots for tutorials. Use Save Data to write them to disk.")
# parametersFormLayout.addRow("Enable Screenshots", self.enableScreenshotsFlagCheckBox)
# 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.")
# parametersFormLayout.addRow("Screenshot scale factor", self.screenshotScaleFactorSliderWidget)
# Apply Button
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = False
if (self.fixedMRMLSelector.currentNode()
and self.movingMRMLSelector.currentNode()
and self.xformMRMLSelector.currentNode()):
self.applyButton.enabled = True
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
self.fixedMRMLSelector.connect(
"currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.movingMRMLSelector.connect(
"currentNodeChanged(vtkMRMLNode*)", self.onSelect)
self.xformMRMLSelector.connect(
"currentNodeChanged(vtkMRMLNode*)", self.onSelect)
# Add vertical spacer
self.layout.addStretch(1)
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 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 = "AddManyMarkupsFiducialTest 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)
#
# number of fiducials to add
#
self.numToAddSliderWidget = ctk.ctkSliderWidget()
self.numToAddSliderWidget.singleStep = 1.0
self.numToAddSliderWidget.minimum = 0.0
self.numToAddSliderWidget.maximum = 1000.0
self.numToAddSliderWidget.value = 100.0
self.numToAddSliderWidget.toolTip = "Set the number of fiducials to add."
parametersFormLayout.addRow("Number of Fiducials to Add",
self.numToAddSliderWidget)
#
# check box to trigger fewer modify events, adding all the new points
# is wrapped inside of a StartModify/EndModify block
#
self.fewerModifyFlagCheckBox = qt.QCheckBox()
self.fewerModifyFlagCheckBox.checked = 0
self.fewerModifyFlagCheckBox.toolTip = 'If checked, wrap adding points inside of a StartModify - EndModify block'
parametersFormLayout.addRow("Fewer Modify Events",
self.fewerModifyFlagCheckBox)
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
# Add vertical spacer
self.layout.addStretch(1)
def setup( self ):
self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onVCMRMLSceneChanged)
w = qt.QWidget()
layout = qt.QGridLayout()
w.setLayout(layout)
self.layout.addWidget(w)
w.show()
self.layout = layout
# create frames
self.inputFrame = ctk.ctkCollapsibleButton()
self.inputFrame.text = "Input"
self.inputFrame.collapsed = 0
inputFrameLayout = qt.QFormLayout(self.inputFrame)
self.layout.addWidget(self.inputFrame)
self.ctrlFrame = ctk.ctkCollapsibleButton()
self.ctrlFrame.text = "Frame control"
self.ctrlFrame.collapsed = 0
ctrlFrameLayout = qt.QGridLayout(self.ctrlFrame)
self.layout.addWidget(self.ctrlFrame)
self.plotFrame = ctk.ctkCollapsibleButton()
self.plotFrame.text = "Plotting"
self.plotFrame.collapsed = 0
plotFrameLayout = qt.QGridLayout(self.plotFrame)
self.layout.addWidget(self.plotFrame)
self.plotSettingsFrame = ctk.ctkCollapsibleButton()
self.plotSettingsFrame.text = "Settings"
self.plotSettingsFrame.collapsed = 1
plotSettingsFrameLayout = qt.QGridLayout(self.plotSettingsFrame)
plotFrameLayout.addWidget(self.plotSettingsFrame,0,1)
label = qt.QLabel('Input multivolume')
self.__mvSelector = slicer.qMRMLNodeComboBox()
self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.__mvSelector.setMRMLScene(slicer.mrmlScene)
self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onVCMRMLSceneChanged)
self.__mvSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onInputChanged)
self.__mvSelector.addEnabled = 0
inputFrameLayout.addRow(label, self.__mvSelector)
label = qt.QLabel('Input secondary multivolume')
self.fgSelector = slicer.qMRMLNodeComboBox()
self.fgSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
self.fgSelector.setMRMLScene(slicer.mrmlScene)
self.fgSelector.addEnabled = 0
self.fgSelector.noneEnabled = 1
self.fgSelector.toolTip = "Secondary multivolume will be used for the secondary \
plot in interactive charting. As an example, this can be used to overlay the \
curve obtained by fitting a model to the data"
inputFrameLayout.addRow(label, self.fgSelector)
# TODO: initialize the slider based on the contents of the labels array
# slider to scroll over metadata stored in the vector container being explored
self.__mdSlider = ctk.ctkSliderWidget()
label = qt.QLabel('Current frame number')
# "play" control
self.playButton = qt.QPushButton('Play')
self.playButton.toolTip = 'Iterate over multivolume frames'
self.playButton.checkable = True
ctrlFrameLayout.addWidget(label, 0, 0)
ctrlFrameLayout.addWidget(self.__mdSlider, 0, 1)
ctrlFrameLayout.addWidget(self.playButton, 0, 2)
self.playButton.connect('toggled(bool)', self.onPlayButtonToggled)
self.__mdSlider.connect('valueChanged(double)', self.onSliderChanged)
label = qt.QLabel('Current frame copy')
self.__vfSelector = slicer.qMRMLNodeComboBox()
self.__vfSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__vfSelector.setMRMLScene(slicer.mrmlScene)
self.__vfSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onVFMRMLSceneChanged)
self.__vfSelector.addEnabled = 1
self.__vfSelector.enabled = 0
# do not show "children" of vtkMRMLScalarVolumeNode
self.__vfSelector.hideChildNodeTypes = ["vtkMRMLDiffusionWeightedVolumeNode", \
"vtkMRMLDiffusionTensorVolumeNode", "vtkMRMLVectorVolumeNode"]
self.extractFrame = False
self.extractButton = qt.QPushButton('Enable current frame copying')
self.extractButton.checkable = True
self.extractButton.connect('toggled(bool)', self.onExtractFrameToggled)
ctrlFrameLayout.addWidget(label, 1, 0)
ctrlFrameLayout.addWidget(self.__vfSelector,1,1,1,2)
ctrlFrameLayout.addWidget(self.extractButton,2,0,1,3)
# initialize slice observers (from DataProbe.py)
# keep list of pairs: [observee,tag] so they can be removed easily
self.styleObserverTags = []
# keep a map of interactor styles to sliceWidgets so we can easily get sliceLogic
self.sliceWidgetsPerStyle = {}
self.refreshObservers()
# label map for probing
label = qt.QLabel('Probed label volume')
self.__fSelector = slicer.qMRMLNodeComboBox()
self.__fSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
self.__fSelector.addAttribute('vtkMRMLScalarVolumeNode','LabelMap','1')
self.__fSelector.toolTip = 'Label map to be probed'
self.__fSelector.setMRMLScene(slicer.mrmlScene)
self.__fSelector.addEnabled = 0
self.chartButton = qt.QPushButton('Chart')
self.chartButton.checkable = False
self.chartButton.connect('clicked()', self.onChartRequested)
plotSettingsFrameLayout.addWidget(label,0,0)
plotSettingsFrameLayout.addWidget(self.__fSelector,0,1)
plotSettingsFrameLayout.addWidget(self.chartButton,0,2)
self.iCharting = qt.QPushButton()
self.iCharting.text = 'Enable interactive charting'
self.iCharting.checkable = True
plotSettingsFrameLayout.addWidget(self.iCharting,1,0,1,3)
self.iCharting.setChecked(True)
self.iCharting.connect('toggled(bool)', self.onInteractiveChartingChanged)
groupLabel = qt.QLabel('Interactive plotting mode:')
self.iChartingMode = qt.QButtonGroup()
self.iChartingIntensity = qt.QRadioButton('Signal intensity')
#self.iChartingIntensity.tooltip = 'Plot range adjusted dynamically to the range over the time course for the selected pixel'
self.iChartingIntensityFixedAxes = qt.QRadioButton('Fixed range intensity')
#self.iChartingIntensityFixedAxes.tooltip = "If checked, the extent of the vertical axis of the plot will be fixed to the range of the intensities in the input MultiVolume"
self.iChartingPercent = qt.QRadioButton('Percent change')
#self.iChartingPercent.tooltip = 'Percent change relative to the average of the first N frames (parameter set below)'
self.iChartingIntensity.setChecked(1)
self.groupWidget = qt.QWidget()
self.groupLayout = qt.QFormLayout(self.groupWidget)
self.groupLayout.addRow(groupLabel)
self.groupLayout.addRow(self.iChartingIntensity)
self.groupLayout.addRow(self.iChartingIntensityFixedAxes)
self.groupLayout.addRow(self.iChartingPercent)
self.baselineFrames = qt.QSpinBox()
self.baselineFrames.minimum = 1
label = qt.QLabel('Number of frames for baseline calculation')
self.groupLayout.addRow(label,self.baselineFrames)
self.xLogScaleCheckBox = qt.QCheckBox()
self.xLogScaleCheckBox.setChecked(0)
label = qt.QLabel('Use log scale for X axis')
self.groupLayout.addRow(self.xLogScaleCheckBox,label)
self.xLogScaleCheckBox.connect('stateChanged(int)', self.onXLogScaleRequested)
self.yLogScaleCheckBox = qt.QCheckBox()
self.yLogScaleCheckBox.setChecked(0)
label = qt.QLabel('Use log scale for Y axis')
self.groupLayout.addRow(self.yLogScaleCheckBox,label)
self.yLogScaleCheckBox.connect('stateChanged(int)', self.onYLogScaleRequested)
plotSettingsFrameLayout.addWidget(self.groupWidget,2,0)
# add chart container widget
self.__chartView = ctk.ctkVTKChartView(w)
plotFrameLayout.addWidget(self.__chartView,3,0,1,3)
self.__chart = self.__chartView.chart()
self.__chartTable = vtk.vtkTable()
self.__xArray = vtk.vtkFloatArray()
self.__yArray = vtk.vtkFloatArray()
# will crash if there is no name
self.__xArray.SetName('')
self.__yArray.SetName('signal intensity')
self.__chartTable.AddColumn(self.__xArray)
self.__chartTable.AddColumn(self.__yArray)
def setup(self):
# 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 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 = "SlicerCIPExample 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)
#
# 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.")
parametersFormLayout.addRow("Screenshot scale factor",
self.screenshotScaleFactorSliderWidget)
#
# 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):
self.conoProbeConnectorLogic = ConoProbeConnectorLogic()
self.firstInitColouring = True
ScriptedLoadableModuleWidget.setup(self)
# Icons stuff
self.conoProbeConnectorModuleDirectoryPath = slicer.modules.conoprobeconnector.path.replace("ConoProbeConnector.py","")
self.playIcon = qt.QIcon(self.conoProbeConnectorModuleDirectoryPath + '/Resources/Icons/playIcon.png')
self.stopIcon = qt.QIcon(self.conoProbeConnectorModuleDirectoryPath + '/Resources/Icons/stopIcon.png')
self.recordIcon = qt.QIcon(self.conoProbeConnectorModuleDirectoryPath + '/Resources/Icons/recordIcon.png')
self.restartIcon = qt.QIcon(self.conoProbeConnectorModuleDirectoryPath + '/Resources/Icons/restartIcon.png')
self.saveIcon = qt.QIcon(self.conoProbeConnectorModuleDirectoryPath + '/Resources/Icons/saveIcon.png')
self.errorStyleSheet = "QLabel { color : #FF0000; \
font: bold 14px}"
self.defaultStyleSheet = "QLabel { color : #000000; \
font: bold 14px}"
######################################################## Recorder
recorderCollapsibleButton = ctk.ctkCollapsibleButton()
recorderCollapsibleButton.text = "ConoProbe Connector"
recorderCollapsibleButton.collapsed = False
self.layout.addWidget(recorderCollapsibleButton)
recorderFormLayout = qt.QFormLayout(recorderCollapsibleButton)
# Output
self.recorderOutputGroupBox = ctk.ctkCollapsibleGroupBox()
self.recorderOutputGroupBox.setTitle("Output")
recorderOutputFormLayout = qt.QFormLayout(self.recorderOutputGroupBox)
recorderFormLayout.addRow(self.recorderOutputGroupBox)
self.lensMinLabel = qt.QLabel('-')
self.lensMinLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel10 = qt.QLabel('Lens Min. Dist. (mm): ')
self.QFormLayoutLeftLabel10.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel10, self.lensMinLabel)
self.distanceLabel = qt.QLabel('-')
self.distanceLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel1 = qt.QLabel('Distance (mm): ')
self.QFormLayoutLeftLabel1.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel1, self.distanceLabel)
self.lensMaxLabel = qt.QLabel('-')
self.lensMaxLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel11 = qt.QLabel('Lens Max. Dist. (mm): ')
self.QFormLayoutLeftLabel11.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel11, self.lensMaxLabel)
dummyLabel1 = qt.QLabel('')
recorderOutputFormLayout.addRow('', dummyLabel1)
self.powerLabel = qt.QLabel('-')
self.powerLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel8 = qt.QLabel('Laser Power (arb. unit): ')
self.QFormLayoutLeftLabel8.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel8, self.powerLabel)
self.frequencyLabel = qt.QLabel('-')
self.frequencyLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel9 = qt.QLabel('Laser Frequency (Hz): ')
self.QFormLayoutLeftLabel9.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel9, self.frequencyLabel)
self.nbrOfPointsRecordedLabel = qt.QLabel('0')
self.nbrOfPointsRecordedLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel2 = qt.QLabel('Nbr. of Points Recorded: ')
self.QFormLayoutLeftLabel2.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel2, self.nbrOfPointsRecordedLabel)
self.positionLabel = qt.QLabel('-')
self.positionLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel3 = qt.QLabel('Position ([r, a, s]): ')
self.QFormLayoutLeftLabel3.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel3, self.positionLabel)
self.timeLabel = qt.QLabel('-')
self.timeLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel4 = qt.QLabel('Recording Time (s): ')
self.QFormLayoutLeftLabel4.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel4, self.timeLabel)
self.snrLabel = qt.QLabel('-')
self.snrLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel5 = qt.QLabel('SNR (%): ')
self.QFormLayoutLeftLabel5.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel5, self.snrLabel)
self.totalLabel = qt.QLabel('-')
self.totalLabel.setStyleSheet(self.defaultStyleSheet)
self.QFormLayoutLeftLabel6 = qt.QLabel('Total: ')
self.QFormLayoutLeftLabel6.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel6, self.totalLabel)
dummyLabel2 = qt.QLabel('')
recorderOutputFormLayout.addRow('', dummyLabel2)
self.infoLabel = qt.QLabel('Make sure Plus is running')
self.infoLabel.setWordWrap(True)
self.infoLabel.setStyleSheet(self.errorStyleSheet)
self.QFormLayoutLeftLabel7 = qt.QLabel('INFO: ')
self.QFormLayoutLeftLabel7.setStyleSheet(self.defaultStyleSheet)
recorderOutputFormLayout.addRow(self.QFormLayoutLeftLabel7, self.infoLabel)
# Live Filtering
self.recorderFilteringGroupBox = ctk.ctkCollapsibleGroupBox()
self.recorderFilteringGroupBox.setTitle("Live Filtering")
recorderFilteringFormLayout = qt.QFormLayout(self.recorderFilteringGroupBox)
recorderFormLayout.addRow(self.recorderFilteringGroupBox)
self.snrFilteringSlider = ctk.ctkSliderWidget()
self.snrFilteringSlider.setDecimals(0)
self.snrFilteringSlider.singleStep = 1
self.snrFilteringSlider.minimum = 0
self.snrFilteringSlider.maximum = 100
self.snrFilteringSlider.value = 40
recorderFilteringFormLayout.addRow('SNR (%): ', self.snrFilteringSlider)
self.distanceFilteringSlider = ctk.ctkRangeWidget()
self.distanceFilteringSlider.minimum = 0
self.distanceFilteringSlider.maximum = 500
self.distanceFilteringSlider.setValues(0, 500)
recorderFilteringFormLayout.addRow('Distance (mm): ', self.distanceFilteringSlider)
# Intuitive Colouring
self.colouringGroupBox = ctk.ctkCollapsibleGroupBox()
self.colouringGroupBox.setTitle("Intuitive Colouring")
colouringFormLayout = qt.QFormLayout(self.colouringGroupBox)
recorderFormLayout.addRow(self.colouringGroupBox)
hBoxLayoutColouring = qt.QHBoxLayout()
colouringFormLayout.addRow(hBoxLayoutColouring)
self.rasLabel = qt.QLabel('Direction: ')
hBoxLayoutColouring.addWidget(self.rasLabel)
self.rasComboBox = qt.QComboBox()
self.rasComboBox.addItem('R')
self.rasComboBox.addItem('A')
self.rasComboBox.addItem('S')
hBoxLayoutColouring.addWidget(self.rasComboBox)
self.minLabel = qt.QLabel(' Minimum: ')
hBoxLayoutColouring.addWidget(self.minLabel)
self.minSpinBox = qt.QDoubleSpinBox ()
self.minSpinBox.setMinimum(-500)
self.minSpinBox.setMaximum(500)
self.minSpinBox.setSingleStep(0.1)
self.minSpinBox.setValue(0.0)
hBoxLayoutColouring.addWidget(self.minSpinBox)
self.maxLabel = qt.QLabel(' Maximum: ')
hBoxLayoutColouring.addWidget(self.maxLabel)
self.maxSpinBox = qt.QDoubleSpinBox ()
self.maxSpinBox.setMinimum(-500)
self.maxSpinBox.setMaximum(500)
self.maxSpinBox.setSingleStep(0.1)
self.maxSpinBox.setValue(0.0)
hBoxLayoutColouring.addWidget(self.maxSpinBox)
hBoxLayoutColouring.addStretch()
# Controls
self.controlsGroupBox = ctk.ctkCollapsibleGroupBox()
self.controlsGroupBox.setTitle("Controls")
controlsFormLayout = qt.QFormLayout(self.controlsGroupBox)
recorderFormLayout.addRow(self.controlsGroupBox)
hBoxLayoutControls = qt.QHBoxLayout()
controlsFormLayout.addRow(hBoxLayoutControls)
self.initButton = qt.QPushButton(" Init")
self.initButton.setIcon(self.playIcon)
self.initButton.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
self.initButton.enabled = True
hBoxLayoutControls.addWidget(self.initButton)
self.recordButton = qt.QPushButton(" Record")
self.recordButton.setIcon(self.recordIcon)
self.recordButton.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
self.recordButton.enabled = False
self.recordButton.checkable = True
hBoxLayoutControls.addWidget(self.recordButton)
self.probeDialogButton = qt.QPushButton("ProbeDialog")
self.probeDialogButton.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
self.probeDialogButton.enabled = False
hBoxLayoutControls.addWidget(self.probeDialogButton)
self.saveButton = qt.QPushButton(" Save")
self.saveButton.setIcon(self.saveIcon)
self.saveButton.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
self.saveButton.enabled = False
hBoxLayoutControls.addWidget(self.saveButton)
self.resetButton = qt.QPushButton(" Reset")
self.resetButton.setIcon(self.restartIcon)
self.resetButton.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
self.resetButton.enabled = False
hBoxLayoutControls.addWidget(self.resetButton)
hBoxCheckBoxes = qt.QHBoxLayout()
controlsFormLayout.addRow(hBoxCheckBoxes)
self.viewpointCheckBox = qt.QCheckBox('Enable Viewpoint')
self.viewpointCheckBox.checked = True
self.viewpointCheckBox.enabled = False
hBoxCheckBoxes.addWidget(self.viewpointCheckBox)
self.singlePointCheckBox = qt.QCheckBox('Single Measurements')
self.singlePointCheckBox.checked = False
self.singlePointCheckBox.enabled = False
hBoxCheckBoxes.addWidget(self.singlePointCheckBox)
self.plusRemoteCheckBox = qt.QCheckBox('Record PLUS Data Stream')
self.plusRemoteCheckBox.checked = False
self.plusRemoteCheckBox.enabled = False
hBoxCheckBoxes.addWidget(self.plusRemoteCheckBox)
# Post-Processing
self.postProcessingGroupBox = ctk.ctkCollapsibleGroupBox()
self.postProcessingGroupBox.setTitle("Post-Processing")
postProcessingFormLayout = qt.QFormLayout(self.postProcessingGroupBox)
recorderFormLayout.addRow(self.postProcessingGroupBox)
self.snrPostProcessingSlider = ctk.ctkSliderWidget()
self.snrPostProcessingSlider.setDecimals(0)
self.snrPostProcessingSlider.singleStep = 1
self.snrPostProcessingSlider.minimum = 0
self.snrPostProcessingSlider.maximum = 100
self.snrPostProcessingSlider.value = 0
postProcessingFormLayout.addRow('SNR (%): ', self.snrPostProcessingSlider)
self.distancePostProcessingSlider = ctk.ctkRangeWidget()
self.distancePostProcessingSlider.minimum = 0
self.distancePostProcessingSlider.maximum = 500
self.distancePostProcessingSlider.setValues(0, 500)
postProcessingFormLayout.addRow('Distance (mm): ', self.distancePostProcessingSlider)
hBoxLayoutPostProcessing = qt.QHBoxLayout()
postProcessingFormLayout.addRow(hBoxLayoutPostProcessing)
self.undoButton = qt.QPushButton("Undo")
self.undoButton.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
self.undoButton.enabled = False
hBoxLayoutPostProcessing.addWidget(self.undoButton)
self.applyButton = qt.QPushButton("Apply")
self.applyButton.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
self.applyButton.enabled = False
hBoxLayoutPostProcessing.addWidget(self.applyButton)
######################################################## Connections
self.snrFilteringSlider.connect('valueChanged(double)', self.onSnrFilteringValueChanged)
self.distanceFilteringSlider.connect('maximumValueChanged(double)', self.onDistanceFilteringMaximumValueChanged)
self.distanceFilteringSlider.connect('minimumValueChanged(double)', self.onDistanceFilteringMinimumValueChanged)
self.initButton.connect('clicked(bool)', self.onInitClicked)
self.recordButton.connect('clicked(bool)', self.onRecordClicked)
self.resetButton.connect('clicked(bool)', self.onResetClicked)
self.probeDialogButton.connect('clicked(bool)', self.onProbeDialogClicked)
self.saveButton.connect('clicked(bool)', self.onSaveClicked)
self.undoButton.connect('clicked(bool)', self.onUndoClicked)
self.applyButton.connect('clicked(bool)', self.onApplyClicked)
self.viewpointCheckBox.connect('stateChanged(int)', self.onViewpointChecked)
self.plusRemoteCheckBox.connect('stateChanged(int)', self.onPlusRemoteChecked)
# Add vertical spacer
self.layout.addStretch(1)
# Create Plus connector and activate it
self.conoProbeConnectorLogic.setupPlus()
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 = "NeurosurgicalPlanningTutorialMarkupsSelfTest 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)
#
# 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.")
parametersFormLayout.addRow("Screenshot scale factor",
self.screenshotScaleFactorSliderWidget)
# Apply Button
#
self.applyButton = qt.QPushButton("Apply")
self.applyButton.toolTip = "Run the algorithm."
self.applyButton.enabled = True
parametersFormLayout.addRow(self.applyButton)
# connections
self.applyButton.connect('clicked(bool)', self.onApplyButton)
# Add vertical spacer
self.layout.addStretch(1)
def 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)
