def setup(self):
    # Instantiate and connect widgets ...

    # Collapsible button
    dummyCollapsibleButton = ctk.ctkCollapsibleButton()
    dummyCollapsibleButton.text = "IO"
    self.layout.addWidget(dummyCollapsibleButton)

    # Layout within the dummy collapsible button
    dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)

    # Input label node
    label = qt.QLabel('Input label: ')
    self.segmentationSelector = slicer.qMRMLNodeComboBox()
    self.segmentationSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
    self.segmentationSelector.setMRMLScene(slicer.mrmlScene)
    self.segmentationSelector.addEnabled = 0
    self.segmentationSelector.noneEnabled = 1
    self.segmentationSelector.removeEnabled = 0
    self.segmentationSelector.showHidden = 0
    self.segmentationSelector.showChildNodeTypes = 0
    self.segmentationSelector.selectNodeUponCreation = 1
    self.segmentationSelector.addAttribute('vtkMRMLScalarVolumeNode','LabelMap',1)
    self.segmentationSelector.connect('currentNodeChanged(vtkMRMLNode*)',self.onInputChanged)
    dummyFormLayout.addRow(label, self.segmentationSelector)

    # Input volume node
    label = qt.QLabel('Input volume: ')
    self.volumeSelector = slicer.qMRMLNodeComboBox()
    self.volumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
    self.volumeSelector.setMRMLScene(slicer.mrmlScene)
    self.volumeSelector.addEnabled = 0
    self.volumeSelector.noneEnabled = 1
    self.volumeSelector.removeEnabled = 0
    self.volumeSelector.showHidden = 0
    self.volumeSelector.showChildNodeTypes = 0
    self.volumeSelector.selectNodeUponCreation = 0
    self.volumeSelector.addAttribute('vtkMRMLScalarVolumeNode','DICOM.instanceUIDs')
    self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)',self.onInputChanged)
    dummyFormLayout.addRow(label, self.volumeSelector)

    # Buttons to save/load report using AIM XML serialization
    label = qt.QLabel('Export folder')
    self.__exportFolderPicker = ctk.ctkDirectoryButton()
    self.__exportFolderPicker.connect('directoryChanged(const QString&)', self.onOutputDirChanged)
    self.exportButton = qt.QPushButton('Export')
    dummyFormLayout.addRow(label, self.__exportFolderPicker)
    dummyFormLayout.addRow(self.exportButton)
    self.exportButton.connect('clicked()', self.onLabelExport)
    self.exportButton.enabled = 1

    # Input hint
    self.__helpLabel = qt.QLabel('Select a label associated with a DICOM volume')
    dummyFormLayout.addRow(self.__helpLabel)

    # Add vertical spacer
    self.layout.addStretch(1)

    self.outputDir = self.__exportFolderPicker.directory
示例#2
0
 def setupsubmissionUI(self):
   self.dataDirButton = ctk.ctkDirectoryButton()
   self.submissionGroupBoxLayout.addWidget(qt.QLabel("Data directory:") )
   self.submissionGroupBoxLayout.addWidget(self.dataDirButton)
   self.SaveButton = qt.QPushButton("Save")
   self.submissionGroupBoxLayout.addWidget(self.SaveButton)
   self.SaveButton.connect('clicked()', self.onSaveButtonClicked)
   self.WebSaveButton = qt.QPushButton("Submit to web")
   self.submissionGroupBoxLayout.addWidget(self.WebSaveButton)
   self.WebSaveButton.connect('clicked()', self.onWebSaveButtonClicked)
  def setup(self):
    self.developerMode = True
    ScriptedLoadableModuleWidget.setup(self)

    parametersCollapsibleButton = ctk.ctkCollapsibleButton()
    parametersCollapsibleButton.text = "Parameters"
    self.layout.addWidget(parametersCollapsibleButton)

    parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)

    self.inputDirButton = ctk.ctkDirectoryButton()
    parametersFormLayout.addRow("Input directory:",self.inputDirButton)

    self.outputDirButton = ctk.ctkDirectoryButton()
    parametersFormLayout.addRow("Output directory:",self.outputDirButton)

    applyButton = qt.QPushButton('Run')
    parametersFormLayout.addRow(applyButton)

    applyButton.connect('clicked()',self.onRunClicked)
示例#4
0
  def setup( self ):

    # settings
    settingsButton = ctk.ctkCollapsibleButton()
    settingsButton.text = "Settings"
    settingsButton.collapsed = False
    self.parent.layout().addWidget( settingsButton )

    settingsLayout = qt.QFormLayout( settingsButton )

    self.__dirButton = ctk.ctkDirectoryButton()
    settingsLayout.addRow( "Output directory:", self.__dirButton )

    self.__viewCheckbox = qt.QCheckBox()
    self.__viewCheckbox.setChecked( True )
    settingsLayout.addRow( "View after export:", self.__viewCheckbox )

    # advanced
    advancedButton = ctk.ctkCollapsibleButton()
    advancedButton.text = "Advanced"
    advancedButton.collapsed = True
    self.parent.layout().addWidget( advancedButton )

    advancedLayout = qt.QFormLayout( advancedButton )

    self.__copyCheckbox = qt.QCheckBox()
    self.__copyCheckbox.setChecked( True )
    advancedLayout.addRow( "Copy models to output directory:", self.__copyCheckbox )

    self.__captionCombobox = qt.QComboBox()
    self.__captionCombobox.addItems( ['None', 'Model name', 'Hierarchy name'] )
    self.__captionCombobox.currentIndex = 1 # Model name by default
    advancedLayout.addRow( "Set captions from:", self.__captionCombobox )

    self.__serverCheckbox = qt.QCheckBox()
    self.__serverCheckbox.setChecked( useWebserver )
    if not useWebserver:
      self.__serverCheckbox.setEnabled( False )
    advancedLayout.addRow( "Run internal web server:", self.__serverCheckbox )

    # Apply button
    self.__exportButton = qt.QPushButton( "Export to WebGL" )
    self.__exportButton.toolTip = "Export to WebGL using XTK."
    self.__exportButton.enabled = True
    self.parent.layout().addWidget( self.__exportButton )

    # Add vertical spacer
    self.parent.layout().addStretch( 1 )

    # connections
    self.__exportButton.connect( 'clicked()', self.onExport )
  def setup(self):
    ScriptedLoadableModuleWidget.setup(self)

    # Instantiate and connect widgets ...


    #
    # Parameters Area
    #
    parametersCollapsibleButton = ctk.ctkCollapsibleButton()
    parametersCollapsibleButton.text = "Patient Information"
    self.layout.addWidget(parametersCollapsibleButton)

    # Layout within the dummy collapsible button
    parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)

    patientNumberMethodFrame = qt.QFrame(self.parent)
    parametersFormLayout.addRow(patientNumberMethodFrame)
    patientNumberMethodFormLayout = qt.QFormLayout(patientNumberMethodFrame)

    dataFrame = qt.QFrame(self.parent)
    dataFrameLayout = qt.QHBoxLayout()
    dataFrame.setLayout(dataFrameLayout)
    dataLabel = qt.QLabel('Data Directory:', dataFrame)
    dataLabel.setToolTip('Data directory containing "Patient##"')
    dataFrameLayout.addWidget(dataLabel)
    self.DataDirectoryButton = ctk.ctkDirectoryButton(self.parent)
    dataFrameLayout.addWidget(self.DataDirectoryButton)
    patientNumberMethodFormLayout.addRow(dataFrame)

    patientNumberIterationsFrame, self.PatientNumberIterationsSpinBox = \
        numericInputFrame(self.parent, "Patient Number:" , "Tooltip", 59, 110,
                          1, 0)
    patientNumberMethodFormLayout.addRow(patientNumberIterationsFrame)

    # 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)

    # Refresh Apply button state
    self.onSelect()
    def setup(self):
        ScriptedLoadableModuleWidget.setup(self)
        print "-------Mesh Statistic Widget Setup-------"
        self.moduleName = 'MeshStatistics'
        scriptedModulesPath = eval('slicer.modules.%s.path' % self.moduleName.lower())
        scriptedModulesPath = os.path.dirname(scriptedModulesPath)

        libPath = os.path.join(scriptedModulesPath)
        sys.path.insert(0, libPath)

        # import the external library that contain the functions comon to all DCBIA modules
        import ShapeQuantifierCore
        reload(ShapeQuantifierCore)

        # -------------------------------------------------------------------------------------
        self.ShapeQuantifierCore = ShapeQuantifierCore.ShapeQuantifierCore(interface = self)
        self.logic = MeshStatisticsLogic(self, ShapeQuantifierCore)
        self.modelList = list()
        self.fieldList = list()
        self.ROIList = list()
        self.ROIDict = dict()  # Key = Name of ROI
                               # Value = Dictionary of Fields (key = Name of Field
                               #                               Value = dictionary of shapes
                               #                                             key = name of shapes
                               #                                             value = Statistics store()



        # ---------------------------------------------------------------- #
        # ---------------- Definition of the UI interface ---------------- #
        # ---------------------------------------------------------------- #

        # ------------ Loading of the .ui file ---------- #

        loader = qt.QUiLoader()
        path = os.path.join(scriptedModulesPath, 'Resources', 'UI', '%s.ui' %self.moduleName)
        qfile = qt.QFile(path)
        qfile.open(qt.QFile.ReadOnly)
        widget = loader.load(qfile, self.parent)
        self.layout = self.parent.layout()
        self.widget = widget
        self.layout.addWidget(widget)

        # ------------------------------------------------------------------------------------
        #                                    SHAPES INPUT
        # ------------------------------------------------------------------------------------
        self.inputComboBox = self.ShapeQuantifierCore.get("inputComboBox")
        self.inputComboBox.setMRMLScene(slicer.mrmlScene)
        self.inputComboBox.connect('checkedNodesChanged()', self.onInputComboBoxCheckedNodesChanged)
        # ------------------------------------------------------------------------------------
        #                                  ROI TABLE
        # ------------------------------------------------------------------------------------
        self.ROIComboBox = self.ShapeQuantifierCore.get("ROIComboBox")
        self.ROICheckBox = self.ShapeQuantifierCore.get("ROICheckBox")
        self.ROICheckBox.connect('stateChanged(int)', self.onROICheckBoxStateChanged)
        # ------------------------------------------------------------------------------------
        #                                  FIELD TABLE
        # ------------------------------------------------------------------------------------
        self.tableField = self.ShapeQuantifierCore.get("tableField")
        self.tableField.setColumnCount(2)
        self.tableField.setMinimumHeight(250)
        self.tableField.setHorizontalHeaderLabels([' ', ' Field Name '])
        self.tableField.setColumnWidth(0, 20)
        self.tableField.setColumnWidth(1, 260)
        self.tableField.setSizePolicy(qt.QSizePolicy().Expanding, qt.QSizePolicy().Expanding)
        # ------------------------------------------------------------------------------------
        #                                    RUN
        # ------------------------------------------------------------------------------------
        self.runButton = self.ShapeQuantifierCore.get("runButton")
        self.runButton.connect('clicked()', self.onRunButton)

        # ------------------------------------------------------------------------------------
        #                          Statistics Table - Export
        # ------------------------------------------------------------------------------------
        self.mainLayout = self.ShapeQuantifierCore.get("mainLayout")
        self.tabROI = qt.QTabWidget()
        self.tabROI.setTabPosition(0)
        self.tabROI.adjustSize()
        # ---------------------------- Directory - Export Button -----------------------------
        self.directoryExport = ctk.ctkDirectoryButton()
        self.exportCheckBox = qt.QCheckBox('Separate Files')
        self.exportCheckBox.setChecked(True)
        self.exportButton = qt.QPushButton(' Export ')
        self.exportButton.enabled = True
        self.exportPointValueCheckBox = qt.QCheckBox('Export Value on Each Point')
        
        self.exportLayout = qt.QVBoxLayout()
        self.directoryAndExportLayout = qt.QHBoxLayout()
        self.directoryAndExportLayout.addWidget(self.directoryExport)
        self.directoryAndExportLayout.addWidget(self.exportCheckBox)
        self.directoryAndExportLayout.addWidget(self.exportPointValueCheckBox)
        self.exportButtonsLayout = qt.QHBoxLayout()
        self.exportButtonsLayout.addWidget(self.exportButton)
        

        self.exportLayout.addLayout(self.directoryAndExportLayout)
        self.exportLayout.addLayout(self.exportButtonsLayout)
        
        self.layout.addStretch(1)
        self.logic.updateInterface(self.tableField, self.ROIComboBox, self.ROIList, self.modelList, self.mainLayout)

        # ------------------------------------------------------------------------------------
        #                                   OBSERVERS
        # ------------------------------------------------------------------------------------

        slicer.mrmlScene.AddObserver(slicer.mrmlScene.EndCloseEvent, self.onCloseScene)
示例#7
0
    def setup(self):
        ScriptedLoadableModuleWidget.setup(self)
        print "-------Mesh Statistic Widget Setup-------"
        self.moduleName = 'MeshStatistics'
        scriptedModulesPath = eval('slicer.modules.%s.path' %
                                   self.moduleName.lower())
        scriptedModulesPath = os.path.dirname(scriptedModulesPath)

        libPath = os.path.join(scriptedModulesPath)
        sys.path.insert(0, libPath)

        # import the external library that contain the functions comon to all DCBIA modules
        import ShapeQuantifierCore
        reload(ShapeQuantifierCore)

        # -------------------------------------------------------------------------------------
        self.ShapeQuantifierCore = ShapeQuantifierCore.ShapeQuantifierCore(
            interface=self)
        self.logic = MeshStatisticsLogic(self, ShapeQuantifierCore)
        self.modelList = list()
        self.fieldList = list()
        self.ROIList = list()
        self.ROIDict = dict()  # Key = Name of ROI
        # Value = Dictionary of Fields (key = Name of Field
        #                               Value = dictionary of shapes
        #                                             key = name of shapes
        #                                             value = Statistics store()

        # ---------------------------------------------------------------- #
        # ---------------- Definition of the UI interface ---------------- #
        # ---------------------------------------------------------------- #

        # ------------ Loading of the .ui file ---------- #

        loader = qt.QUiLoader()
        path = os.path.join(scriptedModulesPath, 'Resources', 'UI',
                            '%s.ui' % self.moduleName)
        qfile = qt.QFile(path)
        qfile.open(qt.QFile.ReadOnly)
        widget = loader.load(qfile, self.parent)
        self.layout = self.parent.layout()
        self.widget = widget
        self.layout.addWidget(widget)

        # ------------------------------------------------------------------------------------
        #                                    SHAPES INPUT
        # ------------------------------------------------------------------------------------
        self.inputComboBox = self.ShapeQuantifierCore.get("inputComboBox")
        self.inputComboBox.setMRMLScene(slicer.mrmlScene)
        self.inputComboBox.connect('checkedNodesChanged()',
                                   self.onInputComboBoxCheckedNodesChanged)
        # ------------------------------------------------------------------------------------
        #                                  ROI TABLE
        # ------------------------------------------------------------------------------------
        self.ROIComboBox = self.ShapeQuantifierCore.get("ROIComboBox")
        self.ROICheckBox = self.ShapeQuantifierCore.get("ROICheckBox")
        self.ROICheckBox.connect('stateChanged(int)',
                                 self.onROICheckBoxStateChanged)
        # ------------------------------------------------------------------------------------
        #                                  FIELD TABLE
        # ------------------------------------------------------------------------------------
        self.tableField = self.ShapeQuantifierCore.get("tableField")
        self.tableField.setColumnCount(2)
        self.tableField.setMinimumHeight(250)
        self.tableField.setHorizontalHeaderLabels([' ', ' Field Name '])
        self.tableField.setColumnWidth(0, 20)
        self.tableField.setColumnWidth(1, 260)
        self.tableField.setSizePolicy(qt.QSizePolicy().Expanding,
                                      qt.QSizePolicy().Expanding)
        # ------------------------------------------------------------------------------------
        #                                    RUN
        # ------------------------------------------------------------------------------------
        self.runButton = self.ShapeQuantifierCore.get("runButton")
        self.runButton.connect('clicked()', self.onRunButton)

        # ------------------------------------------------------------------------------------
        #                          Statistics Table - Export
        # ------------------------------------------------------------------------------------
        self.mainLayout = self.ShapeQuantifierCore.get("mainLayout")
        self.tabROI = qt.QTabWidget()
        self.tabROI.setTabPosition(0)
        self.tabROI.adjustSize()
        # ---------------------------- Directory - Export Button -----------------------------
        self.directoryExport = ctk.ctkDirectoryButton()
        self.exportCheckBox = qt.QCheckBox('Separate Files')
        self.exportCheckBox.setChecked(True)
        self.exportButton = qt.QPushButton(' Export ')
        self.exportButton.enabled = True
        self.exportPointValueCheckBox = qt.QCheckBox(
            'Export Value on Each Point')

        self.exportLayout = qt.QVBoxLayout()
        self.directoryAndExportLayout = qt.QHBoxLayout()
        self.directoryAndExportLayout.addWidget(self.directoryExport)
        self.directoryAndExportLayout.addWidget(self.exportCheckBox)
        self.directoryAndExportLayout.addWidget(self.exportPointValueCheckBox)
        self.exportButtonsLayout = qt.QHBoxLayout()
        self.exportButtonsLayout.addWidget(self.exportButton)

        self.exportLayout.addLayout(self.directoryAndExportLayout)
        self.exportLayout.addLayout(self.exportButtonsLayout)

        self.layout.addStretch(1)
        self.logic.updateInterface(self.tableField, self.ROIComboBox,
                                   self.ROIList, self.modelList,
                                   self.mainLayout)

        # ------------------------------------------------------------------------------------
        #                                   OBSERVERS
        # ------------------------------------------------------------------------------------

        slicer.mrmlScene.AddObserver(slicer.mrmlScene.EndCloseEvent,
                                     self.onCloseScene)
  def setup(self):
    ScriptedLoadableModuleWidget.setup(self)
    # Instantiate and connect widgets ...

    if not NUMPY_AVAILABLE:
      label = qt.QLabel('The module is not available due to missing Numpy package.')
      self.layout.addWidget(label)
      label = qt.QLabel('You can seek help by contacting 3D Slicer user list: [email protected]')
      self.layout.addWidget(label)

      # Add vertical spacer
      self.layout.addStretch(1)
      return

    # Collapsible button
    dummyCollapsibleButton = ctk.ctkCollapsibleButton()
    dummyCollapsibleButton.text = "Basic settings"
    self.layout.addWidget(dummyCollapsibleButton)
    dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)

    # add input directory selector
    label = qt.QLabel('Input directory:')
    self.__fDialog = ctk.ctkDirectoryButton()
    self.__fDialog.caption = 'Input directory'
    dummyFormLayout.addRow(label, self.__fDialog)

    label = qt.QLabel('Output node:')
    self.__mvSelector = slicer.qMRMLNodeComboBox()
    self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
    self.__mvSelector.setMRMLScene(slicer.mrmlScene)
    self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onMRMLSceneChanged)
    self.__mvSelector.addEnabled = 1
    dummyFormLayout.addRow(label, self.__mvSelector)

    # Collapsible button
    dummyCollapsibleButton = ctk.ctkCollapsibleButton()
    dummyCollapsibleButton.text = "Advanced settings"
    dummyCollapsibleButton.collapsed = 1
    self.layout.addWidget(dummyCollapsibleButton)
    dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)
    self.__advancedFrame = dummyCollapsibleButton

    label = qt.QLabel('Frame identifying DICOM tag (if known):')
    self.__dicomTag = qt.QLineEdit()
    self.__dicomTag.text = 'NA'
    dummyFormLayout.addRow(label, self.__dicomTag)

    label = qt.QLabel('Frame identifying units:')
    self.__veLabel = qt.QLineEdit()
    self.__veLabel.text = 'na'
    dummyFormLayout.addRow(label, self.__veLabel)

    label = qt.QLabel('Initial value:')
    self.__veInitial = qt.QDoubleSpinBox()
    self.__veInitial.value = 0
    dummyFormLayout.addRow(label, self.__veInitial)

    label = qt.QLabel('Step:')
    self.__veStep = qt.QDoubleSpinBox()
    self.__veStep.value = 1
    dummyFormLayout.addRow(label, self.__veStep)

    label = qt.QLabel('EchoTime:')
    self.__te = qt.QDoubleSpinBox()
    self.__te.value = 1
    dummyFormLayout.addRow(label, self.__te)

    label = qt.QLabel('RepetitionTime:')
    self.__tr = qt.QDoubleSpinBox()
    self.__tr.value = 1
    dummyFormLayout.addRow(label, self.__tr)

    label = qt.QLabel('FlipAngle:')
    self.__fa = qt.QDoubleSpinBox()
    self.__fa.value = 1
    dummyFormLayout.addRow(label, self.__fa)

    importButton = qt.QPushButton("Import")
    importButton.toolTip = "Import the contents of the directory as a MultiVolume"
    self.layout.addWidget(importButton)
    importButton.connect('clicked(bool)', self.onImportButtonClicked)

    self.__status = qt.QLabel('Status: Idle')
    self.layout.addWidget(self.__status)

    # Add vertical spacer
    self.layout.addStretch(1)
    def setup(self):
        ScriptedLoadableModuleWidget.setup(self)
        print("-------Mesh Statistic Widget Setup-------")
        # -------------------------------------------------------------------------------------
        self.modelList = list()
        self.fieldList = list()
        self.ROIList = list()
        self.ROIDict = dict()  # Key = Name of ROI
                               # Value = Dictionary of Fields (key = Name of Field
                               #                               Value = dictionary of shapes
                               #                                             key = name of shapes
                               #                                             value = Statistics store()

        self.logic = MeshStatisticsLogic(self)

        # ---------------------------------------------------------------- #
        # ---------------- Definition of the UI interface ---------------- #
        # ---------------------------------------------------------------- #

        # ------------ Loading of the .ui file ---------- #

        modulePath = os.path.dirname(slicer.util.modulePath(self.moduleName))
        path = os.path.join(modulePath, 'Resources', 'UI', '%s.ui' % self.moduleName)

        self.layout = self.parent.layout()
        self.widget = slicer.util.loadUI(path)
        self.layout.addWidget(self.widget)

        # ------------------------------------------------------------------------------------
        #                                    SHAPES INPUT
        # ------------------------------------------------------------------------------------
        self.inputComboBox = self.logic.get("inputComboBox")
        self.inputComboBox.setMRMLScene(slicer.mrmlScene)
        self.inputComboBox.connect('checkedNodesChanged()', self.onInputComboBoxCheckedNodesChanged)
        # ------------------------------------------------------------------------------------
        #                                  ROI TABLE
        # ------------------------------------------------------------------------------------
        self.ROIComboBox = self.logic.get("ROIComboBox")
        self.ROICheckBox = self.logic.get("ROICheckBox")
        self.ROICheckBox.connect('stateChanged(int)', self.onROICheckBoxStateChanged)
        # ------------------------------------------------------------------------------------
        #                                  FIELD TABLE
        # ------------------------------------------------------------------------------------
        self.tableField = self.logic.get("tableField")
        self.tableField.setColumnCount(2)
        self.tableField.setMinimumHeight(250)
        self.tableField.setHorizontalHeaderLabels([' ', ' Field Name '])
        self.tableField.setColumnWidth(0, 20)
        self.tableField.setColumnWidth(1, 260)
        self.tableField.setSizePolicy(qt.QSizePolicy().Expanding, qt.QSizePolicy().Expanding)
        # ------------------------------------------------------------------------------------
        #                                    RUN
        # ------------------------------------------------------------------------------------
        self.runButton = self.logic.get("runButton")
        self.runButton.connect('clicked()', self.onRunButton)

        # ------------------------------------------------------------------------------------
        #                          Statistics Table - Export
        # ------------------------------------------------------------------------------------
        self.mainLayout = self.logic.get("mainLayout")
        self.tabROI = qt.QTabWidget()
        self.tabROI.setTabPosition(0)
        self.tabROI.adjustSize()
        # ---------------------------- Directory - Export Button -----------------------------
        self.directoryExport = ctk.ctkDirectoryButton()
        self.exportCheckBox = qt.QCheckBox('Separate Files')
        self.exportCheckBox.setChecked(True)
        self.exportButton = qt.QPushButton(' Export ')
        self.exportButton.enabled = True
        self.exportPointValueCheckBox = qt.QCheckBox('Export Value on Each Point')
        
        self.exportLayout = qt.QVBoxLayout()
        self.directoryAndExportLayout = qt.QHBoxLayout()
        self.directoryAndExportLayout.addWidget(self.directoryExport)
        self.directoryAndExportLayout.addWidget(self.exportCheckBox)
        self.directoryAndExportLayout.addWidget(self.exportPointValueCheckBox)
        self.exportButtonsLayout = qt.QHBoxLayout()
        self.exportButtonsLayout.addWidget(self.exportButton)
        

        self.exportLayout.addLayout(self.directoryAndExportLayout)
        self.exportLayout.addLayout(self.exportButtonsLayout)
        
        self.layout.addStretch(1)
        self.logic.updateInterface(self.tableField, self.ROIComboBox, self.ROIList, self.modelList, self.mainLayout)

        # ------------------------------------------------------------------------------------
        #                                   OBSERVERS
        # ------------------------------------------------------------------------------------

        slicer.mrmlScene.AddObserver(slicer.mrmlScene.EndCloseEvent, self.onCloseScene)
示例#10
0
    def setup(self):
        """Init the widget """
        self.modulePath = SlicerUtil.getModuleFolder("CIP_GetImage")

        self.resourcesPath = os.path.join(self.modulePath,
                                          "CIP_GetImage_Resources")
        self.StudyId = ""

        self.logic = CIP_GetImageLogic(self.modulePath)

        # Widget to load cases faster
        self.loadSaveDatabuttonsWidget = CIPUI.LoadSaveDataWidget(
            parentWidget=self.parent)
        self.loadSaveDatabuttonsWidget.setup(moduleName="CIP_GetImage")

        #
        # Obligatory parameters area
        #
        parametersCollapsibleButton = ctk.ctkCollapsibleButton()
        parametersCollapsibleButton.text = "Image data"
        self.layout.addWidget(parametersCollapsibleButton)
        parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)

        # Study radio buttons
        label = qt.QLabel()
        label.text = "Select the study:"
        parametersFormLayout.addRow(label)

        self.rbgStudy = qt.QButtonGroup()

        for key in self.studyIds:
            rbStudyid = qt.QRadioButton(key)
            self.rbgStudy.addButton(rbStudyid)
            parametersFormLayout.addWidget(rbStudyid)

        self.txtOtherStudy = qt.QLineEdit()
        self.txtOtherStudy.hide()
        parametersFormLayout.addWidget(self.txtOtherStudy)

        # Case id
        self.txtCaseId = qt.QLineEdit()
        parametersFormLayout.addRow("Case ID     ", self.txtCaseId)

        # Image types
        label = qt.QLabel()
        label.text = "Select the images that you want to load:"
        parametersFormLayout.addRow(label)

        self.cbsImageTypes = []
        for key in self.imageTypes:
            check = qt.QCheckBox()
            check.checked = True
            check.setText(key)
            parametersFormLayout.addWidget(check)
            self.cbsImageTypes.append(check)

        # Label maps
        label = qt.QLabel()
        label.text = "Select the label maps that you want to load:"
        parametersFormLayout.addRow(label)

        # Labelmap types checkboxes
        self.cbsLabelMapTypes = []
        for key in self.labelMapTypes:
            check = qt.QCheckBox()
            check.setText(key)
            check.checked = self.labelMapTypes[key][0]
            parametersFormLayout.addWidget(check)
            self.cbsLabelMapTypes.append(check)

        # Load image Button
        self.downloadButton = qt.QPushButton("Download")
        self.downloadButton.toolTip = "Load the image"
        #self.downloadButton.enabled = False
        self.downloadButton.setStyleSheet(
            "background-color: green; font-weight:bold; color:white")
        parametersFormLayout.addRow(self.downloadButton)
        self.downloadButton.connect('clicked (bool)', self.onDownloadButton)

        # Information message
        self.lblDownloading = qt.QLabel()
        self.lblDownloading.text = "Downloading images. Please wait..."
        self.lblDownloading.hide()
        parametersFormLayout.addRow(self.lblDownloading)

        #
        # Optional Parameters
        #
        optionalParametersCollapsibleButton = ctk.ctkCollapsibleButton()
        optionalParametersCollapsibleButton.text = "Optional parameters"
        self.layout.addWidget(optionalParametersCollapsibleButton)
        optionalParametersFormLayout = qt.QFormLayout(
            optionalParametersCollapsibleButton)

        # Local storage (Slicer temporary path)
        self.localStoragePath = "{0}/CIP".format(slicer.app.temporaryPath)
        if not os.path.exists(self.localStoragePath):
            os.makedirs(self.localStoragePath)
            # Make sure that everybody has write permissions (sometimes there are problems because of umask)
            os.chmod(self.localStoragePath, 0o777)

        self.storagePathButton = ctk.ctkDirectoryButton()
        self.storagePathButton.directory = self.localStoragePath

        optionalParametersFormLayout.addRow("Local directory: ",
                                            self.storagePathButton)

        # Connection type (SSH, "normal")
        label = qt.QLabel()
        label.text = "Connection type:"
        optionalParametersFormLayout.addRow(label)

        self.rbgConnectionType = qt.QButtonGroup()
        self.rbSSH = qt.QRadioButton("SSH (secure connection)")
        self.rbSSH.setChecked(True)
        self.rbgConnectionType.addButton(self.rbSSH)
        optionalParametersFormLayout.addWidget(self.rbSSH)

        self.rbCP = qt.QRadioButton("Common")
        self.rbgConnectionType.addButton(self.rbCP)
        optionalParametersFormLayout.addWidget(self.rbCP)

        # SSH Server login
        self.txtServer = qt.QLineEdit()
        s = SlicerUtil.settingGetOrSetDefault(
            "CIP_GetImage", "server",
            "This is your ssh user and server. Example: [email protected]")
        self.txtServer.text = s  # This is your ssh user and server. Example: [email protected]"
        optionalParametersFormLayout.addRow("Server:", self.txtServer)

        # Server root path
        self.txtServerpath = qt.QLineEdit()
        s = SlicerUtil.settingGetOrSetDefault(
            "CIP_GetImage", "serverRootPath",
            "This is your root path to search for files. Ex: /Cases/Processed")
        self.txtServerpath.text = s  # This is your root path to search for files. Ex: /Cases/Processed
        optionalParametersFormLayout.addRow("Server root path:",
                                            self.txtServerpath)

        # SSH Private key
        self.txtPrivateKeySSH = qt.QLineEdit()
        s = SlicerUtil.settingGetOrSetDefault("CIP_GetImage", "sshKey", "")
        self.txtPrivateKeySSH.text = s  # this is the full path to your ssh key if you need it. Be aware of Unix/Windows comaptibility (hint: use os.path.join)
        # Please notice that you won't need a SSH key if your computer already has one locally installed"
        optionalParametersFormLayout.addRow(
            "SSH private key (leave blank for computer's default):     ",
            self.txtPrivateKeySSH)

        # Cache mode
        self.cbCacheMode = qt.QCheckBox("Cache mode activated")
        self.cbCacheMode.setChecked(True)  # Cache mode is activated by default
        optionalParametersFormLayout.addRow("", self.cbCacheMode)

        # Clean cache Button
        self.cleanCacheButton = qt.QPushButton("Clean cache")
        self.cleanCacheButton.toolTip = "Remove all the local cached files"
        optionalParametersFormLayout.addRow(self.cleanCacheButton)
        optionalParametersCollapsibleButton.collapsed = True

        if SlicerUtil.IsDevelopment:
            # reload button
            self.reloadButton = qt.QPushButton("Reload (just development)")
            self.reloadButton.toolTip = "Reload this module (for development purposes)."
            self.reloadButton.name = "Reload"
            self.layout.addWidget(self.reloadButton)
            self.reloadButton.connect('clicked()', self.onReload)

        # Add vertical spacer
        self.layout.addStretch(1)

        # Connections
        self.rbgStudy.connect("buttonClicked (QAbstractButton*)",
                              self.onRbStudyClicked)
        self.txtOtherStudy.connect("textEdited (QString)",
                                   self.onTxtOtherStudyEdited)
        self.rbgConnectionType.connect("buttonClicked (QAbstractButton*)",
                                       self.onRbgConnectionType)

        self.storagePathButton.connect("directorySelected(QString)",
                                       self.onTmpDirChanged)
        self.cleanCacheButton.connect('clicked (bool)',
                                      self.onCleanCacheButtonClicked)
示例#11
0
  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):
        print "-------Mesh Statistic Widget Setup-------"
        ScriptedLoadableModuleWidget.setup(self)
        # -------------------------------------------------------------------------------------
        self.modelList = list()
        self.fieldList = list()
        self.ROIList = list()
        self.ROIDict = dict()  # Key = Name of ROI
        # Value = Dictionary of Fields (key = Name of Field
        #                               Value = dictionary of shapes
        #                                             key = name of shapes
        #                                             value = Statistics store()

        self.logic = MeshStatisticsLogic(self)

        # ---------------------------------------------------------------- #
        # ---------------- Definition of the UI interface ---------------- #
        # ---------------------------------------------------------------- #

        # ------------ Loading of the .ui file ---------- #

        loader = qt.QUiLoader()
        moduleName = "MeshStatistics"
        scriptedModulesPath = eval("slicer.modules.%s.path" % moduleName.lower())
        scriptedModulesPath = os.path.dirname(scriptedModulesPath)
        path = os.path.join(scriptedModulesPath, "Resources", "UI", "%s.ui" % moduleName)

        qfile = qt.QFile(path)
        qfile.open(qt.QFile.ReadOnly)
        widget = loader.load(qfile, self.parent)
        self.layout = self.parent.layout()
        self.widget = widget
        self.layout.addWidget(widget)

        # ------------------------------------------------------------------------------------
        #                                    SHAPES INPUT
        # ------------------------------------------------------------------------------------
        self.inputComboBox = self.logic.get("inputComboBox")
        self.inputComboBox.setMRMLScene(slicer.mrmlScene)
        self.inputComboBox.connect("checkedNodesChanged()", self.onInputComboBoxCheckedNodesChanged)
        # ------------------------------------------------------------------------------------
        #                                  ROI TABLE
        # ------------------------------------------------------------------------------------
        self.ROIComboBox = self.logic.get("ROIComboBox")
        self.ROICheckBox = self.logic.get("ROICheckBox")
        self.ROICheckBox.connect("stateChanged(int)", self.onROICheckBoxStateChanged)
        # ------------------------------------------------------------------------------------
        #                                  FIELD TABLE
        # ------------------------------------------------------------------------------------
        self.tableField = self.logic.get("tableField")
        self.tableField.setColumnCount(2)
        self.tableField.setMinimumHeight(250)
        self.tableField.setHorizontalHeaderLabels([" ", " Field Name "])
        self.tableField.setColumnWidth(0, 20)
        self.tableField.setColumnWidth(1, 260)
        self.tableField.setSizePolicy(qt.QSizePolicy().Expanding, qt.QSizePolicy().Expanding)
        # ------------------------------------------------------------------------------------
        #                                    RUN
        # ------------------------------------------------------------------------------------
        self.runButton = self.logic.get("runButton")
        self.runButton.connect("clicked()", self.onRunButton)

        # ------------------------------------------------------------------------------------
        #                          Statistics Table - Export
        # ------------------------------------------------------------------------------------
        self.mainLayout = self.logic.get("mainLayout")
        self.tabROI = qt.QTabWidget()
        self.tabROI.setTabPosition(0)
        self.tabROI.adjustSize()
        # ---------------------------- Directory - Export Button -----------------------------
        self.directoryExport = ctk.ctkDirectoryButton()
        self.exportCheckBox = qt.QCheckBox("Separate Files")
        self.exportCheckBox.setChecked(True)
        self.exportButton = qt.QPushButton(" Export ")
        self.exportButton.enabled = True
        self.exportPointValueCheckBox = qt.QCheckBox("Export Value on Each Point")

        self.exportLayout = qt.QVBoxLayout()
        self.directoryAndExportLayout = qt.QHBoxLayout()
        self.directoryAndExportLayout.addWidget(self.directoryExport)
        self.directoryAndExportLayout.addWidget(self.exportCheckBox)
        self.directoryAndExportLayout.addWidget(self.exportPointValueCheckBox)
        self.exportButtonsLayout = qt.QHBoxLayout()
        self.exportButtonsLayout.addWidget(self.exportButton)

        self.exportLayout.addLayout(self.directoryAndExportLayout)
        self.exportLayout.addLayout(self.exportButtonsLayout)

        self.layout.addStretch(1)
        self.logic.updateInterface(self.tableField, self.ROIComboBox, self.ROIList, self.modelList, self.mainLayout)

        # ------------------------------------------------------------------------------------
        #                                   OBSERVERS
        # ------------------------------------------------------------------------------------
        def onCloseScene(obj, event):
            # initialize Parameters
            globals()["MeshStatistics"] = slicer.util.reloadScriptedModule("MeshStatistics")

        slicer.mrmlScene.AddObserver(slicer.mrmlScene.EndCloseEvent, onCloseScene)
  def setup( self ):
    #
    # Input frame
    #
    self.__inputFrame = ctk.ctkCollapsibleButton()
    self.__inputFrame.text = "Input"
    self.__inputFrame.collapsed = 0
    inputFrameLayout = qt.QFormLayout(self.__inputFrame)
    
    self.layout.addWidget(self.__inputFrame)

    # Active report node
    label = qt.QLabel('Report: ')
    self.reportSelector = slicer.qMRMLNodeComboBox()
    self.reportSelector.nodeTypes =  ['vtkMRMLReportingReportNode']
    self.reportSelector.setMRMLScene(slicer.mrmlScene)
    self.reportSelector.addEnabled = True
    self.reportSelector.removeEnabled = True
    
    inputFrameLayout.addRow(label, self.reportSelector)

    self.reportSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onReportNodeChanged)
 
    # Volume being annotated (only one is allowed for the report)
    label = qt.QLabel('NOTE: Only volumes loaded from DICOM can be annotated!')
    inputFrameLayout.addRow(label)
    label = qt.QLabel('Annotated volume: ')
    self.volumeSelector = slicer.qMRMLNodeComboBox()
    self.volumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
    # only allow volumes with the attribute DICOM.instanceUIDs
    self.volumeSelector.addAttribute('vtkMRMLScalarVolumeNode','DICOM.instanceUIDs')
    self.volumeSelector.setMRMLScene(slicer.mrmlScene)
    self.volumeSelector.addEnabled = False
    
    inputFrameLayout.addRow(label, self.volumeSelector)

    self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onAnnotatedVolumeNodeChanged)

    #
    # Annotation frame -- vocabulary-based description of what is
    # being annotated/marked up in this report
    #
    self.__annotationsFrame = ctk.ctkCollapsibleButton()
    self.__annotationsFrame.text = "Annotation"
    self.__annotationsFrame.collapsed = 0
    annotationsFrameLayout = qt.QFormLayout(self.__annotationsFrame)
    
    self.layout.addWidget(self.__annotationsFrame)

    self.__defaultColorNode = self.__logic.GetDefaultColorNode()

    self.__toolsColor = EditColor(self.__annotationsFrame,colorNode=self.__defaultColorNode)

    #
    # Markup frame -- summary of all the markup elements contained in the
    # report
    #
    self.__markupFrame = ctk.ctkCollapsibleButton()
    self.__markupFrame.text = "Markup"
    self.__markupFrame.collapsed = 0
    markupFrameLayout = qt.QFormLayout(self.__markupFrame)
    
    self.layout.addWidget(self.__markupFrame)

    self.__markupSliceText = qt.QLabel()
    markupFrameLayout.addRow(self.__markupSliceText)

    self.__markupTreeView = ReportingMarkupWidget(self.layout)
    markupFrameLayout.addRow(self.__markupTreeView.widget)
        
    
    

    # Editor frame
    self.__editorFrame = ctk.ctkCollapsibleButton()
    self.__editorFrame.text = 'Segmentation'
    self.__editorFrame.collapsed = 0
    editorFrameLayout = qt.QFormLayout(self.__editorFrame)

    label = qt.QLabel('Segmentation volume: ')
    self.segmentationSelector = slicer.qMRMLNodeComboBox()
    self.segmentationSelector.nodeTypes = ['vtkMRMLLabelMapVolumeNode']
    self.segmentationSelector.setMRMLScene(slicer.mrmlScene)
    self.segmentationSelector.addEnabled = 1
    self.segmentationSelector.noneEnabled = 1
    self.segmentationSelector.removeEnabled = 0
    self.segmentationSelector.showHidden = 0
    self.segmentationSelector.showChildNodeTypes = 0
    self.segmentationSelector.selectNodeUponCreation = 1

    editorFrameLayout.addRow(label, self.segmentationSelector)

    editorWidgetParent = slicer.qMRMLWidget()
    editorWidgetParent.setLayout(qt.QVBoxLayout())
    editorWidgetParent.setMRMLScene(slicer.mrmlScene)
    self.__editorWidget = EditorWidget(parent=editorWidgetParent,showVolumesFrame=False)
    self.__editorWidget.setup()
    self.__editorWidget.toolsColor.frame.setVisible(False)
    editorFrameLayout.addRow(editorWidgetParent)

    markupFrameLayout.addRow(self.__editorFrame)

    self.segmentationSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onSegmentationNodeChanged)

    # IO frame
    self.__ioFrame = ctk.ctkCollapsibleButton()
    self.__ioFrame.text = 'Import/Export'
    self.__ioFrame.collapsed = 1
    ioFrameLayout = qt.QGridLayout(self.__ioFrame)

    self.layout.addWidget(self.__ioFrame)

    # Buttons to save/load report using AIM XML serialization
    label = qt.QLabel('Export folder')
    self.__exportFolderPicker = ctk.ctkDirectoryButton()
    exportButton = qt.QPushButton('Export')
    exportButton.connect('clicked()', self.onReportExport)
    ioFrameLayout.addWidget(label,0,0)
    ioFrameLayout.addWidget(self.__exportFolderPicker,0,1)
    ioFrameLayout.addWidget(exportButton,0,2)

    label = qt.QLabel('AIM file to import')
    self.__aimFilePicker = qt.QPushButton('N/A')
    self.__aimFilePicker.connect('clicked()',self.onSelectAIMFile)
    button = qt.QPushButton('Import')
    button.connect('clicked()', self.onReportImport)
    ioFrameLayout.addWidget(label,1,0)
    ioFrameLayout.addWidget(self.__aimFilePicker,1,1)
    ioFrameLayout.addWidget(button,1,2)
    self.importAIMFile = None

    self.reportSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.updateWidgets)
    self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.updateWidgets)
    self.updateWidgets()

    self.layout.addStretch(1)

    self.__editorParameterNode = self.editUtil.getParameterNode()

    self.__editorParameterNode.AddObserver(vtk.vtkCommand.ModifiedEvent, self.onEditorParameterNodeChanged)
  def setup( self ):
    #
    # Input frame
    #
    self.__inputFrame = ctk.ctkCollapsibleButton()
    self.__inputFrame.text = "Input"
    self.__inputFrame.collapsed = 0
    inputFrameLayout = qt.QFormLayout(self.__inputFrame)
    
    self.layout.addWidget(self.__inputFrame)

    # Active report node
    label = qt.QLabel('Report: ')
    self.__reportSelector = slicer.qMRMLNodeComboBox()
    self.__reportSelector.nodeTypes =  ['vtkMRMLReportingReportNode']
    self.__reportSelector.setMRMLScene(slicer.mrmlScene)
    self.__reportSelector.addEnabled = 1
    self.__reportSelector.removeEnabled = 0
    
    inputFrameLayout.addRow(label, self.__reportSelector)

    self.__reportSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onMRMLSceneChanged)
    self.__reportSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onReportNodeChanged)
 
    # Volume being annotated (only one is allowed for the report)
    label = qt.QLabel('NOTE: Only volumes loaded from DICOM can be annotated!')
    inputFrameLayout.addRow(label)
    label = qt.QLabel('Annotated volume: ')
    self.__volumeSelector = slicer.qMRMLNodeComboBox()
    self.__volumeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
    # only allow volumes with the attribute DICOM.instanceUIDs
    self.__volumeSelector.addAttribute('vtkMRMLScalarVolumeNode','DICOM.instanceUIDs')
    self.__volumeSelector.setMRMLScene(slicer.mrmlScene)
    self.__volumeSelector.addEnabled = False
    
    inputFrameLayout.addRow(label, self.__volumeSelector)

    self.__volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onAnnotatedVolumeNodeChanged)
    self.__volumeSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onMRMLSceneChanged)

    #
    # Annotation frame -- vocabulary-based description of what is
    # being annotated/marked up in this report
    #
    self.__annotationsFrame = ctk.ctkCollapsibleButton()
    self.__annotationsFrame.text = "Annotation"
    self.__annotationsFrame.collapsed = 0
    annotationsFrameLayout = qt.QFormLayout(self.__annotationsFrame)
    
    self.layout.addWidget(self.__annotationsFrame)

    self.__defaultColorNode = self.__logic.GetDefaultColorNode()

    self.__toolsColor = EditColor(self.__annotationsFrame,colorNode=self.__defaultColorNode)

    #
    # Markup frame -- summary of all the markup elements contained in the
    # report
    #
    self.__markupFrame = ctk.ctkCollapsibleButton()
    self.__markupFrame.text = "Markup"
    self.__markupFrame.collapsed = 0
    markupFrameLayout = qt.QFormLayout(self.__markupFrame)
    
    self.layout.addWidget(self.__markupFrame)

    # Add a flag to switch between different tree view models
    self.__useNewTreeView = 1

    # Add the tree widget
    if self.__useNewTreeView == 1:
      self.__markupTreeView = slicer.modulewidget.qMRMLReportingTreeView()
      self.__markupTreeView.sceneModelType = "DisplayableHierarchy"
    else:
      self.__markupTreeView = slicer.qMRMLTreeView()
      self.__markupTreeView.sceneModelType = "Displayable"
    self.__markupTreeView.setMRMLScene(self.__logic.GetMRMLScene())
        
    self.__markupSliceText = qt.QLabel()
    markupFrameLayout.addRow(self.__markupSliceText)
    markupFrameLayout.addRow(self.__markupTreeView)

    # Editor frame
    self.__editorFrame = ctk.ctkCollapsibleButton()
    self.__editorFrame.text = 'Segmentation'
    self.__editorFrame.collapsed = 0
    editorFrameLayout = qt.QFormLayout(self.__editorFrame)

    label = qt.QLabel('Segmentation volume: ')
    self.__segmentationSelector = slicer.qMRMLNodeComboBox()
    self.__segmentationSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
    self.__segmentationSelector.setMRMLScene(slicer.mrmlScene)
    self.__segmentationSelector.addEnabled = 1
    self.__segmentationSelector.noneEnabled = 1
    self.__segmentationSelector.removeEnabled = 0
    self.__segmentationSelector.showHidden = 0
    self.__segmentationSelector.showChildNodeTypes = 0
    self.__segmentationSelector.selectNodeUponCreation = 1
    self.__segmentationSelector.addAttribute('vtkMRMLScalarVolumeNode','LabelMap',1)

    editorFrameLayout.addRow(label, self.__segmentationSelector)

    editorWidgetParent = slicer.qMRMLWidget()
    editorWidgetParent.setLayout(qt.QVBoxLayout())
    editorWidgetParent.setMRMLScene(slicer.mrmlScene)
    self.__editorWidget = EditorWidget(parent=editorWidgetParent,showVolumesFrame=False)
    self.__editorWidget.setup()
    self.__editorWidget.toolsColor.frame.setVisible(False)
    editorFrameLayout.addRow(editorWidgetParent)

    markupFrameLayout.addRow(self.__editorFrame)

    self.__segmentationSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.onSegmentationNodeChanged)
    self.__segmentationSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onMRMLSceneChanged)

    # IO frame
    self.__ioFrame = ctk.ctkCollapsibleButton()
    self.__ioFrame.text = 'Import/Export'
    self.__ioFrame.collapsed = 1
    ioFrameLayout = qt.QGridLayout(self.__ioFrame)

    self.layout.addWidget(self.__ioFrame)

    # Buttons to save/load report using AIM XML serialization
    label = qt.QLabel('Export folder')
    self.__exportFolderPicker = ctk.ctkDirectoryButton()
    exportButton = qt.QPushButton('Export')
    exportButton.connect('clicked()', self.onReportExport)
    ioFrameLayout.addWidget(label,0,0)
    ioFrameLayout.addWidget(self.__exportFolderPicker,0,1)
    ioFrameLayout.addWidget(exportButton,0,2)

    label = qt.QLabel('AIM file to import')
    self.__aimFilePicker = qt.QPushButton('N/A')
    self.__aimFilePicker.connect('clicked()',self.onSelectAIMFile)
    button = qt.QPushButton('Import')
    button.connect('clicked()', self.onReportImport)
    ioFrameLayout.addWidget(label,1,0)
    ioFrameLayout.addWidget(self.__aimFilePicker,1,1)
    ioFrameLayout.addWidget(button,1,2)
    self.__importAIMFile = None

    self.__reportSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.updateWidgets)
    self.__volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.updateWidgets)
    self.updateWidgets()

    self.layout.addStretch(1)

    self.__editorParameterNode = self.editUtil.getParameterNode()

    self.__editorParameterNode.AddObserver(vtk.vtkCommand.ModifiedEvent, self.onEditorParameterNodeChanged)
    def setup(self):
        """This is called one time when the module GUI is initialized
        """
        ScriptedLoadableModuleWidget.setup(self)

        # Create objects that can be used anywhere in the module. Example: in most cases there should be just one
        # object of the logic class
        self.logic = CIP_ParenchymaSubtypeTrainingLogic()
        self.currentVolumeLoaded = None
        self.blockNodeEvents = False

        ##########
        # Main area
        self.mainAreaCollapsibleButton = ctk.ctkCollapsibleButton()
        self.mainAreaCollapsibleButton.text = "Main area"
        self.layout.addWidget(self.mainAreaCollapsibleButton, SlicerUtil.ALIGNMENT_VERTICAL_TOP)
        self.mainLayout = qt.QGridLayout(self.mainAreaCollapsibleButton)

        # Node selector
        volumeLabel = qt.QLabel("Active volume: ")
        volumeLabel.setStyleSheet("margin-left:5px")
        self.mainLayout.addWidget(volumeLabel, 0, 0)
        self.volumeSelector = slicer.qMRMLNodeComboBox()
        self.volumeSelector.nodeTypes = ("vtkMRMLScalarVolumeNode", "")
        self.volumeSelector.selectNodeUponCreation = True
        self.volumeSelector.autoFillBackground = True
        self.volumeSelector.addEnabled = False
        self.volumeSelector.noneEnabled = False
        self.volumeSelector.removeEnabled = False
        self.volumeSelector.showHidden = False
        self.volumeSelector.showChildNodeTypes = False
        self.volumeSelector.setMRMLScene(slicer.mrmlScene)
        self.volumeSelector.setFixedWidth(250)
        self.volumeSelector.setStyleSheet("margin: 15px 0")
        #self.volumeSelector.selectNodeUponCreation = False
        self.mainLayout.addWidget(self.volumeSelector, 0, 1, 1, 3)

        labelsStyle = "font-weight: bold; margin: 0 0 5px 5px;"
        # Types Radio Buttons
        typesLabel = qt.QLabel("Select the type")
        typesLabel.setStyleSheet(labelsStyle)
        typesLabel.setFixedHeight(15)
        self.mainLayout.addWidget(typesLabel, 1, 0)
        self.typesFrame = qt.QFrame()
        self.typesLayout = qt.QVBoxLayout(self.typesFrame)
        self.mainLayout.addWidget(self.typesFrame, 2, 0, SlicerUtil.ALIGNMENT_VERTICAL_TOP)
        self.typesRadioButtonGroup = qt.QButtonGroup()
        for key in self.logic.params.mainTypes.iterkeys():
            rbitem = qt.QRadioButton(self.logic.params.getMainTypeLabel(key))
            self.typesRadioButtonGroup.addButton(rbitem, key)
            self.typesLayout.addWidget(rbitem)
        self.typesRadioButtonGroup.buttons()[0].setChecked(True)

        # Subtypes Radio buttons
        subtypesLabel = qt.QLabel("Select the subtype")
        subtypesLabel.setStyleSheet(labelsStyle)
        subtypesLabel.setFixedHeight(15)
        self.mainLayout.addWidget(subtypesLabel, 1, 1)
        self.subtypesRadioButtonGroup = qt.QButtonGroup()
        self.subtypesFrame = qt.QFrame()
        self.subtypesFrame.setMinimumHeight(275)
        self.subtypesLayout = qt.QVBoxLayout(self.subtypesFrame)
        self.subtypesLayout.setAlignment(SlicerUtil.ALIGNMENT_VERTICAL_TOP)
        self.subtypesLayout.setStretch(0, 0)
        self.mainLayout.addWidget(self.subtypesFrame, 2, 1, SlicerUtil.ALIGNMENT_VERTICAL_TOP)     # Put the frame in the top
        # The content will be loaded dynamically every time the main type is modified

        # Artifact radio buttons
        self.artifactsLabel = qt.QLabel("Artifact")
        self.artifactsLabel.setStyleSheet(labelsStyle)
        self.artifactsLabel.setFixedHeight(15)
        self.mainLayout.addWidget(self.artifactsLabel, 1, 2)
        #self.mainLayout.addWidget(qt.QLabel("Select the artifact"), 1, 1)
        self.artifactsRadioButtonGroup = qt.QButtonGroup()
        self.artifactsFrame = qt.QFrame()
        self.artifactsLayout = qt.QVBoxLayout(self.artifactsFrame)
        self.mainLayout.addWidget(self.artifactsFrame, 2, 2, SlicerUtil.ALIGNMENT_VERTICAL_TOP)
        self.artifactsRadioButtonGroup = qt.QButtonGroup()
        for artifactId in self.logic.params.artifacts.iterkeys():
            rbitem = qt.QRadioButton(self.logic.params.getArtifactLabel(artifactId))
            self.artifactsRadioButtonGroup.addButton(rbitem, artifactId)
            self.artifactsLayout.addWidget(rbitem)
        self.artifactsRadioButtonGroup.buttons()[0].setChecked(True)

        # Load caselist button
        self.loadButton = ctk.ctkPushButton()
        self.loadButton.text = "Load fiducials file"
        self.loadButton.setIcon(qt.QIcon("{0}/open_file.png".format(SlicerUtil.CIP_ICON_DIR)))
        self.loadButton.setIconSize(qt.QSize(20, 20))
        self.loadButton.setFixedWidth(135)
        self.mainLayout.addWidget(self.loadButton, 3, 0)

        # Remove fiducial button
        self.removeLastFiducialButton = ctk.ctkPushButton()
        self.removeLastFiducialButton.text = "Remove last fiducial"
        self.removeLastFiducialButton.toolTip = "Remove the last fiducial added"
        self.removeLastFiducialButton.setIcon(qt.QIcon("{0}/delete.png".format(SlicerUtil.CIP_ICON_DIR)))
        self.removeLastFiducialButton.setIconSize(qt.QSize(20, 20))
        self.removeLastFiducialButton.setFixedWidth(200)
        self.mainLayout.addWidget(self.removeLastFiducialButton, 3, 1)

        # Save results button
        self.saveResultsButton = ctk.ctkPushButton()
        self.saveResultsButton.setText("Save markups")
        self.saveResultsButton.toolTip = "Save the markups in the specified directory"
        self.saveResultsButton.setIcon(qt.QIcon("{0}/Save.png".format(SlicerUtil.CIP_ICON_DIR)))
        self.saveResultsButton.setIconSize(qt.QSize(20,20))
        self.mainLayout.addWidget(self.saveResultsButton, 4, 0)

        # Save results directory button
        defaultPath = os.path.join(SlicerUtil.getSettingsDataFolder(self.moduleName), "Results")     # Assign a default path for the results
        path = SlicerUtil.settingGetOrSetDefault(self.moduleName, "SaveResultsDirectory", defaultPath)
        self.saveResultsDirectoryButton = ctk.ctkDirectoryButton()
        self.saveResultsDirectoryButton.directory = path
        self.saveResultsDirectoryButton.setMaximumWidth(375)
        self.mainLayout.addWidget(self.saveResultsDirectoryButton, 4, 1, 1, 2)

        #####
        # Case navigator
        if SlicerUtil.isSlicerACILLoaded():
            caseNavigatorAreaCollapsibleButton = ctk.ctkCollapsibleButton()
            caseNavigatorAreaCollapsibleButton.text = "Case navigator"
            self.layout.addWidget(caseNavigatorAreaCollapsibleButton, 0x0020)
            # caseNavigatorLayout = qt.QVBoxLayout(caseNavigatorAreaCollapsibleButton)

            # Add a case list navigator
            from ACIL.ui import CaseNavigatorWidget
            self.caseNavigatorWidget = CaseNavigatorWidget(self.moduleName, caseNavigatorAreaCollapsibleButton)
            self.caseNavigatorWidget.setup()
            # Listen for the event of loading volume
            #self.caseNavigatorWidget.addObservable(self.caseNavigatorWidget.EVENT_VOLUME_LOADED, self.onNewVolumeLoaded)

        self.layout.addStretch()

        self.updateState()

        # Connections
        self.typesRadioButtonGroup.connect("buttonClicked (QAbstractButton*)", self.__onTypesRadioButtonClicked__)
        self.subtypesRadioButtonGroup.connect("buttonClicked (QAbstractButton*)", self.__onSubtypesRadioButtonClicked__)
        self.artifactsRadioButtonGroup.connect("buttonClicked (QAbstractButton*)", self.__onSubtypesRadioButtonClicked__)

        self.volumeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.__onCurrentNodeChanged__)
        self.loadButton.connect('clicked()', self.openFiducialsFile)
        self.removeLastFiducialButton.connect('clicked()', self.__onRemoveLastFiducialButtonClicked__)
        # self.saveResultsOpenDirectoryDialogButton.connect('clicked()', self.onOpenDirectoryDialogButtonClicked)
        self.saveResultsDirectoryButton.connect("directoryChanged (str)", self.__onSaveResultsDirectoryChanged__)
        self.saveResultsButton.connect('clicked()', self.__onSaveResultsButtonClicked__)

        self.observers = []
        self.observers.append(slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.NodeAddedEvent, self.__onNodeAddedObserver__))
        self.observers.append(slicer.mrmlScene.AddObserver(slicer.vtkMRMLScene.EndCloseEvent, self.__onSceneClosed__))
示例#16
0
    def setup(self):

        w = qt.QWidget()
        layout = qt.QGridLayout()
        w.setLayout(layout)
        self.layout.addWidget(w)
        w.show()
        self.layout = layout

        ####################IMPORTAR VOLUMEN 4D#################################################3

        ### Se crea la sección para importar
        importDataCollapsibleButton = ctk.ctkCollapsibleButton()
        importDataCollapsibleButton.text = "Import DICOM"
        self.layout.addWidget(importDataCollapsibleButton)
        importDataFormLayout = qt.QFormLayout(importDataCollapsibleButton)
        #### Crear desplegable para seleccionar dirección del volumen
        self.__fDialog = ctk.ctkDirectoryButton()
        self.__fDialog.caption = 'Input directory'
        importDataFormLayout.addRow('Input directory:', self.__fDialog)
        #### Crear desplegable para seleccionar dirección del volumen
        self.inputSelector = slicer.qMRMLNodeComboBox()
        self.inputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
        self.inputSelector.addEnabled = True  # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
        self.inputSelector.removeEnabled = True  # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
        self.inputSelector.setMRMLScene(slicer.mrmlScene)
        importDataFormLayout.addRow("Input node:", self.inputSelector)
        self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
                            self.inputSelector, 'setMRMLScene(vtkMRMLScene*)')

        self.__nameFrame = qt.QLineEdit()
        self.__nameFrame.text = 'NA'
        importDataFormLayout.addRow('Volume Name', self.__nameFrame)

        # Botón de importar
        self.buttonImport = qt.QPushButton("Import")
        self.buttonImport.toolTip = "Run the algorithm."
        importDataFormLayout.addRow("", self.buttonImport)
        self.buttonImport.connect('clicked(bool)', self.importFunction)
        ### Se crea la sección para exportar
        exportDataCollapsibleButton = ctk.ctkCollapsibleButton()
        exportDataCollapsibleButton.text = "Export DICOM"
        self.layout.addWidget(exportDataCollapsibleButton)
        exportDataFormLayout = qt.QFormLayout(exportDataCollapsibleButton)
        ###Selector de volumen donde se guardara el volumen de la direccion
        self.outputSelector = slicer.qMRMLNodeComboBox()
        self.outputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
        self.outputSelector.addEnabled = False  # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
        self.outputSelector.removeEnabled = False  # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
        self.outputSelector.setMRMLScene(slicer.mrmlScene)
        exportDataFormLayout.addRow("Volumen to export:", self.outputSelector)
        self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
                            self.outputSelector, 'setMRMLScene(vtkMRMLScene*)')
        #### Crear desplegable para seleccionar direccion del volumen
        self.__fDialogOutput = ctk.ctkDirectoryButton()
        self.__fDialogOutput.caption = 'DICOM directory'
        exportDataFormLayout.addRow('DiCOM directory:', self.__fDialogOutput)
        # Botón de exportar
        self.buttonExport = qt.QPushButton("Export")
        self.buttonExport.toolTip = "Run the algorithm."
        exportDataFormLayout.addRow("", self.buttonExport)
        self.buttonExport.connect('clicked(bool)', self.ExportFunction)
示例#17
0
  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 = "tipiXExporter 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)

    #
    # source directory button
    #
    self.sourceButton = ctk.ctkDirectoryButton()
    self.sourceButton.setToolTip( "Select the directory containing the source image volumes to load." )
    parametersFormLayout.addRow("Source Image Files: ", self.sourceButton)

    #
    # destination directory button
    #
    self.destinationButton = ctk.ctkDirectoryButton()
    self.destinationButton.setToolTip( "Select the destination for rendered images." )
    parametersFormLayout.addRow("Destination Files: ", self.destinationButton)

    if False:
        #
        # 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 = "Render the images."
    parametersFormLayout.addRow(self.applyButton)

    # connections
    self.applyButton.connect('clicked(bool)', self.onApplyButton)

    # Add vertical spacer
    self.layout.addStretch(1)
    def setup(self):
        ScriptedLoadableModuleWidget.setup(self)
        # -------------------------------------------------------------------------------------
        self.modelList = list()
        self.fieldList = list()
        self.ROIList = list()
        self.ROIDict = dict()  # Key = Name of ROI
                               # Value = Dictionary of Fields (key = Name of Field
                               #                               Value = dictionary of shapes
                               #                                             key = name of shapes
                               #                                             value = Statistics store()

        self.logic = MeshStatisticsLogic()
        # ------------------------------------------------------------------------------------
        #                                    SHAPES INPUT
        # ------------------------------------------------------------------------------------
        self.inputComboBox = slicer.qMRMLCheckableNodeComboBox()
        self.inputComboBox.nodeTypes = ['vtkMRMLModelNode']
        self.inputComboBox.setMRMLScene(slicer.mrmlScene)
        inputLayout = qt.QFormLayout()
        inputLayout.addRow(' Models: ', self.inputComboBox)
        self.layout.addLayout(inputLayout)

        self.inputComboBox.connect('checkedNodesChanged()', self.onInputComboBoxCheckedNodesChanged)
        # ------------------------------------------------------------------------------------
        #                                  ROI TABLE
        # ------------------------------------------------------------------------------------
        self.ROIComboBox = ctk.ctkComboBox()
        self.ROIComboBox.adjustSize()
        self.ROICheckBox = qt.QCheckBox('All')
        ROILayout = qt.QHBoxLayout()
        ROILayout_0 = qt.QFormLayout()
        ROILayout_0.addRow(' Region considered: ', self.ROIComboBox)
        ROILayout.addLayout(ROILayout_0)
        ROILayout.addWidget(self.ROICheckBox)

        self.layout.addLayout(ROILayout)
        self.ROICheckBox.connect('stateChanged(int)', self.onROICheckBoxStateChanged)
        # ------------------------------------------------------------------------------------
        #                                  FIELD TABLE
        # ------------------------------------------------------------------------------------
        self.tableField = qt.QTableWidget()
        self.tableField.setColumnCount(2)
        self.tableField.setMinimumHeight(250)
        self.tableField.setHorizontalHeaderLabels([' ', ' Field Name '])
        self.tableField.setColumnWidth(0, 20)
        self.tableField.setColumnWidth(1, 260)
        self.tableField.setSizePolicy(qt.QSizePolicy().Expanding, qt.QSizePolicy().Expanding)
        
        label = qt.QLabel(' Select a Field to compute statistics on:')
        self.fieldLayout = qt.QVBoxLayout()
        self.fieldLayout.addWidget(label)
        self.fieldLayout.addWidget(self.tableField)
        self.layout.addLayout(self.fieldLayout)
        # ------------------------------------------------------------------------------------
        #                                    RUN
        # ------------------------------------------------------------------------------------
        self.runButton = qt.QPushButton(' Run ')
        self.runButton.enabled = False
        roiLayout = qt.QHBoxLayout()
        roiLayout.addWidget(self.runButton)
        self.layout.addLayout(roiLayout)
        self.runButton.connect('clicked()', self.onRunButton)
        # ------------------------------------------------------------------------------------
        #                          Statistics Table - Export
        # ------------------------------------------------------------------------------------
        self.tabROI = qt.QTabWidget()
        self.tabROI.setTabPosition(0)
        self.tabROI.adjustSize()
        # ---------------------------- Directory - Export Button -----------------------------
        self.directoryExport = ctk.ctkDirectoryButton()
        self.exportCheckBox = qt.QCheckBox('Separate Files')
        self.exportCheckBox.setChecked(True)
        self.exportButton = qt.QPushButton(' Export ')
        self.exportButton.enabled = True
        self.exportPointValueCheckBox = qt.QCheckBox('Export Value on Each Point')
        
        self.exportLayout = qt.QVBoxLayout()
        self.directoryAndExportLayout = qt.QHBoxLayout()
        self.directoryAndExportLayout.addWidget(self.directoryExport)
        self.directoryAndExportLayout.addWidget(self.exportCheckBox)
        self.directoryAndExportLayout.addWidget(self.exportPointValueCheckBox)
        self.exportButtonsLayout = qt.QHBoxLayout()
        self.exportButtonsLayout.addWidget(self.exportButton)
        

        self.exportLayout.addLayout(self.directoryAndExportLayout)
        self.exportLayout.addLayout(self.exportButtonsLayout)
        
        self.layout.addStretch(1)
        self.logic.updateInterface(self.tableField, self.ROIComboBox, self.ROIList, self.modelList, self.layout)

        # ------------------------------------------------------------------------------------
        #                                   OBSERVERS
        # ------------------------------------------------------------------------------------
        def onCloseScene(obj, event):
            # initialize Parameters
            globals()['MeshStatistics'] = slicer.util.reloadScriptedModule('MeshStatistics')
        slicer.mrmlScene.AddObserver(slicer.mrmlScene.EndCloseEvent, onCloseScene)
示例#19
0
    def setup(self):

        w = qt.QWidget()
        layout = qt.QGridLayout()
        w.setLayout(layout)
        self.layout.addWidget(w)
        w.show()
        self.layout = layout

        ####################IMPORTAR VOLUMEN 4D#################################################3

        ### Se crea la sección para cargar el volumen 4D en una pestaña desplegable
        importDataCollapsibleButton = ctk.ctkCollapsibleButton()
        importDataCollapsibleButton.text = "Import Data"
        self.layout.addWidget(importDataCollapsibleButton)

        importDataFormLayout = qt.QFormLayout(importDataCollapsibleButton)

        #### Crear desplegable para seleccionar dirección del volumen
        self.__fDialog = ctk.ctkDirectoryButton()
        self.__fDialog.caption = 'Input directory'
        importDataFormLayout.addRow('Input directory:', self.__fDialog)

        ###Selector de volumen donde se guardara el volumen de la direccion
        self.outputSelector = slicer.qMRMLNodeComboBox()
        self.outputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
        self.outputSelector.addEnabled = True  # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
        self.outputSelector.removeEnabled = False  # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
        self.outputSelector.setMRMLScene(slicer.mrmlScene)
        importDataFormLayout.addRow("Output node:", self.outputSelector)
        self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
                            self.outputSelector, 'setMRMLScene(vtkMRMLScene*)')

        ### Parametros avanzados

        self.__dicomTag = qt.QLineEdit()
        self.__dicomTag.text = 'NA'
        importDataFormLayout.addRow('Frame identifying DICOM tag:',
                                    self.__dicomTag)

        self.__veLabel = qt.QLineEdit()
        self.__veLabel.text = 'na'
        importDataFormLayout.addRow('Frame identifying units:', self.__veLabel)

        self.__veInitial = qt.QDoubleSpinBox()
        self.__veInitial.value = 0
        importDataFormLayout.addRow('Initial value:', self.__veInitial)

        self.__veStep = qt.QDoubleSpinBox()
        self.__veStep.value = 1
        importDataFormLayout.addRow('Step:', self.__veStep)

        self.__te = qt.QDoubleSpinBox()
        self.__te.value = 1
        importDataFormLayout.addRow('EchoTime:', self.__te)

        self.__tr = qt.QDoubleSpinBox()
        self.__tr.value = 1
        importDataFormLayout.addRow('RepetitionTime:', self.__tr)

        self.__fa = qt.QDoubleSpinBox()
        self.__fa.value = 1
        importDataFormLayout.addRow('FlipAngle:', self.__fa)

        # Botón de importar

        self.buttonImport = qt.QPushButton("Import")
        self.buttonImport.toolTip = "Run the algorithm."
        ##self.buttonImport.enabled = True
        importDataFormLayout.addRow("                                       ",
                                    self.buttonImport)

        self.buttonImport.connect('clicked(bool)', self.importFunction)
    def setup(self):
        # Instantiate and connect widgets ...

        # Collapsible button
        dummyCollapsibleButton = ctk.ctkCollapsibleButton()
        dummyCollapsibleButton.text = "Basic settings"
        self.layout.addWidget(dummyCollapsibleButton)
        dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)

        # add input directory selector
        label = qt.QLabel("Input directory:")
        self.__fDialog = ctk.ctkDirectoryButton()
        self.__fDialog.caption = "Input directory"
        dummyFormLayout.addRow(label, self.__fDialog)

        label = qt.QLabel("Output node:")
        self.__mvSelector = slicer.qMRMLNodeComboBox()
        self.__mvSelector.nodeTypes = ["vtkMRMLMultiVolumeNode"]
        self.__mvSelector.setMRMLScene(slicer.mrmlScene)
        self.__mvSelector.connect("mrmlSceneChanged(vtkMRMLScene*)", self.onMRMLSceneChanged)
        self.__mvSelector.addEnabled = 1
        dummyFormLayout.addRow(label, self.__mvSelector)

        # Collapsible button
        dummyCollapsibleButton = ctk.ctkCollapsibleButton()
        dummyCollapsibleButton.text = "Advanced settings"
        dummyCollapsibleButton.collapsed = 1
        self.layout.addWidget(dummyCollapsibleButton)
        dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)
        self.__advancedFrame = dummyCollapsibleButton

        label = qt.QLabel("Frame identifying DICOM tag (if known):")
        self.__dicomTag = qt.QLineEdit()
        self.__dicomTag.text = "NA"
        dummyFormLayout.addRow(label, self.__dicomTag)

        label = qt.QLabel("Frame identifying units:")
        self.__veLabel = qt.QLineEdit()
        self.__veLabel.text = "na"
        dummyFormLayout.addRow(label, self.__veLabel)

        label = qt.QLabel("Initial value:")
        self.__veInitial = qt.QDoubleSpinBox()
        self.__veInitial.value = 0
        dummyFormLayout.addRow(label, self.__veInitial)

        label = qt.QLabel("Step:")
        self.__veStep = qt.QDoubleSpinBox()
        self.__veStep.value = 1
        dummyFormLayout.addRow(label, self.__veStep)

        label = qt.QLabel("EchoTime:")
        self.__te = qt.QDoubleSpinBox()
        self.__te.value = 1
        dummyFormLayout.addRow(label, self.__te)

        label = qt.QLabel("RepetitionTime:")
        self.__tr = qt.QDoubleSpinBox()
        self.__tr.value = 1
        dummyFormLayout.addRow(label, self.__tr)

        label = qt.QLabel("FlipAngle:")
        self.__fa = qt.QDoubleSpinBox()
        self.__fa.value = 1
        dummyFormLayout.addRow(label, self.__fa)

        importButton = qt.QPushButton("Import")
        importButton.toolTip = "Import the contents of the directory as a MultiVolume"
        self.layout.addWidget(importButton)
        importButton.connect("clicked(bool)", self.onImportButtonClicked)

        self.__status = qt.QLabel("Status: Idle")
        self.layout.addWidget(self.__status)

        # Add vertical spacer
        self.layout.addStretch(1)
示例#21
0
  def setup(self):

    w = qt.QWidget();
    layout = qt.QGridLayout();
    w.setLayout(layout);
    self.layout.addWidget(w);
    w.show();
    self.layout = layout;

####################IMPORTAR VOLUMEN 4D#################################################3

### Se crea la sección para cargar el volumen 4D en una pestaña desplegable
    importDataCollapsibleButton = ctk.ctkCollapsibleButton()
    importDataCollapsibleButton.text = "Import Data"
    self.layout.addWidget(importDataCollapsibleButton)

    importDataFormLayout = qt.QFormLayout(importDataCollapsibleButton)


#### Crear desplegable para seleccionar dirección del volumen
    self.__fDialog = ctk.ctkDirectoryButton()
    self.__fDialog.caption = 'Input directory'
    importDataFormLayout.addRow('Input directory:', self.__fDialog)


 ###Selector de volumen donde se guardara el volumen de la direccion
    self.outputSelector = slicer.qMRMLNodeComboBox()
    self.outputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
    self.outputSelector.addEnabled = True  # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
    self.outputSelector.removeEnabled = False  # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
    self.outputSelector.setMRMLScene(slicer.mrmlScene)
    importDataFormLayout.addRow("Output node:", self.outputSelector)
    self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.outputSelector, 'setMRMLScene(vtkMRMLScene*)')  


### Parametros avanzados
    
    self.__dicomTag = qt.QLineEdit()
    self.__dicomTag.text = 'NA'
    importDataFormLayout.addRow('Frame identifying DICOM tag:', self.__dicomTag)

    self.__veLabel = qt.QLineEdit()
    self.__veLabel.text = 'na'
    importDataFormLayout.addRow('Frame identifying units:', self.__veLabel)

    self.__veInitial = qt.QDoubleSpinBox()
    self.__veInitial.value = 0
    importDataFormLayout.addRow('Initial value:', self.__veInitial)

    self.__veStep = qt.QDoubleSpinBox()
    self.__veStep.value = 1
    importDataFormLayout.addRow('Step:', self.__veStep)

  
    self.__te = qt.QDoubleSpinBox()
    self.__te.value = 1
    importDataFormLayout.addRow('EchoTime:', self.__te)

    
    self.__tr = qt.QDoubleSpinBox()
    self.__tr.value = 1
    importDataFormLayout.addRow('RepetitionTime:', self.__tr)

    self.__fa = qt.QDoubleSpinBox()
    self.__fa.value = 1
    importDataFormLayout.addRow('FlipAngle:', self.__fa)


    # Botón de importar

    self.buttonImport = qt.QPushButton("Import")
    self.buttonImport.toolTip = "Run the algorithm."
    ##self.buttonImport.enabled = True
    importDataFormLayout.addRow("                                       ", self.buttonImport)

    self.buttonImport.connect('clicked(bool)', self.importFunction)
    ##self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)

################################### PARÁMETROS DE PROCESAMIENTO#################################################
##    # Se crea la sección para seleccionar parámetros el volumen 4D en una pestaña desplegable
    parametersCollapsibleButton = ctk.ctkCollapsibleButton()
    parametersCollapsibleButton.text = "Parameters"
    self.layout.addWidget(parametersCollapsibleButton)

    parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)

    self.inputSelector = slicer.qMRMLNodeComboBox()
    self.inputSelector.nodeTypes = ["vtkMRMLMultiVolumeNode"]
    self.inputSelector.selectNodeUponCreation = True
    self.inputSelector.addEnabled = True
    self.inputSelector.removeEnabled = False
    self.inputSelector.noneEnabled = True
    self.inputSelector.showHidden = False
    self.inputSelector.showChildNodeTypes = False
    self.inputSelector.setMRMLScene( slicer.mrmlScene )
    self.inputSelector.setToolTip( "Pick the input to the algorithm." )
    parametersFormLayout.addRow("Volumen 4D: ", self.inputSelector)
    self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', self.inputSelector, 'setMRMLScene(vtkMRMLScene*)')


##########################PROCESAMIENTO##########################################################################

##    # Se crea la sección para seleccionar procesamiento del volumen 4D en una pestaña desplegable
    processingCollapsibleButton = ctk.ctkCollapsibleButton()
    processingCollapsibleButton.text = "Processing"
    self.layout.addWidget(processingCollapsibleButton)

    processingFormLayout = qt.QFormLayout(processingCollapsibleButton)

        # Botón de Segmentación
    #Este botón solo se activa si el multivolumen ha sido seleccionado en la
    #ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
    #realiza el registro de los diferentes volumenes en el volumen 4D

    self.buttonSegmentation = qt.QPushButton("Segmentation")
    self.buttonSegmentation.toolTip = "Run the algorithm."
    self.buttonSegmentation.enabled = True
    processingFormLayout.addRow("                                       ", self.buttonSegmentation)


    # Botón de modelo 3D
    #Este botón solo se activa si el multivolumen ha sido seleccionado en la
    #ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
    #realiza el registro de los diferentes volumenes en el volumen 4D
    self.buttonModel = qt.QPushButton("Show 3D model")
    self.buttonModel.toolTip = "Run the algorithm."
    self.buttonModel.enabled = True
    processingFormLayout.addRow("                                       ",self.buttonModel)



########################################CURVAS#######################################################

    
##    # Se crea la sección para seleccionar curvas del volumen 4D en una pestaña desplegable
    curvesCollapsibleButton = ctk.ctkCollapsibleButton()
    curvesCollapsibleButton.text = "Curves"
    self.layout.addWidget(curvesCollapsibleButton)

    curvesFormLayout = qt.QFormLayout(curvesCollapsibleButton)

# Botón de generación de curvas
    #Este botón solo se activa si el multivolumen ha sido seleccionado en la
    #ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
    #realiza el registro de los diferentes volumenes en el volumen 4D
    self.buttonCurves = qt.QPushButton("Generate curves")
    self.buttonCurves.toolTip = "Run the algorithm."
    self.buttonCurves.enabled = True
    curvesFormLayout.addRow("                                       ",self.buttonCurves)
    def setup(self):
        ScriptedLoadableModuleWidget.setup(self)
        # Instantiate and connect widgets ...

        if not NUMPY_AVAILABLE:
            label = qt.QLabel(
                'The module is not available due to missing Numpy package.')
            self.layout.addWidget(label)
            label = qt.QLabel(
                'You can seek help by contacting 3D Slicer user list: [email protected]'
            )
            self.layout.addWidget(label)

            # Add vertical spacer
            self.layout.addStretch(1)
            return

        # Collapsible button
        dummyCollapsibleButton = ctk.ctkCollapsibleButton()
        dummyCollapsibleButton.text = "Basic settings"
        self.layout.addWidget(dummyCollapsibleButton)
        dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)

        # add input directory selector
        label = qt.QLabel('Input directory:')
        self.__fDialog = ctk.ctkDirectoryButton()
        self.__fDialog.caption = 'Input directory'
        dummyFormLayout.addRow(label, self.__fDialog)

        label = qt.QLabel('Output node:')
        self.__mvSelector = slicer.qMRMLNodeComboBox()
        self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
        self.__mvSelector.setMRMLScene(slicer.mrmlScene)
        self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)',
                                  self.onMRMLSceneChanged)
        self.__mvSelector.addEnabled = 1
        dummyFormLayout.addRow(label, self.__mvSelector)

        # Collapsible button
        dummyCollapsibleButton = ctk.ctkCollapsibleButton()
        dummyCollapsibleButton.text = "Advanced settings"
        dummyCollapsibleButton.collapsed = 1
        self.layout.addWidget(dummyCollapsibleButton)
        dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)
        self.__advancedFrame = dummyCollapsibleButton

        label = qt.QLabel('Frame identifying DICOM tag (if known):')
        self.__dicomTag = qt.QLineEdit()
        self.__dicomTag.text = 'NA'
        dummyFormLayout.addRow(label, self.__dicomTag)

        label = qt.QLabel('Frame identifying units:')
        self.__veLabel = qt.QLineEdit()
        self.__veLabel.text = 'na'
        dummyFormLayout.addRow(label, self.__veLabel)

        label = qt.QLabel('Initial value:')
        self.__veInitial = qt.QDoubleSpinBox()
        self.__veInitial.value = 0
        dummyFormLayout.addRow(label, self.__veInitial)

        label = qt.QLabel('Step:')
        self.__veStep = qt.QDoubleSpinBox()
        self.__veStep.value = 1
        dummyFormLayout.addRow(label, self.__veStep)

        label = qt.QLabel('EchoTime:')
        self.__te = qt.QDoubleSpinBox()
        self.__te.value = 1
        dummyFormLayout.addRow(label, self.__te)

        label = qt.QLabel('RepetitionTime:')
        self.__tr = qt.QDoubleSpinBox()
        self.__tr.value = 1
        dummyFormLayout.addRow(label, self.__tr)

        label = qt.QLabel('FlipAngle:')
        self.__fa = qt.QDoubleSpinBox()
        self.__fa.value = 1
        dummyFormLayout.addRow(label, self.__fa)

        importButton = qt.QPushButton("Import")
        importButton.toolTip = "Import the contents of the directory as a MultiVolume"
        self.layout.addWidget(importButton)
        importButton.connect('clicked(bool)', self.onImportButtonClicked)

        self.__status = qt.QLabel('Status: Idle')
        self.layout.addWidget(self.__status)

        # Add vertical spacer
        self.layout.addStretch(1)
示例#23
0
    def setup(self):
        """Init the widget """
        self.modulePath = SlicerUtil.getModuleFolder("CIP_GetImage")
        
        self.resourcesPath = os.path.join(self.modulePath, "CIP_GetImage_Resources")
        self.StudyId = ""


        
        self.logic = CIP_GetImageLogic(self.modulePath)
        
        # Widget to load cases faster
        self.loadSaveDatabuttonsWidget = CIPUI.LoadSaveDataWidget(parentWidget=self.parent)
        self.loadSaveDatabuttonsWidget.setup(moduleName="CIP_GetImage")
        
        #
        # Obligatory parameters area
        #
        parametersCollapsibleButton = ctk.ctkCollapsibleButton()
        parametersCollapsibleButton.text = "Image data"
        self.layout.addWidget(parametersCollapsibleButton)        
        parametersFormLayout = qt.QFormLayout(parametersCollapsibleButton)
        
        # Study radio buttons
        label = qt.QLabel()
        label.text = "Select the study:"
        parametersFormLayout.addRow(label)        
        
        self.rbgStudy=qt.QButtonGroup() 
        
        for key in self.studyIds:
            rbStudyid = qt.QRadioButton(key)
            self.rbgStudy.addButton(rbStudyid)     
            parametersFormLayout.addWidget(rbStudyid)        
         
        self.txtOtherStudy = qt.QLineEdit()
        self.txtOtherStudy.hide()
        parametersFormLayout.addWidget(self.txtOtherStudy)

        
        # Case id 
        self.txtCaseId = qt.QLineEdit()        
        parametersFormLayout.addRow("Case ID     ", self.txtCaseId)
        
        # Image types
        label = qt.QLabel()
        label.text = "Select the images that you want to load:"
        parametersFormLayout.addRow(label)
        
        self.cbsImageTypes = []
        for key in self.imageTypes:            
            check = qt.QCheckBox()
            check.checked = True
            check.setText(key)
            parametersFormLayout.addWidget(check)
            self.cbsImageTypes.append(check) 
        
        # Label maps    
        label = qt.QLabel()
        label.text = "Select the label maps that you want to load:"
        parametersFormLayout.addRow(label)
        
        # Labelmap types checkboxes
        self.cbsLabelMapTypes = []
        for key in self.labelMapTypes:            
            check = qt.QCheckBox()
            check.setText(key)
            check.checked = self.labelMapTypes[key][0]            
            parametersFormLayout.addWidget(check)        
            self.cbsLabelMapTypes.append(check)         
        
        
        # Load image Button        
        self.downloadButton = qt.QPushButton("Download")                
        self.downloadButton.toolTip = "Load the image"        
        #self.downloadButton.enabled = False
        self.downloadButton.setStyleSheet("background-color: green; font-weight:bold; color:white" )
        parametersFormLayout.addRow(self.downloadButton)
        self.downloadButton.connect('clicked (bool)', self.onDownloadButton)
                

        # Information message
        self.lblDownloading = qt.QLabel()
        self.lblDownloading.text = "Downloading images. Please wait..."
        self.lblDownloading.hide()
        parametersFormLayout.addRow(self.lblDownloading)        
        
        
        #
        # Optional Parameters
        #
        optionalParametersCollapsibleButton = ctk.ctkCollapsibleButton()
        optionalParametersCollapsibleButton.text = "Optional parameters"
        self.layout.addWidget(optionalParametersCollapsibleButton)
        optionalParametersFormLayout = qt.QFormLayout(optionalParametersCollapsibleButton)
     
        # Local storage (Slicer temporary path)                
        self.localStoragePath = "{0}/CIP".format(slicer.app.temporaryPath)        
        if not os.path.exists(self.localStoragePath):            
            os.makedirs(self.localStoragePath)
            # Make sure that everybody has write permissions (sometimes there are problems because of umask)
            os.chmod(self.localStoragePath, 0777)
            
        self.storagePathButton = ctk.ctkDirectoryButton()
        self.storagePathButton.directory = self.localStoragePath

        optionalParametersFormLayout.addRow("Local directory: ", self.storagePathButton)     
        
        # Connection type (SSH, "normal")
        label = qt.QLabel()
        label.text = "Connection type:"
        optionalParametersFormLayout.addRow(label)
        
        self.rbgConnectionType=qt.QButtonGroup() 
        self.rbSSH = qt.QRadioButton("SSH (secure connection)")
        self.rbSSH.setChecked(True)
        self.rbgConnectionType.addButton(self.rbSSH)        
        optionalParametersFormLayout.addWidget(self.rbSSH)
        
        self.rbCP = qt.QRadioButton("Common")
        self.rbgConnectionType.addButton(self.rbCP)
        optionalParametersFormLayout.addWidget(self.rbCP)    
        
     
        
        # SSH Server login
        self.txtServer = qt.QLineEdit()
        s = SlicerUtil.settingGetOrSetDefault("CIP_GetImage", "server", "This is your ssh user and server. Example: [email protected]")
        self.txtServer.text = s     # This is your ssh user and server. Example: [email protected]"
        optionalParametersFormLayout.addRow("Server:", self.txtServer)

        # Server root path
        self.txtServerpath = qt.QLineEdit()
        s = SlicerUtil.settingGetOrSetDefault("CIP_GetImage", "serverRootPath", "This is your root path to search for files. Ex: /Cases/Processed")
        self.txtServerpath.text = s     # This is your root path to search for files. Ex: /Cases/Processed
        optionalParametersFormLayout.addRow("Server root path:", self.txtServerpath)
        
                
        # SSH Private key    
        self.txtPrivateKeySSH = qt.QLineEdit()        
        s = SlicerUtil.settingGetOrSetDefault("CIP_GetImage", "sshKey", "")
        self.txtPrivateKeySSH.text = s # this is the full path to your ssh key if you need it. Be aware of Unix/Windows comaptibility (hint: use os.path.join)
                                        # Please notice that you won't need a SSH key if your computer already has one locally installed"
        optionalParametersFormLayout.addRow("SSH private key (leave blank for computer's default):     ", self.txtPrivateKeySSH)
        
        # Cache mode 
        self.cbCacheMode = qt.QCheckBox("Cache mode activated")
        self.cbCacheMode.setChecked(True)     # Cache mode is activated by default
        optionalParametersFormLayout.addRow("", self.cbCacheMode)        
        
        # Clean cache Button        
        self.cleanCacheButton = qt.QPushButton("Clean cache")                
        self.cleanCacheButton.toolTip = "Remove all the local cached files"
        optionalParametersFormLayout.addRow(self.cleanCacheButton)
        optionalParametersCollapsibleButton.collapsed = True

        if SlicerUtil.IsDevelopment:
            # reload button
            self.reloadButton = qt.QPushButton("Reload (just development)")
            self.reloadButton.toolTip = "Reload this module (for development purposes)."
            self.reloadButton.name = "Reload"
            self.layout.addWidget(self.reloadButton)
            self.reloadButton.connect('clicked()', self.onReload)

        # Add vertical spacer
        self.layout.addStretch(1)


        # Connections
        self.rbgStudy.connect("buttonClicked (QAbstractButton*)", self.onRbStudyClicked)
        self.txtOtherStudy.connect("textEdited (QString)", self.onTxtOtherStudyEdited)
        self.rbgConnectionType.connect("buttonClicked (QAbstractButton*)", self.onRbgConnectionType)         
        
        self.storagePathButton.connect("directorySelected(QString)", self.onTmpDirChanged)
        self.cleanCacheButton.connect('clicked (bool)', self.onCleanCacheButtonClicked)
示例#24
0
    def setup(self):

        ScriptedLoadableModuleWidget.setup(self)

        # Instantiate and connect widgets ...

        ### Parameters Area
        inputCollapsibleButton = ctk.ctkCollapsibleButton()
        inputCollapsibleButton.text = "Input"
        self.layout.addWidget(inputCollapsibleButton)

        # Layout within the dummy collapsible button
        inputFormLayout = qt.QFormLayout(inputCollapsibleButton)

        # fixed landmarks (mrml input)
        self.fixedLandmarks = slicer.qMRMLNodeComboBox()
        self.fixedLandmarks.nodeTypes = ["vtkMRMLMarkupsFiducialNode"]
        self.fixedLandmarks.selectNodeUponCreation = True
        self.fixedLandmarks.addEnabled = False
        self.fixedLandmarks.removeEnabled = False
        self.fixedLandmarks.noneEnabled = True
        self.fixedLandmarks.showHidden = False
        self.fixedLandmarks.renameEnabled = True
        self.fixedLandmarks.setMRMLScene(slicer.mrmlScene)
        self.fixedLandmarks.setToolTip("Landmarks on fixed image.")
        inputFormLayout.addRow("Fixed landmarks: ", self.fixedLandmarks)

        # fixed landmarks (directory input)
        self.fixedLandmarksDirectory = ctk.ctkDirectoryButton()
        self.fixedLandmarksDirectory.directory = qt.QDir.homePath()
        inputFormLayout.addRow("", self.fixedLandmarksDirectory)

        # moving landmarks (mrml input)
        self.movingLandmarks = slicer.qMRMLNodeComboBox()
        self.movingLandmarks.nodeTypes = ["vtkMRMLMarkupsFiducialNode"]
        self.movingLandmarks.selectNodeUponCreation = True
        self.movingLandmarks.addEnabled = False
        self.movingLandmarks.removeEnabled = False
        self.movingLandmarks.noneEnabled = True
        self.movingLandmarks.showHidden = False
        self.movingLandmarks.showChildNodeTypes = False
        self.movingLandmarks.setMRMLScene(slicer.mrmlScene)
        self.movingLandmarks.setToolTip("Landmarks on moving image.")
        inputFormLayout.addRow("Moving landmarks: ", self.movingLandmarks)

        self.view = qt.QTableView()
        self.view.sortingEnabled = True
        self.parent.layout().addWidget(self.view)

        # moving landmarks (directory input)
        self.movingLandmarksDirectory = ctk.ctkDirectoryButton()
        self.movingLandmarksDirectory.directory = qt.QDir.homePath()
        inputFormLayout.addRow("", self.movingLandmarksDirectory)

        # Apply Button
        self.applyButton = qt.QPushButton("Apply")
        self.applyButton.toolTip = "Run the algorithm."
        self.applyButton.enabled = True
        self.layout.addWidget(self.applyButton)

        ### Output Area
        outputCollapsibleButton = ctk.ctkCollapsibleButton()
        outputCollapsibleButton.text = "Output statistics"
        self.layout.addWidget(outputCollapsibleButton)

        # Layout within the dummy collapsible button
        outputFormLayout = qt.QFormLayout(outputCollapsibleButton)

        # output statistics
        buttonLayout = qt.QHBoxLayout()
        self.averageError = qt.QLineEdit()
        self.averageErrorValue = 1
        self.averageError.setToolTip("Average landmark separation")
        buttonLayout.addWidget(self.averageError)
        outputFormLayout.addRow("Average error:", buttonLayout)

        buttonLayout = qt.QHBoxLayout()
        self.Variance = qt.QLineEdit()
        self.VarianceValue = 1
        self.Variance.setToolTip("Variance")
        buttonLayout.addWidget(self.Variance)
        outputFormLayout.addRow("Variance:", buttonLayout)

        buttonLayout = qt.QHBoxLayout()
        self.stDev = qt.QLineEdit()
        self.stDevValue = 1
        self.stDev.setToolTip("Standard deviation")
        buttonLayout.addWidget(self.stDev)
        outputFormLayout.addRow("Standard deviation:", buttonLayout)

        # model and view for stats table
        self.view = qt.QTableView()
        self.view.sortingEnabled = True
        self.parent.layout().addWidget(self.view)

        # connections
        self.fixedLandmarks.connect("currentNodeChanged(vtkMRMLNode*)", self.onFixedLandmarksSelect)
        self.movingLandmarks.connect("currentNodeChanged(vtkMRMLNode*)", self.onMovingLandmarksSelect)
        self.applyButton.connect("clicked(bool)", self.onMismatchErrorApply)
    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 - CT Image
        #
        self.inputSelectorCTImage = slicer.qMRMLNodeComboBox()
        self.inputSelectorCTImage.nodeTypes = ["vtkMRMLScalarVolumeNode"]
        self.inputSelectorCTImage.selectNodeUponCreation = True
        self.inputSelectorCTImage.addEnabled = False
        self.inputSelectorCTImage.removeEnabled = False
        self.inputSelectorCTImage.noneEnabled = False
        self.inputSelectorCTImage.showHidden = False
        self.inputSelectorCTImage.showChildNodeTypes = False
        self.inputSelectorCTImage.setMRMLScene(slicer.mrmlScene)
        self.inputSelectorCTImage.setToolTip(
            "Pick the input to the algorithm.")
        parametersFormLayout.addRow("Reference CT Image: ",
                                    self.inputSelectorCTImage)

        #
        # input volume selector - Spheres label
        #
        self.inputSelectorMaskImg = slicer.qMRMLNodeComboBox()
        self.inputSelectorMaskImg.nodeTypes = ["vtkMRMLLabelMapVolumeNode"]
        self.inputSelectorMaskImg.selectNodeUponCreation = True
        self.inputSelectorMaskImg.addEnabled = False
        self.inputSelectorMaskImg.removeEnabled = False
        self.inputSelectorMaskImg.noneEnabled = False
        self.inputSelectorMaskImg.showHidden = False
        self.inputSelectorMaskImg.showChildNodeTypes = False
        self.inputSelectorMaskImg.setMRMLScene(slicer.mrmlScene)
        self.inputSelectorMaskImg.setToolTip(
            "Pick the input to the algorithm.")
        parametersFormLayout.addRow("Spheres label (CT space): ",
                                    self.inputSelectorMaskImg)

        #
        # input volume selector - MRI Image
        #
        self.inputSelectorMRImage = slicer.qMRMLNodeComboBox()
        self.inputSelectorMRImage.nodeTypes = ["vtkMRMLScalarVolumeNode"]
        self.inputSelectorMRImage.selectNodeUponCreation = True
        self.inputSelectorMRImage.addEnabled = False
        self.inputSelectorMRImage.removeEnabled = False
        self.inputSelectorMRImage.noneEnabled = False
        self.inputSelectorMRImage.showHidden = False
        self.inputSelectorMRImage.showChildNodeTypes = False
        self.inputSelectorMRImage.setMRMLScene(slicer.mrmlScene)
        self.inputSelectorMRImage.setToolTip(
            "Pick the input to the algorithm.")
        parametersFormLayout.addRow("MR Image to analyse: ",
                                    self.inputSelectorMRImage)

        #
        # Output director Button
        #
        label = qt.QLabel('Directory output:')
        self.OutputDirectory = ctk.ctkDirectoryButton()
        self.OutputDirectory.directory = u'//s-grp/grp/Imagerie/CQ/IRM/Resultats_mensuel'
        self.OutputDirectory.caption = 'Output directory'
        parametersFormLayout.addRow(label, self.OutputDirectory)

        #
        # Registration Button
        #
        self.RegistrationButton = qt.QPushButton("1) Registration")
        self.RegistrationButton.toolTip = "Run the algorithm."
        self.RegistrationButton.enabled = False
        parametersFormLayout.addRow(self.RegistrationButton)

        #
        # Geometric distorsion Button
        #
        self.GeoDistorsionButton = qt.QPushButton(
            "2A) Geometric distorsion analysis")
        self.GeoDistorsionButton.toolTip = "Run the geometric distorsion algorithm."
        self.GeoDistorsionButton.enabled = False
        parametersFormLayout.addRow(self.GeoDistorsionButton)

        #
        # input volume selector - geometric distorsion result volume
        #
        self.inputSelectorGeoDistorsionResult = slicer.qMRMLNodeComboBox()
        self.inputSelectorGeoDistorsionResult.nodeTypes = [
            "vtkMRMLScalarVolumeNode"
        ]
        self.inputSelectorGeoDistorsionResult.selectNodeUponCreation = True
        self.inputSelectorGeoDistorsionResult.addEnabled = False
        self.inputSelectorGeoDistorsionResult.removeEnabled = False
        self.inputSelectorGeoDistorsionResult.noneEnabled = True
        self.inputSelectorGeoDistorsionResult.showHidden = False
        self.inputSelectorGeoDistorsionResult.showChildNodeTypes = False
        self.inputSelectorGeoDistorsionResult.setMRMLScene(slicer.mrmlScene)
        self.inputSelectorGeoDistorsionResult.setToolTip(
            "Pick the input to the algorithm.")
        parametersFormLayout.addRow(
            "Geometric distorsion result image (only for testing, let it in none): ",
            self.inputSelectorGeoDistorsionResult)

        #
        # Show 3D Geometric distorsion Button
        #
        self.Show3DGeoDistorsionButton = qt.QPushButton(
            "2B) Show 3D Geometric distorsion results")
        self.Show3DGeoDistorsionButton.toolTip = "Run the Show3D algorithm."
        self.Show3DGeoDistorsionButton.enabled = True
        parametersFormLayout.addRow(self.Show3DGeoDistorsionButton)

        #
        # SNR Button
        #
        self.SNRButton = qt.QPushButton("3) Signal to Noise Ratio analysis")
        self.SNRButton.toolTip = "Run the SNR algorithm."
        self.SNRButton.enabled = True
        parametersFormLayout.addRow(self.SNRButton)

        #
        # Signal Linearity Button
        #
        self.SignalLinearityButton = qt.QPushButton(
            "4) Signal Linearity analysis")
        self.SignalLinearityButton.toolTip = "Run the analysis of the mean signal in the principales spheres."
        self.SignalLinearityButton.enabled = True
        parametersFormLayout.addRow(self.SignalLinearityButton)

        # connections
        self.RegistrationButton.connect('clicked(bool)',
                                        self.onRegistrationButton)
        self.SNRButton.connect('clicked(bool)', self.onSNRButton)
        self.SignalLinearityButton.connect('clicked(bool)',
                                           self.onSignalLinearityButton)
        self.GeoDistorsionButton.connect('clicked(bool)',
                                         self.onGeoDistorsionButton)
        self.Show3DGeoDistorsionButton.connect(
            'clicked(bool)', self.onShow3DGeoDistorsionButton)
        self.inputSelectorCTImage.connect("currentNodeChanged(vtkMRMLNode*)",
                                          self.onSelect)
        self.inputSelectorMaskImg.connect("currentNodeChanged(vtkMRMLNode*)",
                                          self.onSelect)
        self.inputSelectorMRImage.connect("currentNodeChanged(vtkMRMLNode*)",
                                          self.onSelect)
        self.inputSelectorGeoDistorsionResult.connect(
            "currentNodeChanged(vtkMRMLNode*)", self.onSelect)
        self.OutputDirectory.connect("Output directory)", self.onSelect)

        # Add vertical spacer
        self.layout.addStretch(1)

        # Refresh regsitration and SNR buttons state
        self.onSelect()
示例#26
0
    def setup(self):

        w = qt.QWidget()
        layout = qt.QGridLayout()
        w.setLayout(layout)
        self.layout.addWidget(w)
        w.show()
        self.layout = layout

        ####################IMPORTAR VOLUMEN 4D#################################################3

        ### Se crea la sección para cargar el volumen 4D en una pestaña desplegable
        importDataCollapsibleButton = ctk.ctkCollapsibleButton()
        importDataCollapsibleButton.text = "Import Data"
        self.layout.addWidget(importDataCollapsibleButton)

        importDataFormLayout = qt.QFormLayout(importDataCollapsibleButton)

        #### Crear desplegable para seleccionar dirección del volumen
        self.__fDialog = ctk.ctkDirectoryButton()
        self.__fDialog.caption = 'Input directory'
        importDataFormLayout.addRow('Input directory:', self.__fDialog)

        ###Selector de volumen donde se guardara el volumen de la direccion
        self.outputSelector = slicer.qMRMLNodeComboBox()
        self.outputSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
        self.outputSelector.addEnabled = True  # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
        self.outputSelector.removeEnabled = False  # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
        self.outputSelector.setMRMLScene(slicer.mrmlScene)
        importDataFormLayout.addRow("Output node:", self.outputSelector)
        self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
                            self.outputSelector, 'setMRMLScene(vtkMRMLScene*)')

        ### Parametros avanzados

        self.__dicomTag = qt.QLineEdit()
        self.__dicomTag.text = 'NA'
        importDataFormLayout.addRow('Frame identifying DICOM tag:',
                                    self.__dicomTag)

        self.__veLabel = qt.QLineEdit()
        self.__veLabel.text = 'na'
        importDataFormLayout.addRow('Frame identifying units:', self.__veLabel)

        self.__veInitial = qt.QDoubleSpinBox()
        self.__veInitial.value = 0
        importDataFormLayout.addRow('Initial value:', self.__veInitial)

        self.__veStep = qt.QDoubleSpinBox()
        self.__veStep.value = 1
        importDataFormLayout.addRow('Step:', self.__veStep)

        self.__te = qt.QDoubleSpinBox()
        self.__te.value = 1
        importDataFormLayout.addRow('EchoTime:', self.__te)

        self.__tr = qt.QDoubleSpinBox()
        self.__tr.value = 1
        importDataFormLayout.addRow('RepetitionTime:', self.__tr)

        self.__fa = qt.QDoubleSpinBox()
        self.__fa.value = 1
        importDataFormLayout.addRow('FlipAngle:', self.__fa)

        # Botón de importar

        self.buttonImport = qt.QPushButton("Import")
        self.buttonImport.toolTip = "Run the algorithm."
        ##self.buttonImport.enabled = True
        importDataFormLayout.addRow("                                       ",
                                    self.buttonImport)

        self.buttonImport.connect('clicked(bool)', self.importFunction)
        ##self.inputSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onSelect)

        ###########################REGISTRO##########################################

        ##    # Se crea una sección de parámetros en una pestaña desplegable
        registerCollapsibleButton = ctk.ctkCollapsibleButton()
        registerCollapsibleButton.text = "Register"
        self.layout.addWidget(registerCollapsibleButton)

        registerFormLayout = qt.QFormLayout(registerCollapsibleButton)

        #Se crea una ventana desplegable en la cual se ingresa el volumen 4D de
        #entrada que se quiere registrar, este volumen debe ser de tipo
        #"vtkMRMLMultiVolumeNode", además si se tienen varios multivolumenes cargados
        #se puede elegir entre ellos el que se desea registrar
        self.inputRegSelector = slicer.qMRMLNodeComboBox()
        self.inputRegSelector.nodeTypes = ["vtkMRMLMultiVolumeNode"]
        self.inputRegSelector.selectNodeUponCreation = True
        self.inputRegSelector.addEnabled = True
        self.inputRegSelector.removeEnabled = False
        self.inputRegSelector.noneEnabled = True
        self.inputRegSelector.showHidden = False
        self.inputRegSelector.showChildNodeTypes = False
        self.inputRegSelector.setMRMLScene(slicer.mrmlScene)
        self.inputRegSelector.setToolTip("Pick the input to the algorithm.")
        registerFormLayout.addRow("Volumen 4D: ", self.inputRegSelector)
        self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
                            self.inputRegSelector,
                            'setMRMLScene(vtkMRMLScene*)')

        ###Selector de volumen donde se guardara el volumen de la direccion
        self.outputRegSelector = slicer.qMRMLNodeComboBox()
        self.outputRegSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
        self.outputRegSelector.addEnabled = True  # Se habilita la posibildad al usuario de crear un nuevo nodo con este widget
        self.outputRegSelector.removeEnabled = False  # Se le quita al usuario la posibilidad de eliminar el nodo seleccionado en ese momento
        self.outputRegSelector.setMRMLScene(slicer.mrmlScene)
        registerFormLayout.addRow("Output node:", self.outputRegSelector)
        self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)',
                            self.outputRegSelector,
                            'setMRMLScene(vtkMRMLScene*)')

        # Botón de Registro
        #Este botón solo se activa si el multivolumen ha sido seleccionado en la
        #ventana desplegable de Volumen 4D. Al presionarlo, el algoritmo
        #realiza el registro de los diferentes volumenes en el volumen 4D
        self.applyButton = qt.QPushButton("Registrar")
        self.applyButton.toolTip = "Run the algorithm."
        self.applyButton.enabled = True
        registerFormLayout.addRow(self.applyButton)

        # Conexiones necesarias para el algoritmo
        #entrega al algoritmo el volumen 4D de entrada y conecta la función del botón
        #con la ejecución del registro
        self.applyButton.connect('clicked(bool)', self.registrarButton)
示例#27
0
  def setup(self):

    ScriptedLoadableModuleWidget.setup(self)

    # Instantiate and connect widgets ...

    ### Input Area
    inputCollapsibleButton = ctk.ctkCollapsibleButton()
    inputCollapsibleButton.text = "Input"
    self.layout.addWidget(inputCollapsibleButton)

    # Layout within the dummy collapsible button
    inputFormLayout = qt.QFormLayout(inputCollapsibleButton)

    # vf image (mrml input)
    self.vfMRMLSelector = slicer.qMRMLNodeComboBox()
    self.vfMRMLSelector.nodeTypes = ["vtkMRMLVectorVolumeNode"]
    self.vfMRMLSelector.selectNodeUponCreation = True
    self.vfMRMLSelector.addEnabled = False
    self.vfMRMLSelector.removeEnabled = False
    self.vfMRMLSelector.noneEnabled = True
    self.vfMRMLSelector.showHidden = False
    self.vfMRMLSelector.setMRMLScene( slicer.mrmlScene )
    self.vfMRMLSelector.setToolTip( "Pick the input to the algorithm." )
    inputFormLayout.addRow("Vector Field image: ", self.vfMRMLSelector)

    # variables
    self.minJacobianValue = 1
    self.maxJacobianValue = 1

    # vf image (directory input)
    self.vfInputDirectory = ctk.ctkDirectoryButton()
    self.vfInputDirectory.directory = qt.QDir.homePath()
    inputFormLayout.addRow("Input Directory:", self.vfInputDirectory)

    # Fixed image (for geometry info)
    self.fixedImage = slicer.qMRMLNodeComboBox()
    self.fixedImage.nodeTypes = ["vtkMRMLScalarVolumeNode"]
    self.fixedImage.setMRMLScene( slicer.mrmlScene )
    self.fixedImage.selectNodeUponCreation = True
    self.fixedImage.addEnabled = False
    self.fixedImage.renameEnabled = True
    self.fixedImage.noneEnabled = True
    self.fixedImage.setToolTip( "Output image of Jacobian matrix.vtkSlicerPlastimatchModuleLogicPython" )
    inputFormLayout.addRow("Fixed image (for geometry info): ", self.fixedImage)

    # Apply Button
    self.applyButton = qt.QPushButton("Apply")
    self.applyButton.toolTip = "Run the algorithm."
    self.applyButton.enabled = True
    self.layout.addWidget(self.applyButton)
    
    ### Output Area
    outputCollapsibleButton = ctk.ctkCollapsibleButton()
    outputCollapsibleButton.text = "Output"
    self.layout.addWidget(outputCollapsibleButton)

    # Layout within the dummy collapsible button
    outputFormLayout = qt.QFormLayout(outputCollapsibleButton)

    # Jacobian image (mrml output)
    self.outputJacobian = slicer.qMRMLNodeComboBox()
    self.outputJacobian.nodeTypes = ["vtkMRMLScalarVolumeNode"]
    self.outputJacobian.setMRMLScene( slicer.mrmlScene )
    self.outputJacobian.addEnabled = True
    self.outputJacobian.renameEnabled = True
    #self.outputJacobian.layout().addWidget(self.outputSelector)
    self.outputJacobian.setToolTip( "Output image of Jacobian matrix.vtkSlicerPlastimatchModuleLogicPython" )
    outputFormLayout.addRow("Jacobian image: ", self.outputJacobian)

    # output directory selector
#    self.outputDirectory = ctk.ctkDirectoryButton()
#    self.outputDirectory.directory = qt.QDir.homePath()
#    outputFormLayout.addRow("Output Directory: ", self.outputDirectory)
    
    # output statistics
    buttonLayout = qt.QHBoxLayout()
    self.minJacobian = qt.QLineEdit()
    self.minJacobian.setToolTip( "Minimum value of Jacobian matrix" ) 
    buttonLayout.addWidget(self.minJacobian)
    outputFormLayout.addRow("Minimum Jacobian:", buttonLayout)

    buttonLayout = qt.QHBoxLayout()
    self.maxJacobian = qt.QLineEdit()
    self.maxJacobian.setToolTip( "Maximum value of Jacobian matrix" ) 
    buttonLayout.addWidget(self.maxJacobian)
    outputFormLayout.addRow("Maximum Jacobian:", buttonLayout)    

    # connections
    self.applyButton.connect('clicked(bool)', self.onJacobianApply)
    self.outputJacobian.connect("currentNodeChanged(vtkMRMLNode*)", self.onOutputJacobianSelect)
    self.fixedImage.connect("currentNodeChanged(vtkMRMLNode*)", self.onFixedImageSelect)
    self.vfMRMLSelector.connect("currentNodeChanged(vtkMRMLNode*)", self.onvfMRMLSelect)

    # Add vertical spacer
    self.layout.addStretch(1)
  def setup(self):
    # Instantiate and connect widgets ...

    # Collapsible button
    dummyCollapsibleButton = ctk.ctkCollapsibleButton()
    dummyCollapsibleButton.text = "Basic settings"
    self.layout.addWidget(dummyCollapsibleButton)
    dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)

    # add input directory selector
    label = qt.QLabel('Input directory:')
    self.__fDialog = ctk.ctkDirectoryButton()
    self.__fDialog.caption = 'Input DICOM directory'
    dummyFormLayout.addRow(label, self.__fDialog)

    label = qt.QLabel('Output node:')
    self.__mvSelector = slicer.qMRMLNodeComboBox()
    self.__mvSelector.nodeTypes = ['vtkMRMLMultiVolumeNode']
    self.__mvSelector.setMRMLScene(slicer.mrmlScene)
    self.__mvSelector.connect('mrmlSceneChanged(vtkMRMLScene*)', self.onMRMLSceneChanged)
    self.__mvSelector.addEnabled = 1
    dummyFormLayout.addRow(label, self.__mvSelector)

    label = qt.QLabel('Input data type:')
    self.__modeSelector = qt.QComboBox()

    # parameter tuples: long title (for the selector), dicom tag, units, short title
    self.__processingModes = []
    self.__processingModes.append(['DICOM 4D DCE MRI (GE)', '0018|1060', 'ms', 'DCE'])
    self.__processingModes.append(['DICOM variable TE MRI (GE)', '0018|0081', 'ms', 'vTE'])
    self.__processingModes.append(['DICOM variable FA MRI (GE)', '0018|1314', 'deg', 'vFA'])
    self.__processingModes.append(['DICOM variable TR MRI (GE)', '0018|0080', 'ms', 'vTR'])
    self.__processingModes.append(['User-defined DICOM', '??', '??', 'MultiVolumeDICOM'])
    self.__processingModes.append(['User-defined non-DICOM', 'N/A', '??', 'MultiVolume'])

    for p in self.__processingModes:
      print("Processing mode found: %s" % p)
      self.__modeSelector.addItem(p[0])
    self.__modeSelector.currentIndex = 0

    self.__modeSelector.connect('currentIndexChanged(int)', self.onProcessingModeChanged)
    dummyFormLayout.addRow(label, self.__modeSelector)

    # Collapsible button
    dummyCollapsibleButton = ctk.ctkCollapsibleButton()
    dummyCollapsibleButton.text = "Advanced settings"
    dummyCollapsibleButton.collapsed = 1
    self.layout.addWidget(dummyCollapsibleButton)
    dummyFormLayout = qt.QFormLayout(dummyCollapsibleButton)
    self.__advancedFrame = dummyCollapsibleButton

    # label name and values
    label = qt.QLabel('DICOM tag:')
    label.toolTip = 'DICOM tag used to separate individual volumes in the series'
    self.__dicomTag = qt.QLineEdit()
    self.__dicomTag.text = ""
    dummyFormLayout.addRow(label, self.__dicomTag)

    label = qt.QLabel('Frame identifying units:')
    self.__veLabel = qt.QLineEdit()
    dummyFormLayout.addRow(label, self.__veLabel)

    label = qt.QLabel('Initial value:')
    self.__veInitial = qt.QDoubleSpinBox()
    self.__veInitial.value = 0
    dummyFormLayout.addRow(label, self.__veInitial)

    label = qt.QLabel('Step:')
    self.__veStep = qt.QDoubleSpinBox()
    self.__veStep.value = 1
    dummyFormLayout.addRow(label, self.__veStep)

    importButton = qt.QPushButton("Import")
    importButton.toolTip = "Import the contents of the DICOM directory as a MultiVolume"
    self.layout.addWidget(importButton)
    importButton.connect('clicked(bool)', self.onImportButtonClicked)

    self.__status = qt.QLabel('Status: Idle')
    self.layout.addWidget(self.__status)

    # Add vertical spacer
    self.layout.addStretch(1)
  def 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 = "Freehand3DUltrasound 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)
 
    # IGTLink Connector
    connectorCollapsibleButton = ctk.ctkCollapsibleButton()
    connectorCollapsibleButton.text = "OpenIGTLink Settings"
    self.layout.addWidget(connectorCollapsibleButton)    
    self.parametersVBoxLayout = qt.QVBoxLayout(connectorCollapsibleButton)    
    self.connectorWidget = qt.QWidget()
    self.parametersVBoxLayout.addWidget(self.connectorWidget)
    self.connectorLayout = qt.QFormLayout(self.connectorWidget)    
    
    self.linkInputSelector = slicer.qMRMLNodeComboBox()
    self.linkInputSelector.nodeTypes = ( ("vtkMRMLIGTLConnectorNode"), "" )
    self.linkInputSelector.selectNodeUponCreation = True
    self.linkInputSelector.addEnabled = True 
    self.linkInputSelector.removeEnabled = True
    self.linkInputSelector.noneEnabled = False
    self.linkInputSelector.showHidden = False
    self.linkInputSelector.showChildNodeTypes = False
    self.linkInputSelector.setMRMLScene( slicer.mrmlScene )
    self.linkInputSelector.setToolTip( "Pick connector node" )
    self.connectorLayout.addRow("PlusServer Connector: ", self.linkInputSelector)    

    self.igtLinkWidget = qt.QWidget()
    self.igtLinkWidget.enabled = False
    self.parametersVBoxLayout.addWidget(self.igtLinkWidget)
    self.igtLinkHBoxLayout = qt.QHBoxLayout(self.igtLinkWidget)
    self.hostNameLabel = qt.QLabel("Host Name:")
    self.igtLinkHBoxLayout.addWidget(self.hostNameLabel)
    self.hostNameLineEdit = qt.QLineEdit("localhost")
    self.igtLinkHBoxLayout.addWidget(self.hostNameLineEdit)
    self.portLabel = qt.QLabel(" Port:")
    self.igtLinkHBoxLayout.addWidget(self.portLabel)
    self.portLineEdit = qt.QLineEdit("18944")
    self.portLineEdit.setMaximumWidth(60)
    self.igtLinkHBoxLayout.addWidget(self.portLineEdit)
    self.statusLabel = qt.QLabel(" Active:")
    self.igtLinkHBoxLayout.addWidget(self.statusLabel)
    self.linkStatusCheckBox= qt.QCheckBox(" ")
    self.igtLinkHBoxLayout.addWidget(self.linkStatusCheckBox)

    #
    # Reconstruction Area
    #
    reconstructionCollapsibleButton = ctk.ctkCollapsibleButton()
    reconstructionCollapsibleButton.text = "Record and Reconstruction"
    self.layout.addWidget(reconstructionCollapsibleButton)

    # Layout within the dummy collapsible button
    reconstructionVBoxLayout = qt.QVBoxLayout(reconstructionCollapsibleButton)
    
    # Input Tracker node selector
    #
    inputImageTrackerWidget = qt.QWidget()
    reconstructionVBoxLayout.addWidget(inputImageTrackerWidget)
    inputImageTrackerQFormLayout = qt.QFormLayout(inputImageTrackerWidget)
    
    self.inputImageTrackerNodeSelector = slicer.qMRMLNodeComboBox()
    self.inputImageTrackerNodeSelector.nodeTypes = ['vtkMRMLLinearTransformNode']
    self.inputImageTrackerNodeSelector.selectNodeUponCreation = True
    self.inputImageTrackerNodeSelector.addEnabled = False
    self.inputImageTrackerNodeSelector.removeEnabled = False
    self.inputImageTrackerNodeSelector.noneEnabled = True
    self.inputImageTrackerNodeSelector.showHidden = False
    self.inputImageTrackerNodeSelector.showChildNodeTypes = False
    self.inputImageTrackerNodeSelector.setMRMLScene( slicer.mrmlScene )
    self.inputImageTrackerNodeSelector.objectName = 'inputImageTrackerNodeSelector'
    self.inputImageTrackerNodeSelector.toolTip = "Select the tracker linear transform node."
    #inputImageTrackerNodeSelector.connect('currentNodeChanged(bool)', self.enableOrDisableCreateButton)
    inputImageTrackerQFormLayout.addRow( 'Image Transform Node:',self.inputImageTrackerNodeSelector)
    #self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', inputImageTrackerNodeSelector, 'setMRMLScene(vtkMRMLScene*)')

    #
    # ROI Node Selector
    #
    self.inputROINodeSelector = slicer.qMRMLNodeComboBox()
    self.inputROINodeSelector.enabled = True
    self.inputROINodeSelector.addEnabled = True
    self.inputROINodeSelector.removeEnabled = True
    self.inputROINodeSelector.setMRMLScene( slicer.mrmlScene)
    self.inputROINodeSelector.nodeTypes = ['vtkMRMLAnnotationROINode']
    inputImageTrackerQFormLayout.addRow( 'Reconstruction ROI:',self.inputROINodeSelector)
    #
    # Icons 
    #
    self.statusRedIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/icon_DotRed.png')
    self.statusGreenIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/icon_DotGreen.png')
    self.connectIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/connect.png')
    self.disconnectIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/disconnect.png')
    self.recordIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/icon_Record.png')
    self.pauseIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/icon_pause.png')
    self.stopIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/icon_stop.png')
    self.snapshotIcon = qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/snapshot.png')
    self.deleteIcon= qt.QIcon(self.freehand3DUltrasoundDirectoryPath+'/Resources/Icons/delete.png')
    
    #
    # reconstruction and recording buttons
    self.recordAndReconstructionWidget = qt.QWidget()
    self.recordAndReconstructionWidget.enabled = False
    reconstructionVBoxLayout.addWidget(self.recordAndReconstructionWidget)
    recordAndReconstructionHBoxLayout = qt.QHBoxLayout(self.recordAndReconstructionWidget)
     
    self.startButton = qt.QPushButton("")
    buttonSize = 35 
    iconSize = qt.QSize(25,25)
    #self.startButton.toolTip = "Tracker Status"
    self.startButton.enabled = True 
    self.startButton.setIcon(self.recordIcon)
    self.startButton.checkable = True
    self.startButton.setMinimumHeight(buttonSize)
    self.startButton.setIconSize(iconSize)
    self.startButton.setMinimumWidth(buttonSize)
    self.startButton.setMaximumWidth(buttonSize)
    recordAndReconstructionHBoxLayout.addWidget(self.startButton)
  
    self.pauseButton = qt.QPushButton("")
    #self.pauseButton.toolTip = "Tracker Status"
    self.pauseButton.enabled = False 
    self.pauseButton.checkable = True
    self.pauseButton.setIcon(self.pauseIcon)
    self.pauseButton.setMinimumHeight(buttonSize)
    self.pauseButton.setIconSize(iconSize)
    self.pauseButton.setMinimumWidth(buttonSize)
    self.pauseButton.setMaximumWidth(buttonSize)
    recordAndReconstructionHBoxLayout.addWidget(self.pauseButton)       
 
    self.snapshotButton = qt.QPushButton("")
    #self.snapshotButton.toolTip = "Tracker Status"
    self.snapshotButton.enabled = False 
    self.snapshotButton.setIcon(self.snapshotIcon)
    recordAndReconstructionHBoxLayout.addWidget(self.snapshotButton)
    self.snapshotButton.setMinimumHeight(buttonSize)
    self.snapshotButton.setIconSize(iconSize)
    self.snapshotButton.setMinimumWidth(buttonSize)
    self.snapshotButton.setMaximumWidth(buttonSize)
 
    self.deleteButton = qt.QPushButton("")
    #self.deleteButton.toolTip = "Tracker Status"
    self.deleteButton.enabled = False 
    self.deleteButton.setIcon(self.deleteIcon)
    self.deleteButton.setMinimumHeight(buttonSize)
    self.deleteButton.setIconSize(iconSize)
    self.deleteButton.setMinimumWidth(buttonSize)
    self.deleteButton.setMaximumWidth(buttonSize)
    recordAndReconstructionHBoxLayout.addWidget(self.deleteButton)
    #recordAndReconstructionHBoxLayout.addStretch(1)

    self.statusButton = qt.QPushButton("")
    #self.startButton.toolTip = "Tracker Status"
    self.statusButton.enabled = False 
    self.statusButton.setIcon(self.disconnectIcon)
    self.statusButton.setIconSize(iconSize)
    self.statusButton.setMinimumHeight(buttonSize)
    self.statusButton.setMaximumWidth(buttonSize)
    self.statusButton.setMinimumWidth(buttonSize)
    recordAndReconstructionHBoxLayout.addWidget(self.statusButton)

    #
    # Display Area
    #
    displayCollapsibleButton = ctk.ctkCollapsibleButton()
    displayCollapsibleButton.text = "Display"
    self.layout.addWidget(displayCollapsibleButton)

    # Layout within the dummy collapsible button
    displayVBoxLayout = qt.QVBoxLayout(displayCollapsibleButton)
   
    volumesWidget = qt.QWidget()
    displayVBoxLayout.addWidget(volumesWidget)
    volumesFormLayout = qt.QFormLayout(volumesWidget)
    #
    # base volume node selector 
    #
    self.baseVolumeNodeSelector = slicer.qMRMLNodeComboBox()
    self.baseVolumeNodeSelector.setMRMLScene( slicer.mrmlScene)
    self.baseVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
    volumesFormLayout.addRow( 'Base Volume (MR/CT):',self.baseVolumeNodeSelector)
    #
    # reconstructed volume node selector 
    #
    self.reconstructedVolumeNodeSelector = slicer.qMRMLNodeComboBox()
    self.reconstructedVolumeNodeSelector.setMRMLScene( slicer.mrmlScene)
    self.reconstructedVolumeNodeSelector.nodeTypes = ['vtkMRMLScalarVolumeNode']
    volumesFormLayout.addRow( 'Reconstructed Volume:',self.reconstructedVolumeNodeSelector)
    #
    # Pointer Transform Node Selector
    #
    self.pointerTransformNodeSelector = slicer.qMRMLNodeComboBox()
    self.pointerTransformNodeSelector.nodeTypes = ['vtkMRMLLinearTransformNode']
    self.pointerTransformNodeSelector.selectNodeUponCreation = True
    self.pointerTransformNodeSelector.addEnabled = False
    self.pointerTransformNodeSelector.removeEnabled = False
    self.pointerTransformNodeSelector.noneEnabled = True
    self.pointerTransformNodeSelector.showHidden = False
    self.pointerTransformNodeSelector.showChildNodeTypes = False
    self.pointerTransformNodeSelector.setMRMLScene( slicer.mrmlScene )
    self.pointerTransformNodeSelector.objectName = 'pointerTransformNodeSelector'
    self.pointerTransformNodeSelector.toolTip = "Select the tracker linear transform node."
    #pointerTransformNodeSelector.connect('currentNodeChanged(bool)', self.enableOrDisableCreateButton)
    volumesFormLayout.addRow( 'Pointer Transform Node:',self.pointerTransformNodeSelector)
    #self.parent.connect('mrmlSceneChanged(vtkMRMLScene*)', pointerTransformNodeSelector, 'setMRMLScene(vtkMRMLScene*)')

    #
    # Display Mode Group Buttons
    #
    displayModesWidget = qt.QWidget()
    displayVBoxLayout.addWidget(displayModesWidget)
    displayModesHBoxLayout = qt.QHBoxLayout(displayModesWidget)

    displayGroup = qt.QButtonGroup(volumesWidget)
    displayModeLabel = qt.QLabel("Display Mode: ")
    displayModesHBoxLayout.addWidget(displayModeLabel)
    self.mode1RadioButton = qt.QRadioButton("1- Recording")
    displayGroup.addButton(self.mode1RadioButton)
    self.mode2RadioButton = qt.QRadioButton("2- Pointer")
    displayGroup.addButton(self.mode2RadioButton)
    self.mode3RadioButton = qt.QRadioButton("3- Reslicing off")
    displayGroup.addButton(self.mode3RadioButton)
    displayModesHBoxLayout.addWidget(self.mode1RadioButton)
    displayModesHBoxLayout.addWidget(self.mode2RadioButton)
    displayModesHBoxLayout.addWidget(self.mode3RadioButton)
    displayModesHBoxLayout.addStretch(1)

    #
    # Settings Area
    #
    self.settingsCollapsibleButton = ctk.ctkCollapsibleButton()
    self.settingsCollapsibleButton.text = "Settings"
    self.layout.addWidget(self.settingsCollapsibleButton)

    # Layout within the dummy collapsible button
    settingsVBoxLayout = qt.QVBoxLayout(self.settingsCollapsibleButton)
   
    pathWidget = qt.QWidget()
    settingsVBoxLayout.addWidget(pathWidget)
    pathFormLayout = qt.QFormLayout(pathWidget)

    self.directoryButton = ctk.ctkDirectoryButton()
    pathFormLayout.addRow("Output Directory: ", self.directoryButton)
 
    #
    # Record and Reconstruction Parameters 
    #
    recordOptionsWidget = qt.QWidget()
    settingsVBoxLayout.addWidget(recordOptionsWidget)
    recordOptionsHBoxLayout = qt.QHBoxLayout(recordOptionsWidget)

    recordOptionsLabel = qt.QLabel("Options: ")
    recordOptionsHBoxLayout.addWidget(recordOptionsLabel)
    self.onlineReconstructionCheckBox = qt.QCheckBox("Online Reconstruction")
    self.onlineReconstructionCheckBox.checked = True
    self.recordTrackedFramesCheckBox = qt.QCheckBox("Record Tracked Frames")
    self.recordTrackedFramesCheckBox.checked = True
    self.probeSweepGuideCheckBox = qt.QCheckBox("Probe Sweep Guide")
    self.probeSweepGuideCheckBox.checked = True
    recordOptionsHBoxLayout.addWidget(self.onlineReconstructionCheckBox)
    recordOptionsHBoxLayout.addWidget(self.recordTrackedFramesCheckBox)
    recordOptionsHBoxLayout.addWidget(self.probeSweepGuideCheckBox)
    recordOptionsHBoxLayout.addStretch(1)
  
    # Add vertical spacer
    self.layout.addStretch(1)

    #
    # Connections
    #
    self.linkInputSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.setLink)
    self.linkStatusCheckBox.connect('stateChanged(int)',self.onLinkStatusCheckBox)
    self.startButton.connect('toggled(bool)', self.onStartButton)
    self.inputImageTrackerNodeSelector.connect('currentNodeChanged(vtkMRMLNode*)', self.setTransformNode)
    self.deleteButton.connect('clicked(bool)',self.onDeleteButton)
    self.directoryButton.connect('directoryChanged(const QString &)',self.onDirectoryButton)