Initial import

CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(EMBRACE)
+
+#-----------------------------------------------------------------------------
+# Extension meta-information
+set(EXTENSION_HOMEPAGE "http://slicer.org/slicerWiki/index.php/Documentation/Nightly/Extensions/EMBRACE")
+set(EXTENSION_CATEGORY "Examples")
+set(EXTENSION_CONTRIBUTORS "John Doe (AnyWare Corp.)")
+set(EXTENSION_DESCRIPTION "This is an example of a simple extension")
+set(EXTENSION_ICONURL "http://www.example.com/Slicer/Extensions/EMBRACE.png")
+set(EXTENSION_SCREENSHOTURLS "http://www.example.com/Slicer/Extensions/EMBRACE/Screenshots/1.png")
+set(EXTENSION_DEPENDS "NA") # Specified as a space separated string, a list or 'NA' if any
+
+#-----------------------------------------------------------------------------
+# Extension dependencies
+find_package(Slicer REQUIRED)
+include(${Slicer_USE_FILE})
+
+#-----------------------------------------------------------------------------
+# Extension modules
+add_subdirectory(dataExplorer)
+## NEXT_MODULE
+
+#-----------------------------------------------------------------------------
+include(${Slicer_EXTENSION_GENERATE_CONFIG})
+include(${Slicer_EXTENSION_CPACK})

dataExplorer/Testing/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(Python)

dataExplorer/Testing/Python/CMakeLists.txt

@@ -0,0 +1,2 @@
+
+#slicer_add_python_unittest(SCRIPT ${MODULE_NAME}ModuleTest.py)

dataExplorer/dataExplorer.py

@@ -0,0 +1,458 @@
+import os
+import unittest
+import vtk, qt, ctk, slicer
+from slicer.ScriptedLoadableModule import *
+import logging
+import slicerNetwork
+import json
+import loadPatient
+
+#
+# dataExplorer
+#
+
+class dataExplorer(ScriptedLoadableModule):
+  """Uses ScriptedLoadableModule base class, available at:
+  https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/ScriptedLoadableModule.py
+  """
+
+  def __init__(self, parent):
+    ScriptedLoadableModule.__init__(self, parent)
+    self.parent.title = "dataExplorer" # TODO make this more human readable by adding spaces
+    self.parent.categories = ["Examples"]
+    self.parent.dependencies = []
+    self.parent.contributors = ["Andrej Studen (University of Ljubljana)"] # replace with "Firstname Lastname (Organization)"
+    self.parent.helpText = """
+This is an example of scripted loadable module bundled in an extension.
+It performs a simple thresholding on the input volume and optionally captures a screenshot.
+"""
+    self.parent.helpText += self.getDefaultModuleDocumentationLink()
+    self.parent.acknowledgementText = """
+This extension developed within Medical Physics research programe of ARRS
+""" # replace with organization, grant and thanks.
+
+#
+# dataExplorerWidget
+#
+
+class dataExplorerWidget(ScriptedLoadableModuleWidget):
+  """Uses ScriptedLoadableModuleWidget base class, available at:
+  https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/ScriptedLoadableModule.py
+  """
+
+  def setup(self):
+    ScriptedLoadableModuleWidget.setup(self)
+    self.loadPatientLogic=loadPatient.loadPatientLogic(self)
+    # Instantiate and connect widgets ...
+
+    #
+    # Parameters Area
+    #
+    try:
+      self.startDir=os.path.join(os.environ['HOME'],"temp/crt")
+    except:
+      fhome=os.environ['HOMEDRIVE']+os.environ['HOMEPATH']
+      self.startDir=os.path.join(fhome,"temp")
+
+    self.sNet=slicerNetwork.labkeyURIHandler()
+    self.loadPatientLogic.setURIHandler(self.sNet)
+
+    configCollapsibleButton = ctk.ctkCollapsibleButton()
+    configCollapsibleButton.text = "Configuration"
+    self.layout.addWidget(configCollapsibleButton)
+
+    # Layout within the dummy collapsible button
+    configFormLayout = qt.QFormLayout(configCollapsibleButton)
+
+    self.configDir='/afs/f9.ijs.si/home/studen/software/src/embraceParse'
+    self.loadConfigButton=qt.QPushButton("Load Config")
+    self.loadConfigButton.connect('clicked(bool)',self.onLoadConfigButtonClicked)
+    configFormLayout.addRow("Configuration:",self.loadConfigButton)
+
+
+    ## connection sub-area
+
+    connectionCollapsibleButton = ctk.ctkCollapsibleButton()
+    connectionCollapsibleButton.text = "Connection"
+    self.layout.addWidget(connectionCollapsibleButton)
+
+    # Layout within the dummy collapsible button
+    connectionFormLayout = qt.QFormLayout(connectionCollapsibleButton)
+
+    #
+    # input volume selector
+    #
+    self.server=qt.QLineEdit("https://merlin.fmf.uni-lj.si")
+    connectionFormLayout.addRow("Server: ", self.server)
+
+    self.userCertButton=qt.QPushButton("Load")
+    self.userCertButton.toolTip="Load user certificate (crt)"
+    self.userCertButton.connect('clicked(bool)',self.onUserCertButtonClicked)
+    connectionFormLayout.addRow("User certificate:",self.userCertButton)
+
+    self.userKeyButton=qt.QPushButton("Load")
+    self.userKeyButton.toolTip="Load user key (key)"
+    self.userKeyButton.connect('clicked(bool)',self.onUserKeyButtonClicked)
+    connectionFormLayout.addRow("User key:",self.userKeyButton)
+
+    self.userCAButton=qt.QPushButton("Load")
+    self.userCAButton.toolTip="Load CA certificate (crt)"
+    self.userCAButton.connect('clicked(bool)',self.onUserCAButtonClicked)
+    connectionFormLayout.addRow("User certificate:",self.userCAButton)
+
+    self.authName=qt.QLineEdit("email")
+    #self.authName.textChanged.connect(self.updateAuthName)
+    connectionFormLayout.addRow("Labkey username: ", self.authName)
+
+    self.authPass=qt.QLineEdit("email")
+    self.authPass.setEchoMode(qt.QLineEdit.Password)
+    #self.authPass.textChanged.connect(self.updateAuthPass)
+    connectionFormLayout.addRow("Labkey password: ", self.authPass)
+
+    self.initButton=qt.QPushButton("Init")
+    self.initButton.toolTip="Init connection"
+    self.initButton.connect('clicked(bool)',self.onInitButtonClicked)
+    connectionFormLayout.addRow("Connection:",self.initButton)
+
+    # Add vertical spacer
+    self.layout.addStretch(1)
+
+    datasetCollapsibleButton = ctk.ctkCollapsibleButton()
+    datasetCollapsibleButton.text = "Dataset"
+    self.layout.addWidget(datasetCollapsibleButton)
+    # Layout within the dummy collapsible button
+    datasetFormLayout = qt.QFormLayout(datasetCollapsibleButton)
+
+    self.datasetName=qt.QLineEdit("datasetName")
+    datasetFormLayout.addRow("Dataset:",self.datasetName)
+
+    self.datasetProject=qt.QLineEdit("datasetProject")
+    datasetFormLayout.addRow("Project:",self.datasetProject)
+
+    self.datasetButton=qt.QPushButton("Load")
+    self.datasetButton.connect('clicked(bool)',self.onDatasetLoadButtonClicked)
+    datasetFormLayout.addRow("Project:",self.datasetButton)
+
+
+
+    dataCollapsibleButton = ctk.ctkCollapsibleButton()
+    dataCollapsibleButton.text = "Data"
+    self.layout.addWidget(dataCollapsibleButton)
+    # Layout within the dummy collapsible button
+    dataFormLayout = qt.QVBoxLayout(dataCollapsibleButton)
+
+    self.data=qt.QTableWidget(3,3)
+    dataFormLayout.addWidget(self.data)
+
+    patientsCollapsibleButton = ctk.ctkCollapsibleButton()
+    patientsCollapsibleButton.text = "Patients"
+    self.layout.addWidget(patientsCollapsibleButton)
+    # Layout within the dummy collapsible button
+    self.patientsFormLayout = qt.QVBoxLayout(patientsCollapsibleButton)
+    self.signalMapper=qt.QSignalMapper()
+    self.signalMapper.connect(self.signalMapper, qt.SIGNAL("mapped(const QString &)"), self.onPatientButtonClicked)
+
+
+  def cleanup(self):
+    pass
+
+  def onLoadConfigButtonClicked(self):
+      filename=qt.QFileDialog.getOpenFileName(None,'Open configuration file (JSON)',
+           self.configDir, '*.json')
+      with open(filename,'r') as f:
+          dt=json.load(f)
+      if dt.has_key('host'):
+          self.server.setText(dt['host'])
+      if dt.has_key('dataset'):
+          self.datasetName.setText(dt['dataset'])
+      if dt.has_key('project'):
+          self.datasetProject.setText(dt['project'])
+      if dt.has_key('SSL'):
+          if dt['SSL'].has_key('user'):
+              self.userCertButton.setText(dt['SSL']['user'])
+          if dt['SSL'].has_key('key'):
+              self.userKeyButton.setText(dt['SSL']['key'])
+          if dt['SSL'].has_key('keyPwd'):
+              self.keyPwd=dt['SSL']['keyPwd']
+          if dt['SSL'].has_key('ca'):
+              self.userCAButton.setText(dt['SSL']['ca'])
+      if dt.has_key('labkey'):
+          if dt['labkey'].has_key('user'):
+              self.authName.setText(dt['labkey']['user'])
+          if dt['labkey'].has_key('password'):
+              self.authPass.setText(dt['labkey']['password'])
+      self.loadConfigButton.setText(os.path.basename(filename))
+
+  def onUserCertButtonClicked(self):
+     filename=qt.QFileDialog.getOpenFileName(None,'Open user certificate',
+           self.startDir, '*.crt')
+     #pwd=qt.QInputDialog.getText(None,'Certificate password',
+     # 'Enter certificate password',qt.QLineEdit.Password)
+     if not(filename) :
+         print "No file selected"
+         return
+
+     f=qt.QFile(filename)
+     if not (f.open(qt.QIODevice.ReadOnly)) :
+         print "Could not open file"
+         return
+
+     certList=qt.QSslCertificate.fromPath(filename)
+     if len(certList) < 1:
+         print "Troubles parsing {0}".format(filename)
+         return
+
+     cert=qt.QSslCertificate(f)
+     print "cert.isNull()={0}".format(cert.isNull())
+     self.userCertButton.setText(filename)
+     self.authName.setText(cert.subjectInfo("emailAddress"))
+
+  def onUserKeyButtonClicked(self):
+     filename=qt.QFileDialog.getOpenFileName(None,'Open private key',
+           self.startDir, '*.key')
+     if not (filename) :
+         print "No file selected"
+         return
+
+     f=qt.QFile(filename)
+     if not (f.open(qt.QIODevice.ReadOnly)) :
+         print "Could not open file"
+         return
+     self.keyPwd=qt.QInputDialog.getText(None,'Private key password',
+       'Enter key password',qt.QLineEdit.Password)
+
+     key=qt.QSslKey(f,qt.QSsl.Rsa,qt.QSsl.Pem,qt.QSsl.PrivateKey,
+        str(self.keyPwd))
+     self.userKeyButton.setText(filename)
+
+  def onUserCAButtonClicked(self):
+    filename=qt.QFileDialog.getOpenFileName(None,'Open authority certificate',
+             self.startDir, '*.crt')
+    if not(filename) :
+       print "No file selected"
+       return
+
+    f=qt.QFile(filename)
+
+    if not (f.open(qt.QIODevice.ReadOnly)) :
+        print "Could not open file"
+        return
+
+    certList=qt.QSslCertificate.fromPath(filename)
+
+    if len(certList) < 1:
+        print "Troubles parsing {0}".format(filename)
+        return
+
+    #self.logic.caCert=qt.QSslCertificate(f)#certList[0]
+    self.userCAButton.setText(filename)
+
+  def onInitButtonClicked(self):
+      self.sNet.configureSSL(
+        self.userCertButton.text,
+        self.userKeyButton.text,
+        self.keyPwd,
+        self.userCAButton.text
+      )
+
+      self.sNet.hostname=self.server.text
+      self.sNet.auth_name=self.authName.text
+      self.sNet.auth_pass=self.authPass.text
+      self.sNet.initRemote()
+      self.initButton.setText("Active")
+
+  def onDatasetLoadButtonClicked(self):
+
+      ds=self.sNet.loadDataset(self.datasetProject.text,self.datasetName.text)
+      #loaded a JSON object -> convert to suitable display
+      columns=ds['columnModel']
+      self.data.setColumnCount(len(columns))
+      self.data.setRowCount(len(ds['rows']))
+      columnNames=[f['header'] for f in columns]
+      self.data.setHorizontalHeaderLabels(columnNames)
+      columnID=[f['dataIndex'] for f in columns]
+      insertRowID=0
+      for row in ds['rows']:
+          insertColumnID=0
+          for c in columnID:
+              item=qt.QTableWidgetItem(str(row[c]))
+              self.data.setItem(insertRowID,insertColumnID,item)
+              insertColumnID+=1
+          insertRowID+=1
+
+      #clear patient list
+      while self.patientsFormLayout.count():
+           child=self.patientsFormLayout.takeAt(0)
+           if child.widget():
+               self.signalMapper.removeMapping(child.widget())
+               child.widget().deleteLater()
+
+      #populate patient list
+      patientList=[f['EMBRACE_ID'] for f in ds['rows']]
+      patientSet=set(patientList)
+      for p in patientSet:
+           patientButton=qt.QPushButton(p)
+           patientButton.connect(patientButton, qt.SIGNAL("clicked()"),
+                self.signalMapper, qt.SLOT("map()"))
+           self.patientsFormLayout.addWidget(patientButton)
+           self.signalMapper.setMapping(patientButton,p)
+
+  def onPatientButtonClicked(self, label):
+      print "onPatientButtonClicked() for {}".format(label)
+      self.loadPatientLogic.load(label)
+
+
+#
+# dataExplorerLogic
+#
+
+class dataExplorerLogic(ScriptedLoadableModuleLogic):
+  """This class should implement all the actual
+  computation done by your module.  The interface
+  should be such that other python code can import
+  this class and make use of the functionality without
+  requiring an instance of the Widget.
+  Uses ScriptedLoadableModuleLogic base class, available at:
+  https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/ScriptedLoadableModule.py
+  """
+
+  def hasImageData(self,volumeNode):
+    """This is an example logic method that
+    returns true if the passed in volume
+    node has valid image data
+    """
+    if not volumeNode:
+      logging.debug('hasImageData failed: no volume node')
+      return False
+    if volumeNode.GetImageData() is None:
+      logging.debug('hasImageData failed: no image data in volume node')
+      return False
+    return True
+
+  def isValidInputOutputData(self, inputVolumeNode, outputVolumeNode):
+    """Validates if the output is not the same as input
+    """
+    if not inputVolumeNode:
+      logging.debug('isValidInputOutputData failed: no input volume node defined')
+      return False
+    if not outputVolumeNode:
+      logging.debug('isValidInputOutputData failed: no output volume node defined')
+      return False
+    if inputVolumeNode.GetID()==outputVolumeNode.GetID():
+      logging.debug('isValidInputOutputData failed: input and output volume is the same. Create a new volume for output to avoid this error.')
+      return False
+    return True
+
+  def takeScreenshot(self,name,description,type=-1):
+    # show the message even if not taking a screen shot
+    slicer.util.delayDisplay('Take screenshot: '+description+'.\nResult is available in the Annotations module.', 3000)
+
+    lm = slicer.app.layoutManager()
+    # switch on the type to get the requested window
+    widget = 0
+    if type == slicer.qMRMLScreenShotDialog.FullLayout:
+      # full layout
+      widget = lm.viewport()
+    elif type == slicer.qMRMLScreenShotDialog.ThreeD:
+      # just the 3D window
+      widget = lm.threeDWidget(0).threeDView()
+    elif type == slicer.qMRMLScreenShotDialog.Red:
+      # red slice window
+      widget = lm.sliceWidget("Red")
+    elif type == slicer.qMRMLScreenShotDialog.Yellow:
+      # yellow slice window
+      widget = lm.sliceWidget("Yellow")
+    elif type == slicer.qMRMLScreenShotDialog.Green:
+      # green slice window
+      widget = lm.sliceWidget("Green")
+    else:
+      # default to using the full window
+      widget = slicer.util.mainWindow()
+      # reset the type so that the node is set correctly
+      type = slicer.qMRMLScreenShotDialog.FullLayout
+
+    # grab and convert to vtk image data
+    qimage = ctk.ctkWidgetsUtils.grabWidget(widget)
+    imageData = vtk.vtkImageData()
+    slicer.qMRMLUtils().qImageToVtkImageData(qimage,imageData)
+
+    annotationLogic = slicer.modules.annotations.logic()
+    annotationLogic.CreateSnapShot(name, description, type, 1, imageData)
+
+  def run(self, inputVolume, outputVolume, imageThreshold, enableScreenshots=0):
+    """
+    Run the actual algorithm
+    """
+
+    if not self.isValidInputOutputData(inputVolume, outputVolume):
+      slicer.util.errorDisplay('Input volume is the same as output volume. Choose a different output volume.')
+      return False
+
+    logging.info('Processing started')
+
+    # Compute the thresholded output volume using the Threshold Scalar Volume CLI module
+    cliParams = {'InputVolume': inputVolume.GetID(), 'OutputVolume': outputVolume.GetID(), 'ThresholdValue' : imageThreshold, 'ThresholdType' : 'Above'}
+    cliNode = slicer.cli.run(slicer.modules.thresholdscalarvolume, None, cliParams, wait_for_completion=True)
+
+    # Capture screenshot
+    if enableScreenshots:
+      self.takeScreenshot('dataExplorerTest-Start','MyScreenshot',-1)
+
+    logging.info('Processing completed')
+
+    return True
+
+
+class dataExplorerTest(ScriptedLoadableModuleTest):
+  """
+  This is the test case for your scripted module.
+  Uses ScriptedLoadableModuleTest base class, available at:
+  https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/ScriptedLoadableModule.py
+  """
+
+  def setUp(self):
+    """ Do whatever is needed to reset the state - typically a scene clear will be enough.
+    """
+    slicer.mrmlScene.Clear(0)
+
+  def runTest(self):
+    """Run as few or as many tests as needed here.
+    """
+    self.setUp()
+    self.test_dataExplorer1()
+
+  def test_dataExplorer1(self):
+    """ Ideally you should have several levels of tests.  At the lowest level
+    tests should exercise the functionality of the logic with different inputs
+    (both valid and invalid).  At higher levels your tests should emulate the
+    way the user would interact with your code and confirm that it still works
+    the way you intended.
+    One of the most important features of the tests is that it should alert other
+    developers when their changes will have an impact on the behavior of your
+    module.  For example, if a developer removes a feature that you depend on,
+    your test should break so they know that the feature is needed.
+    """
+
+    self.delayDisplay("Starting the test")
+    #
+    # first, get some data
+    #
+    import urllib
+    downloads = (
+        ('http://slicer.kitware.com/midas3/download?items=5767', 'FA.nrrd', slicer.util.loadVolume),
+        )
+
+    for url,name,loader in downloads:
+      filePath = slicer.app.temporaryPath + '/' + name
+      if not os.path.exists(filePath) or os.stat(filePath).st_size == 0:
+        logging.info('Requesting download %s from %s...\n' % (name, url))
+        urllib.urlretrieve(url, filePath)
+      if loader:
+        logging.info('Loading %s...' % (name,))
+        loader(filePath)
+    self.delayDisplay('Finished with download and loading')
+
+    volumeNode = slicer.util.getNode(pattern="FA")
+    logic = dataExplorerLogic()
+    self.assertIsNotNone( logic.hasImageData(volumeNode) )
+    self.delayDisplay('Test passed!')

dataExplorer/loadPatient.py

@@ -0,0 +1,65 @@
+import slicer
+import loadDicom
+import re
+import slicerNetwork
+import os
+import subprocess
+
+fValue=loadDicom.dicomValue
+dicomModify="/afs/f9.ijs.si/home/studen/software/install/"
+dicomModify+="dicomModify/bin/dicomModify"
+
+class loadPatient(slicer.ScriptedLoadableModule.ScriptedLoadableModule):
+    def __init__(self,parent):
+        slicer.ScriptedLoadableModule.ScriptedLoadableModule.__init__(self, parent)
+        self.className="loadPatient"
+        self.parent.title="loadPatient"
+
+class loadPatientLogic(slicer.ScriptedLoadableModule.ScriptedLoadableModuleLogic):
+    def __init__(self,parent):
+       slicer.ScriptedLoadableModule.ScriptedLoadableModuleLogic.__init__(self, parent)
+
+       #self.plugin=slicer.modules.dicomPlugins['DicomRtImportExportPlugin']()
+       #self.volumePlugin=slicer.modules.dicomPlugins['DICOMScalarVolumePlugin']()
+       self.dicomLoader=loadDicom.loadDicomLogic(self)
+
+       #self.rtReader=slicer.vtkSlicerDicomRtReader()
+
+       #start SSL/TLS configuration
+
+    def setURIHandler(self, net):
+        self.sNet=net
+
+    def load(self,label):
+        #clear previous data
+        debug=True
+        loadDicom.clearNodes()
+        
+        containerPath='Matej/studija'
+        subFolder=''
+        dirUrl=containerPath+"/@files"+subFolder
+        dir=os.path.join(dirUrl,label)
+        #load segmentations
+        rs=dir+"/RS/DICOM";
+        self.dicomLoader.load(self.sNet,rs)
+
+
+        rsMatch='None'
+        dataset="ImagingVisitsManaged"
+        fSet=self.sNet.filterDataset(containerPath,dataset,'EMBRACE_ID',label)
+        fData=fSet['rows']
+        for r in fData:
+            if r['type']!='RS':
+                continue
+            row=r
+
+        if row['rsMatch']==None:
+            return
+
+        if row['rsMatch']=='NONE':
+            return
+
+        dicomDir=dir+'/'+row['rsMatch']+'/DICOM'
+        if debug:
+            print "Loading {}".format(dicomDir)
+        self.dicomLoader.load(self.sNet,dicomDir)