def __init__( self, stepid ):
self.initialize( stepid )
self.setName( '5. Place Screws' )
self.setDescription( 'Load screw models and change orientation using sliders' )
self.screwPath = None
self.screwName = None
self.coords = [0,0,0]
self.matrix1 = vtk.vtkMatrix3x3()
self.matrix2 = vtk.vtkMatrix3x3()
self.matrix3 = vtk.vtkMatrix3x3()
self.matrixScrew = vtk.vtkMatrix4x4()
self.fiduciallist = []
self.screwSummary = []
self.screwList = []
self.currentFidIndex = 0
self.currentFidLabel = None
self.fidNode = slicer.vtkMRMLMarkupsFiducialNode()
self.valueTemp1 = 0
self.valueTemp2 = 0
self.driveTemp = 0
self.__loadScrewButton = None
self.__parent = super( ScrewStep, self )
self.timer = qt.QTimer()
self.timer.setInterval(2)
self.timer.connect('timeout()', self.driveScrew)
self.timer2 = qt.QTimer()
self.timer2.setInterval(2)
self.timer2.connect('timeout()', self.reverseScrew)
self.screwInsert = 0.0
def __init__(self, parent=None):
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
self.parent.setMRMLScene(slicer.mrmlScene)
else:
self.parent = parent
self.layout = self.parent.layout()
self.transformNode = None
self.transformNodeObserverTag = None
self.transformObserverTag = None
self.transform = None
self.acquireButtonFlag = False
self.collectSignal = False
self.pointerPosition = np.zeros(3)
self.pointsCounts = 0
self.recordedpoint = np.zeros(3)
self.statusTimer = qt.QTimer()
self.statusTimer.setInterval(100)
self.statusTimer.connect('timeout()', self.changeTrackerStatus)
if not parent:
self.setup()
self.parent.show()
def __init__(self, parent=None):
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
else:
self.parent = parent
self.layout = self.parent.layout()
# this flag is 1 if there is an update in progress
self.__updating = 1
self.__mvNode = None
self.extractFrame = False
# chart view node
self.__cvn = None
# data node
#slicer.mrmlScene.AddNode(slicer.vtkMRMLDoubleArrayNode())
# chart node
self.__cn = slicer.vtkMRMLChartNode()
self.__cn.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(self.__cn)
# image play setup
self.timer = qt.QTimer()
self.timer.setInterval(50)
self.timer.connect('timeout()', self.goToNext)
def __init__(self, parent=None):
self.testingServer = None
# state management for compressing events
# - each time an update is requested, start the singleShot timer
# - if the update is requested before the timeout, the call to timer.start() resets it
# - the actual update only happens when the the full time elapses since the last request
self.updateRecentActivityTimer = qt.QTimer()
self.updateRecentActivityTimer.singleShot = True
self.updateRecentActivityTimer.interval = 500
self.updateRecentActivityTimer.connect(
'timeout()', self.onUpateRecentActivityRequestTimeout)
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
self.parent.setMRMLScene(slicer.mrmlScene)
self.layout = self.parent.layout()
self.setup()
self.parent.show()
else:
self.parent = parent
self.layout = parent.layout()
globals()['d'] = self
def __init__(self, parent=None):
self.testingServer = None
self.dicomBrowser = None
# options for browser
self.browserPersistent = False
# TODO: are these wrapped so we can avoid magic numbers?
self.dicomModelUIDRole = 32
self.dicomModelTypeRole = self.dicomModelUIDRole + 1
self.dicomModelTypes = ('Root', 'Patient', 'Study', 'Series', 'Image')
# state management for compressing events
# - each time an update is requested, start the singleShot timer
# - if the update is requested before the timeout, the call to timer.start() resets it
# - the actual update only happens when the the full time elapses since the last request
self.updateRecentActivityTimer = qt.QTimer()
self.updateRecentActivityTimer.singleShot = True
self.updateRecentActivityTimer.interval = 500
self.updateRecentActivityTimer.connect(
'timeout()', self.onUpateRecentActivityRequestTimeout)
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
self.parent.setMRMLScene(slicer.mrmlScene)
self.layout = self.parent.layout()
self.setup()
self.parent.show()
else:
self.parent = parent
self.layout = parent.layout()
globals()['d'] = self
def setupCalibrationPanel(self):
logging.debug('setupCalibrationPanel')
self.calibrationCollapsibleButton.setProperty('collapsedHeight', 20)
setButtonStyle(self.calibrationCollapsibleButton, 2.0)
self.calibrationCollapsibleButton.text = 'Tool calibration'
self.sliceletPanelLayout.addWidget(self.calibrationCollapsibleButton)
self.calibrationLayout = qt.QFormLayout(
self.calibrationCollapsibleButton)
self.calibrationLayout.setContentsMargins(12, 4, 4, 4)
self.calibrationLayout.setSpacing(4)
self.cauteryPivotButton = qt.QPushButton('Start cautery calibration')
setButtonStyle(self.cauteryPivotButton)
self.calibrationLayout.addRow(self.cauteryPivotButton)
self.needlePivotButton = qt.QPushButton('Start needle calibration')
setButtonStyle(self.needlePivotButton)
self.calibrationLayout.addRow(self.needlePivotButton)
self.countdownLabel = qt.QLabel()
self.calibrationLayout.addRow(self.countdownLabel)
self.pivotSamplingTimer = qt.QTimer()
self.pivotSamplingTimer.setInterval(500)
self.pivotSamplingTimer.setSingleShot(True)
def onEntry(self, comingFrom, transitionType):
moduloName = 'simuladorTornillosPediculares'
slicer.mrmlScene.Clear(0)
super(Inicio, self).onEntry(comingFrom, transitionType)
self.ctimer = qt.QTimer()
self.ctimer.singleShot(0, self.killButton)
def onCompute(self):
print('Computing ...')
sampling_level = self.spinBox_sampling.value
#sampling
if sampling_level > 0:
fileA = self.pathLineEdit_fileA.currentPath
fileB = self.pathLineEdit_fileB.currentPath
self.logic.samplePolydatas(fileA, fileB, sampling_level)
self.checkThreadTimer = qt.QTimer()
self.checkThreadTimer.connect('timeout()', self.onCheckSampling)
self.checkThreadTimer.start(100)
self.pushButton_compute.setText('Sampling ...')
self.pushButton_compute.setDisable(True)
#self.pushButton_compute.Disable(True)
return
#Getting parameters
nb_bins = self.spinBox_bins.value
signed = False
if self.comboBox_distanceType.currentText == 'Signed Distance':
signed = True
correspondence = False
if self.comboBox_correspondence.currentText == 'Yes':
correspondence = True
self.logic.fileA_out = self.pathLineEdit_fileA.currentPath
self.logic.fileB_out = self.pathLineEdit_fileB.currentPath
#self.logic.stats.Set('A',fileA_path)
#self.logic.stats.Set('B',fileB_path)
#computing
self.pushButton_compute.setText("Computing ...")
self.pushButton_compute.setDisable(True)
self.logic.computeStats(nb_bins, signed, correspondence)
self.checkThreadTimer = qt.QTimer()
self.checkThreadTimer.connect('timeout()', self.onCheckCompute)
self.checkThreadTimer.start(100)
return
def start(self):
"""Create the subprocess and set up a polling timer"""
if self.timer:
self.stop()
self.timer = qt.QTimer()
self.timer.setInterval(self.interval)
self.timer.connect('timeout()', self.tick)
self.timer.start()
def onEntry(self, comingFrom, transitionType):
super(MenuProfesor, self).onEntry(comingFrom, transitionType)
self.ctimer = qt.QTimer()
self.ctimer.singleShot(0, self.killButton)
slicer.mrmlScene.Clear(0)
self.cargarScene()
self.contadorTornillos1 = 0
self.contadorTornillos2 = 0
self.tornillo1 = None
def create(self):
super(DoubleThresholdEffectOptions,self).create()
self.thresholdLabel = qt.QLabel("DoubleThreshold Inner Range:", self.frame)
self.thresholdLabel.setToolTip("Set the range of the background values that should will labeled.")
self.threshold = ctk.ctkRangeWidget(self.frame)
self.threshold.spinBoxAlignment = 0xff # put enties on top
self.threshold.singleStep = 0.01
self.outerThresholdLabel = qt.QLabel("DoubleThreshold Outter Range:", self.frame)
self.outerThresholdLabel.setToolTip("Set the range of the background values that must be connected to the inner range to be labeled.")
self.outerThreshold = ctk.ctkRangeWidget(self.frame)
self.outerThreshold.spinBoxAlignment = 0xff # put enties on top
self.outerThreshold.singleStep = 0.01
# set min/max based on current range
success, lo, hi = self.getBackgroundScalarRange()
if success:
self.threshold.minimum, self.threshold.maximum = lo, hi
self.threshold.singleStep = (hi - lo) / 1000.
self.outerThreshold.minimum, self.outerThreshold.maximum = lo, hi
self.outerThreshold.singleStep = (hi - lo) / 1000.
self.frame.layout().addWidget(self.thresholdLabel)
self.widgets.append(self.thresholdLabel)
self.frame.layout().addWidget(self.threshold)
self.widgets.append(self.threshold)
self.frame.layout().addWidget(self.outerThresholdLabel)
self.widgets.append(self.outerThresholdLabel)
self.frame.layout().addWidget(self.outerThreshold)
self.widgets.append(self.outerThreshold)
self.apply = qt.QPushButton("Apply", self.frame)
self.apply.setToolTip("Apply current threshold settings to the label map.")
self.frame.layout().addWidget(self.apply)
self.widgets.append(self.apply)
self.timer = qt.QTimer()
self.previewState = 0
self.previewStep = 1
self.previewSteps = 5
self.timer.start(200)
self.connections.append( (self.timer, 'timeout()', self.preview) )
self.connections.append( (self.threshold, 'valuesChanged(double,double)', self.onThresholdValuesChanged) )
self.connections.append( (self.outerThreshold, 'valuesChanged(double,double)', self.onThresholdValuesChanged) )
self.connections.append( (self.apply, 'clicked()', self.onApply) )
EditorLib.HelpButton(self.frame, "TODO: describe double threshold")
# Add vertical spacer
self.frame.layout().addStretch(1)
def assurePeaksParented(self):
# Check every 1/2 second if the transforms exist, if they do, parent them and stop checking
if not self.findPeakTransforms():
slicer.app.processEvents()
qt.QTimer().singleShot(500, self.assurePeaksParented) # 500ms
return
self.parentPeakTransforms(self.needleTipToNeedleTransform,
self.firstPeakToSETTipTransformNode,
self.secondPeakToSETTipTransformNode,
self.thirdPeakToSETTipTransformNode)
def create(self):
super(ThresholdEffectOptions, self).create()
self.thresholdLabel = qt.QLabel("Threshold Range:", self.frame)
self.thresholdLabel.setToolTip(
"Set the range of the background values that should be labeled.")
self.frame.layout().addWidget(self.thresholdLabel)
self.widgets.append(self.thresholdLabel)
self.threshold = ctk.ctkRangeWidget(self.frame)
self.threshold.spinBoxAlignment = 0xff # put enties on top
self.threshold.singleStep = 0.01
# set min/max based on current range
success, lo, hi = self.getBackgroundScalarRange()
if success:
self.threshold.minimum, self.threshold.maximum = lo, hi
self.threshold.singleStep = (hi - lo) / 1000.
self.frame.layout().addWidget(self.threshold)
self.widgets.append(self.threshold)
self.useForPainting = qt.QPushButton("Use For Paint", self.frame)
self.useForPainting.setToolTip(
"Transfer the current threshold settings to be used for labeling operations such as Paint and Draw."
)
self.frame.layout().addWidget(self.useForPainting)
self.widgets.append(self.useForPainting)
self.apply = qt.QPushButton("Apply", self.frame)
self.apply.objectName = self.__class__.__name__ + 'Apply'
self.apply.setToolTip(
"Apply current threshold settings to the label map.")
self.frame.layout().addWidget(self.apply)
self.widgets.append(self.apply)
self.timer = qt.QTimer()
self.previewState = 0
self.previewStep = 1
self.previewSteps = 5
self.timer.start(200)
self.connections.append((self.timer, 'timeout()', self.preview))
self.connections.append(
(self.useForPainting, 'clicked()', self.onUseForPainting))
self.connections.append(
(self.threshold, 'valuesChanged(double,double)',
self.onThresholdValuesChanged))
self.connections.append((self.apply, 'clicked()', self.onApply))
EditorLib.HelpButton(
self.frame,
"Set labels based on threshold range. Note: this replaces the current label map values."
)
# Add vertical spacer
self.frame.layout().addStretch(1)
def __init__(self):
qt.QWidget.__init__(self)
VTKObservationMixin.__init__(self)
self._cmdSetParameter = None
self._cmdGetParameter = None
self._interactionInProgress = False
self._deviceID = ""
self._parameterName = ""
self._connectorNode = None
self._periodicParameterTimer = qt.QTimer()
self._periodicParameterTimer.connect(
"timeout()", self.sendGetUltrasoundParameterCommand)
def rock(self):
if not self.rocking:
self.rockTimer = None
self.fadeSlider.value = 0.5
if self.rocking:
if not self.rockTimer:
self.rockTimer = qt.QTimer()
self.rockTimer.start(50)
self.rockTimer.connect('timeout()', self.rock)
import math
self.fadeSlider.value = 0.5 + math.sin(self.rockCount / 10.) / 2.
self.rockCount += 1
def flicker(self):
if not self.flickering:
self.flickerTimer = None
self.fadeSlider.value = 0.5
if self.flickering:
if not self.flickerTimer:
if self.fadeSlider.value == 0.5:
self.fadeSlider.value = 0.25
self.flickerTimer = qt.QTimer()
self.flickerTimer.start(300)
self.flickerTimer.connect('timeout()', self.flicker)
import math
self.fadeSlider.value = 1.0 - self.fadeSlider.value
def __init__(self, parent):
ScriptedLoadableModuleLogic.__init__(self, parent)
self.scene = slicer.mrmlScene
self.widget = None
self.catheters = CatheterCollection()
self.registration = None
# Create a parameter node
self.parameterNode = self.getParameterNode()
# Time to monitor data integrity
self.monitoringTimer = qt.QTimer()
self.addObservers()
def __init__(self, parent=None):
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
else:
self.parent = parent
self.layout = self.parent.layout()
# this flag is 1 if there is an update in progress
self.__updating = 1
self.__mvNode = None
self.extractFrame = False
# image play setup
self.timer = qt.QTimer()
self.timer.setInterval(50)
self.timer.connect('timeout()', self.goToNext)
def __init__(self, parent=None):
if not parent:
self.parent = slicer.qMRMLWidget()
self.parent.setLayout(qt.QVBoxLayout())
self.parent.setMRMLScene(slicer.mrmlScene)
else:
self.parent = parent
self.layout = self.parent.layout()
self.cameraNode = None
# Flythough variables
self.transform = None
self.path = None
self.camera = None
self.skip = 0
self.timer = qt.QTimer()
self.timer.setInterval(20)
self.timer.connect('timeout()', self.flyToNext)
if not parent:
self.setup()
self.cameraNodeSelector.setMRMLScene(slicer.mrmlScene)
self.inputFiducialsNodeSelector.setMRMLScene(slicer.mrmlScene)
self.parent.show()
def onCheckSampling(self):
stateA = self.logic.samplingA.GetStatusString()
stateB = self.logic.samplingB.GetStatusString()
if stateA == 'Running' or stateA == 'Scheduled' or stateB == 'Running' or stateB == 'Scheduled':
print('Sampling File A:', stateA)
print('Sampling File B:', stateB)
else:
print('Sampling done!')
self.checkThreadTimer.stop()
self.checkThreadTimer.disconnect('timeout()', self.onCheckSampling)
#Getting parameters
nb_bins = self.spinBox_bins.value
signed = False
if self.comboBox_distanceType.currentText == 'Signed Distance':
signed = True
correspondence = False
if self.comboBox_correspondence.currentText == 'Yes':
correspondence = True
fileA_path = self.logic.fileA_out
fileB_path = self.logic.fileB_out
self.logic.stats.Set('A', fileA_path)
self.logic.stats.Set('B', fileB_path)
#computing
self.pushButton_compute.setText("Computing ...")
self.logic.computeStats(nb_bins, signed, correspondence)
self.checkThreadTimer = qt.QTimer()
self.checkThreadTimer.connect('timeout()', self.onCheckCompute)
self.checkThreadTimer.start(100)
return
def onEntry(self, comingFrom, transitionType):
super(Step2, self).onEntry(comingFrom, transitionType)
self.ctimer = qt.QTimer()
self.ctimer.singleShot(0, self.killButton)
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 setTimer(self):
self.replyBox.setPlainText("Waiting for reply...")
self.timeoutCounter = 0
self.timer = qt.QTimer()
self.timer.timeout.connect(self.getCommandReply)
self.timer.start(100)
def setup(self):
# if this import is at top of the source, the loading could not work well.
#import glob
# Instantiate and connect widgets ...
#
# Reload and Test area
#
reloadCollapsibleButton = ctk.ctkCollapsibleButton()
reloadCollapsibleButton.text = "Reload && Test"
reloadCollapsibleButton.collapsed = True
#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 = "PlaneControl 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
#
self.configurationCollapsibleButton = ctk.ctkCollapsibleButton()
self.configurationCollapsibleButton.text = "Setup"
self.configurationCollapsibleButton.collapsed = False
self.configurationList = self.configurationCollapsibleButton
self.layout.addWidget(self.configurationCollapsibleButton)
# Layout within the collapsible button
self.configurationFormLayout = qt.QFormLayout(
self.configurationCollapsibleButton)
#
# Sensor Transform (vtkMRMLLinearTransformNode)
#
self.sensorTransformSelector = slicer.qMRMLNodeComboBox()
self.sensorTransformSelector.nodeTypes = ((
"vtkMRMLLinearTransformNode"), "")
self.sensorTransformSelector.noneEnabled = True
self.sensorTransformSelector.setMRMLScene(slicer.mrmlScene)
self.configurationFormLayout.addRow("Sensor Matrix: ",
self.sensorTransformSelector)
#
# PLANE_0 Transform (vtkMRMLLinearTransformNode)
#
self.plane_0TransformSelector = slicer.qMRMLNodeComboBox()
self.plane_0TransformSelector.nodeTypes = ((
"vtkMRMLLinearTransformNode"), "")
self.plane_0TransformSelector.noneEnabled = True
self.plane_0TransformSelector.setMRMLScene(slicer.mrmlScene)
self.configurationFormLayout.addRow("PLANE_0 Matrix: ",
self.plane_0TransformSelector)
#
# PLANE_1 Transform (vtkMRMLLinearTransformNode)
#
self.plane_1TransformSelector = slicer.qMRMLNodeComboBox()
self.plane_1TransformSelector.nodeTypes = ((
"vtkMRMLLinearTransformNode"), "")
self.plane_1TransformSelector.noneEnabled = True
self.plane_1TransformSelector.setMRMLScene(slicer.mrmlScene)
self.configurationFormLayout.addRow("PLANE_1 Matrix: ",
self.plane_1TransformSelector)
#
# PLANE_2 Transform (vtkMRMLLinearTransformNode)
#
self.plane_2TransformSelector = slicer.qMRMLNodeComboBox()
self.plane_2TransformSelector.nodeTypes = ((
"vtkMRMLLinearTransformNode"), "")
self.plane_2TransformSelector.noneEnabled = True
self.plane_2TransformSelector.setMRMLScene(slicer.mrmlScene)
self.configurationFormLayout.addRow("PLANE_2 Matrix: ",
self.plane_2TransformSelector)
# Apply button
self.applyMatrixButton = qt.QPushButton("ON")
self.configurationFormLayout.addRow("Matrix Connection: ",
self.applyMatrixButton)
self.applyMatrixButton.connect('clicked()',
self.onApplyMatrixConnectionButton)
# Stop button
self.removeMatrixButton = qt.QPushButton("OFF")
self.configurationFormLayout.addRow("Matrix Connection: ",
self.removeMatrixButton)
self.removeMatrixButton.connect('clicked()',
self.onStopMatrixConnectionButton)
# QTimer
self.t = qt.QTimer()
self.t.connect('timeout()', self.tCount)
self.freq = 30 #50
#
# Dock Panel
#
self.createDockPanel()
# Add vertical spacer
self.layout.addStretch(1)
self.extensionSelector = {}
self.installedExtensionName = {}
self.selectedItem = {}
self.currentModuleId = 0
self.numberOfModule = 0
self.numberOfExtention = 0
self.numberOfExtentionList = 0
self.loadFileFlag = 0
self.numberOfLabelText = 15
self.itemsOnOneLine = 3
#Matrix
self.timerStopFlag = 0
self.sensorMatrix = vtk.vtkMatrix4x4()
self.plane_0Matrix = vtk.vtkMatrix4x4()
self.plane_1Matrix = vtk.vtkMatrix4x4()
self.plane_2Matrix = vtk.vtkMatrix4x4()
def __init__(self, parent, logic, configurationName='Default'):
self.slice3DChartCustomLayoutId = 5000 # Must come before Guidelet.__init__
Guidelet.__init__(self, parent, logic, configurationName)
logging.debug('EpiGuideGuidelet.__init__')
self.logic.addValuesToDefaultConfiguration()
# for debugging purposes only, to be removed
slicer.epi = self
self.navigationCollapsibleButton = None
self.imageData = None
self.imageDimensions = None
self.line = None
self.table = None
self.chart = None
self.view = None
self.signalArray = None
self.distanceArray = None
self.boundsRecalculated = False
self.fitUltrasoundImageToViewOnConnect = True
self.firstPeakToSETTipTransformNode = None
self.secondPeakToSETTipTransformNode = None
self.thirdPeakToSETTipTransformNode = None
self.firstPeakModelNode = None
self.secondPeakModelNode = None
self.thirdPeakModelNode = None
self.needleWithTipModel = None
self.trajectoryModel_needleModel = None
self.trajectoryModel_needleTip = None
self.referenceToRasTransform = None
self.needleTipToNeedleTransform = None
self.needleModelToNeedleTipTransform = None
self.trajModelToNeedleTipTransform = None
self.needleToReferenceTransform = None
self.setTipToReferenceTransformNode = None
self.aModeImageNode = None
self.timer = qt.QTimer()
self.agilentCommandLogic = PlusRemoteLogic()
self.agilentConnectorNode = slicer.mrmlScene.AddNode(
slicer.vtkMRMLIGTLConnectorNode())
self.agilentConnectorNode.SetLogErrorIfServerConnectionFailed(False)
hostNamePort = self.parameterNode.GetParameter(
'AgilentServerHostNamePort') # example: "localhost:18944"
[hostName, port] = hostNamePort.split(':')
self.agilentConnectorNode.SetTypeClient(hostName, int(port))
self.agilentConnectorNode.Start()
self.needleModelTipRadius = 0.0
# Set up main frame
self.sliceletDockWidget.setObjectName('EpiGuidePanel')
self.sliceletDockWidget.setWindowTitle('EpiGuideNav')
self.mainWindow.setWindowTitle('Epidural injection navigation')
self.navigationView = self.VIEW_TRIPLE_3D # should we change to VIEW_ULTRASOUND_3D_3DCHART ???
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 onEntry(self, comingFrom, transitionType):
super(HistoriaClinica, self).onEntry(comingFrom, transitionType)
self.ctimer = qt.QTimer()
self.ctimer.singleShot(0, self.killButton)
slicer.mrmlScene.Clear(0)
self.cargarScene()
def setup(self):
ScriptedLoadableModuleWidget.setup(self)
self.logic = DualModalityCalibrationLogic()
# Instantiate and connect widgets
#
# Calibration Parameters Area
#
parametersCollapsibleButton = ctk.ctkCollapsibleButton()
parametersCollapsibleButton.text = "Calibration input and output transforms"
self.layout.addWidget(parametersCollapsibleButton)
# Layout within the dummy collapsible button
parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
#
# Optical tracking system transform selector
#
self.opticalPointerSelectorLabel = qt.QLabel()
self.opticalPointerSelectorLabel.setText(
"OpPointerToOpRef Transform: ")
self.opticalPointerSelector = slicer.qMRMLNodeComboBox()
self.opticalPointerSelector.nodeTypes = ([
"vtkMRMLLinearTransformNode"
])
self.opticalPointerSelector.noneEnabled = False
self.opticalPointerSelector.addEnabled = False
self.opticalPointerSelector.removeEnabled = True
self.opticalPointerSelector.setMRMLScene(slicer.mrmlScene)
self.opticalPointerSelector.setToolTip(
"Pick a known transform corresponding to the optical pointer's coordinate frame"
)
parametersFormLayout.addRow(self.opticalPointerSelectorLabel,
self.opticalPointerSelector)
#
# Em tracking system transform selector
#
self.EmPointerSelectorLabel = qt.QLabel()
self.EmPointerSelectorLabel.setText("EmPointerToEmTracker Transform: ")
self.emPointerSelector = slicer.qMRMLNodeComboBox()
self.emPointerSelector.nodeTypes = (["vtkMRMLTransformNode"])
self.emPointerSelector.noneEnabled = False
self.emPointerSelector.addEnabled = False
self.emPointerSelector.removeEnabled = True
self.emPointerSelector.setMRMLScene(slicer.mrmlScene)
self.emPointerSelector.setToolTip(
"Pick a known transform corresponding to the Em pointer's coordinate frame"
)
parametersFormLayout.addRow(self.EmPointerSelectorLabel,
self.emPointerSelector)
#
# Initial landmark registration result transform selector
#
self.initialEmTrackerToOpRefSelectorLabel = qt.QLabel()
self.initialEmTrackerToOpRefSelectorLabel.setText(
"Initial EmTrackerToOpRef Transform: ")
self.initialEmTrackerToOpRefSelector = slicer.qMRMLNodeComboBox()
self.initialEmTrackerToOpRefSelector.nodeTypes = ([
"vtkMRMLTransformNode"
])
self.initialEmTrackerToOpRefSelector.noneEnabled = False
self.initialEmTrackerToOpRefSelector.addEnabled = True
self.initialEmTrackerToOpRefSelector.removeEnabled = True
self.initialEmTrackerToOpRefSelector.baseName = "EmTrackerToOpRefInitial"
self.initialEmTrackerToOpRefSelector.setMRMLScene(slicer.mrmlScene)
self.initialEmTrackerToOpRefSelector.setToolTip(
"Pick a known transform corresponding to the Em pointer's coordinate frame"
)
parametersFormLayout.addRow(self.initialEmTrackerToOpRefSelectorLabel,
self.initialEmTrackerToOpRefSelector)
self.outputEmTrackerToOpRefTransformSelectorLabel = qt.QLabel(
"Output EmTrackerToOpRef transform: ")
self.outputEmTrackerToOpRefTransformSelector = slicer.qMRMLNodeComboBox(
)
self.outputEmTrackerToOpRefTransformSelector.nodeTypes = ([
"vtkMRMLTransformNode"
])
self.outputEmTrackerToOpRefTransformSelector.noneEnabled = True
self.outputEmTrackerToOpRefTransformSelector.addEnabled = True
self.outputEmTrackerToOpRefTransformSelector.removeEnabled = True
self.outputEmTrackerToOpRefTransformSelector.baseName = "EmTrackerToOpRef"
self.outputEmTrackerToOpRefTransformSelector.setMRMLScene(
slicer.mrmlScene)
self.outputEmTrackerToOpRefTransformSelector.setToolTip(
"Select the transform to output the EmTrackerToOpRef calibration result to"
)
parametersFormLayout.addRow(
self.outputEmTrackerToOpRefTransformSelectorLabel,
self.outputEmTrackerToOpRefTransformSelector)
self.outputEmPointerGtruthToOpPointerTransformSelectorLabel = qt.QLabel(
"Output EmPointerGtruthToOpPointer transform: ")
self.outputEmPointerGtruthToOpPointerTransformSelector = slicer.qMRMLNodeComboBox(
)
self.outputEmPointerGtruthToOpPointerTransformSelector.nodeTypes = ([
"vtkMRMLTransformNode"
])
self.outputEmPointerGtruthToOpPointerTransformSelector.noneEnabled = True
self.outputEmPointerGtruthToOpPointerTransformSelector.addEnabled = True
self.outputEmPointerGtruthToOpPointerTransformSelector.removeEnabled = True
self.outputEmPointerGtruthToOpPointerTransformSelector.baseName = "EmPointerGtruthToOpPointer"
self.outputEmPointerGtruthToOpPointerTransformSelector.setMRMLScene(
slicer.mrmlScene)
self.outputEmPointerGtruthToOpPointerTransformSelector.setToolTip(
"Select the transform to output the EmPointerGtruthToOpPointer calibration result to"
)
parametersFormLayout.addRow(
self.outputEmPointerGtruthToOpPointerTransformSelectorLabel,
self.outputEmPointerGtruthToOpPointerTransformSelector)
# Select defaults (to make debugging easier)
opPointerToOpRefNode = slicer.util.getNode('OpPointerToOpRef')
if opPointerToOpRefNode:
self.opticalPointerSelector.setCurrentNode(opPointerToOpRefNode)
emPointerToEmTrackerNode = slicer.util.getNode('EmPointerToEmTracker')
if emPointerToEmTrackerNode:
self.emPointerSelector.setCurrentNode(emPointerToEmTrackerNode)
emTrackerToOpRefInitialNode = slicer.util.getNode(
'EmTrackerToOpRefInitial')
if emTrackerToOpRefInitialNode:
self.initialEmTrackerToOpRefSelector.setCurrentNode(
emTrackerToOpRefInitialNode)
emTrackerToOpRefOutputNode = slicer.util.getNode('EmTrackerToOpRef')
if emTrackerToOpRefOutputNode:
self.outputEmTrackerToOpRefTransformSelector.setCurrentNode(
emTrackerToOpRefOutputNode)
emPointerGtruthToOpPointerOutputNode = slicer.util.getNode(
'EmPointerGtruthToOpPointer')
if emPointerGtruthToOpPointerOutputNode:
self.outputEmPointerGtruthToOpPointerTransformSelector.setCurrentNode(
emPointerGtruthToOpPointerOutputNode)
#
# Controls Area
#
controlsCollapsibleButton = ctk.ctkCollapsibleButton()
controlsCollapsibleButton.text = "Controls"
self.layout.addWidget(controlsCollapsibleButton)
# Layout within the dummy collapsible button
controlsFormLayout = qt.QFormLayout(controlsCollapsibleButton)
#
# Number of data points to be collected input
#
self.numberDataPointsInputLabel = qt.QLabel()
self.numberDataPointsInputLabel.setText(
"Number of Collected Data Points:")
self.numberDataPointsInput = qt.QSpinBox()
self.numberDataPointsInput.maximum = 5000
self.numberDataPointsInput.minimum = 10
self.numberDataPointsInputLabel.setToolTip(
"Select how many sample points will be used in calculations")
controlsFormLayout.addRow(self.numberDataPointsInputLabel,
self.numberDataPointsInput)
#self.numberDataPoints = self.numberDataPointsInput.value
#
# Delay spinbox
#
self.delaySelectorLabel = qt.QLabel()
self.delaySelectorLabel.setText("Delay (seconds):")
self.delaySelector = qt.QSpinBox()
self.delaySelector.minimum = 1
self.delaySelector.maximum = 10
self.delaySelector.value = 5
self.delaySelector.setToolTip(
"Time to wait before starting data collection after clicking 'Start data collection' button"
)
controlsFormLayout.addRow(self.delaySelectorLabel, self.delaySelector)
#
# Start data collection button
#
self.startButton = qt.QPushButton("Start data collection")
self.startButton.toolTip = "Start collecting data that will be used in calculations"
self.startButton.enabled = True
self.startButton.connect('clicked(bool)', self.onStartDataCollection)
controlsFormLayout.addRow(self.startButton)
#
# Delay countdown timer
#
self.delayTimer = qt.QTimer()
self.delayTimerLabel = qt.QLabel()
self.delayTimer.setInterval(1000) # 1 second
self.delayTimer.setSingleShot(True)
self.delayTimer.connect('timeout()', self.onDelayTimerTimeout)
controlsFormLayout.addRow(self.delayTimerLabel)
#
# Data collection progress bar
#
self.collectionProgressBar = qt.QProgressBar()
self.collectionProgressBar.setRange(0, 100)
self.collectionProgressBar.setVisible(False)
controlsFormLayout.addRow(self.collectionProgressBar)
#
# Display Area
#
displayCollapsibleButton = ctk.ctkCollapsibleButton()
displayCollapsibleButton.text = "Calibration results"
self.layout.addWidget(displayCollapsibleButton)
# Layout within the dummy collapsible button
displayFormLayout = qt.QFormLayout(displayCollapsibleButton)
#
# Error metrics
#
self.transErrorLabel = qt.QLabel("Position error: N/A")
self.rotErrorLabel = qt.QLabel("Orientation error: N/A")
displayFormLayout.addRow(self.transErrorLabel)
displayFormLayout.addRow(self.rotErrorLabel)
# Add vertical spacer
self.layout.addStretch(1)
def initUI(self):
self.text_n7 = "-7"
self.text_n6 = "-6"
self.text_n5 = "-5"
self.text_n4 = "-4"
self.text_n3 = "-3"
self.text_n2 = "-2"
self.text_n1 = "-1"
self.text_0 = "0"
self.text_1 = "1"
self.text_2 = "2"
self.text_3 = "3"
self.text_4 = "4"
self.text_5 = "5"
self.text_6 = "6"
self.text_7 = "7"
self.setStyleSheet("background-color:black;")
self.setGeometry(
330, 330, 355,
355) #Area of total window = 117150 ... Area of graph = 84000
self.setWindowTitle('Crosshair')
self.text_A = "A"
self.text_B = "B"
self.text_C = "C"
self.text_D = "D"
self.text_E = "E"
self.text_F = "F"
self.text_G = "G"
self.text_H = "H"
self.text_I = "I"
self.text_J = "J"
self.text_K = "K"
self.text_L = "L"
self.text_M = "M"
self.text_N = "N"
self.indexX = ""
self.indexY = ""
self.ndepth = ""
self.state2 = 0
self.blink = 0
self.text_Hole = "o"
self.scale = 1.0
self.mousePointX1 = 0
self.mousePointY1 = 0
self.mousePointX2 = 0
self.mousePointY2 = 0
self.mousePointX3 = 0
self.mousePointY3 = 0
self.mousePointX4 = 0
self.mousePointY4 = 0
self.LeftSideVertical = 0
self.LeftSideHorizontal = 0
self.RightSideVertical = 0
self.RightSideHorizontal = 0
self.BottomVertical = 0
self.BottomHorizontal = 0
self.TopVertical = 0
self.TopHorizontal = 0
self.LetterSpacingVertical = 0
self.LetterSpacingHorizontal = 0
self.NumberSpacingVertical = 0
self.NumberSpacingHorizontal = 0
self.SpacingBottom = 0
self.LetterOriginX = 0
self.LetterOriginY = 0
self.NumberOriginX = 0
self.NumberOriginY = 0
self.leftX = 0
self.leftY = 0
self.topX = 0
self.topY = 0
self.rightX = 0
self.rightY = 0
self.bottomX = 0
self.bottomY = 0
self.RightSideHoleSpacing = 0
self.RightSideHoleSpacingHorizontal = 0
self.RightSideHoleSpacingVertical = 0
self.bottomHoleSpacingVertical = 0
self.bottomHoleSpacingHorizontal = 0
self.HorizontalLine = 0
self.VerticalLine = 0
self.VertX1 = 0
self.VertX2 = 0
self.VertY1 = 0
self.VertY2 = 0
self.VertSlope = 0
self.VertYInt = 0
self.VertFinderLine = 0
self.HorizX1 = 0
self.HorizX2 = 0
self.HorizY1 = 0
self.HorizY2 = 0
self.HorizSlope = 0
self.HorizYInt = 0
self.HorizFinderLine = 0
self.setGeometry(0, 0, 1000, 1000)
self.setWindowTitle('Template')
self.setWindowFlags(self.windowFlags() | qt.Qt.FramelessWindowHint)
self.show()
self.timer = qt.QTimer()
self.timer.timeout.connect(self.doBlinkMethod)
self.timer.start(500) # every 10 seconds
def onEntry(self, comingFrom, transitionType):
super(Step3, self).onEntry(comingFrom, transitionType)
self.ctimer = qt.QTimer()
self.ctimer.singleShot(0, self.killButton)
print('onEntry - step %s' % self.id())
