dynamicSPECT/slicerModules/imageBrowser.py

import os
import unittest
from __main__ import vtk, qt, ctk, slicer
from slicer.ScriptedLoadableModule import *
import json
import datetime
import sys
import nixModule
import pathlib
import chardet
import re
#
# labkeySlicerPythonExtension
#

class imageBrowser(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 = "image Browser" 
        # TODO make this more human readable by adding spaces
        self.parent.categories = ["dynamicSPECT"]
        self.parent.dependencies = []
        self.parent.contributors = ["Andrej Studen (UL/FMF)"] 
        # replace with "Firstname Lastname (Organization)"
        self.parent.helpText = """
        Interface to irAEMM files in LabKey
        """
        self.parent.acknowledgementText = """
        Developed within the medical physics research programme 
        of the Slovenian research agency.
        """ # replace with organization, grant and thanks.

#
# labkeySlicerPythonExtensionWidget
#

class imageBrowserWidget(ScriptedLoadableModuleWidget):
    """Uses ScriptedLoadableModuleWidget base class, available at:
  https://github.com/Slicer/Slicer/blob/master/Base/Python/slicer/ScriptedLoadableModule.py
    """

    def setup(self):
        print("Setting up imageBrowserWidget")
        ScriptedLoadableModuleWidget.setup(self)
        # Instantiate and connect widgets ...
      
        self.logic=imageBrowserLogic(self)
        self.addInfoSection()
        self.addSetupSection()
        self.addPatientsSelector()
        self.addSegmentEditor()
        self.addWindowManipulator()

    def addInfoSection(self):  
        #a python overview of json settings
        infoCollapsibleButton = ctk.ctkCollapsibleButton()
        infoCollapsibleButton.text = "Info"
        self.layout.addWidget(infoCollapsibleButton)
    
        infoLayout = qt.QFormLayout(infoCollapsibleButton)


        self.participantField=qt.QLabel("PatientId")
        infoLayout.addRow("Participant field:",self.participantField)
    
        self.ctField=qt.QLabel("ct")
        infoLayout.addRow("Data field (CT):",self.ctField)

        self.spectField=qt.QLabel("spect")
        infoLayout.addRow("Data field (SPECT):",self.spectField)

        self.userField=qt.QLabel("Loading")
        infoLayout.addRow("User",self.userField)

        self.idField=qt.QLabel("Loading")
        infoLayout.addRow("ID",self.idField)

        #Add logic at some point
        #self.logic=imageBrowserLogic(self)



    def addPatientsSelector(self):
        #
        # Patients Area
        #
        patientsCollapsibleButton = ctk.ctkCollapsibleButton()
        patientsCollapsibleButton.text = "Patients"
    
        #don't add it yet
        self.layout.addWidget(patientsCollapsibleButton)

        patientsFormLayout = qt.QFormLayout(patientsCollapsibleButton)

        self.patientList=qt.QComboBox()
        self.patientList.currentIndexChanged.connect(self.onPatientListChanged)
        self.patientList.setEditable(True)
        self.patientList.setInsertPolicy(qt.QComboBox.NoInsert)
        patientsFormLayout.addRow("Patient:",self.patientList)
            

        self.visitList=qt.QComboBox()
        self.visitList.currentIndexChanged.connect(self.onVisitListChanged)
        patientsFormLayout.addRow("Visit:",self.visitList)


        self.ctCode=qt.QLabel("ctCode")
        patientsFormLayout.addRow("CT:",self.ctCode)
    
        self.spectCode=qt.QLabel("spectCode")
        patientsFormLayout.addRow("SPECT:",self.spectCode)


        self.patientLoad=qt.QPushButton("Load")
        self.patientLoad.clicked.connect(self.onPatientLoadButtonClicked)
        patientsFormLayout.addRow("Load patient",self.patientLoad)

        self.patientSave=qt.QPushButton("Save")
        self.patientSave.clicked.connect(self.onPatientSaveButtonClicked)
        patientsFormLayout.addRow("Save segmentation",self.patientSave)

        self.patientClear=qt.QPushButton("Clear")
        self.patientClear.clicked.connect(self.onPatientClearButtonClicked)
        patientsFormLayout.addRow("Clear patient",self.patientClear)
    
        self.keepCached=qt.QCheckBox("keep Cached")
        self.keepCached.setChecked(1)
        patientsFormLayout.addRow("Keep cached",self.keepCached)

        self.forceReload=qt.QCheckBox("Force reload")
        self.forceReload.setChecked(0)
        patientsFormLayout.addRow("Force reload",self.forceReload)
        


    def addSetupSection(self):
        setupCollapsibleButton = ctk.ctkCollapsibleButton()
        setupCollapsibleButton.text = "Setup"
        self.layout.addWidget(setupCollapsibleButton)
        #Form layout (maybe one can think of more intuitive layouts)

        setupFormLayout = qt.QFormLayout(setupCollapsibleButton)

        self.serverList=qt.QComboBox()
        self.serverList.addItem('<Select>')
        self.serverList.addItem("astuden")
        self.serverList.addItem("llezaic")
        self.serverList.currentIndexChanged.connect(self.onServerListChanged)
        setupFormLayout.addRow("Select user:",self.serverList)


        self.setupList=qt.QComboBox()
        self.setupList.addItem('<Select>')
        #self.setupList.addItem("limfomiPET_iBrowser.json")
        #self.setupList.addItem("limfomiPET_iBrowser_selected.json")
        #self.setupList.addItem("iraemm_iBrowserProspective.json")
        #self.setupList.addItem("iraemm_iBrowserRetrospective.json")
        self.setupList.addItem("cardiacSPECT_iBrowser.json")
        self.setupList.currentIndexChanged.connect(self.onSetupListChanged)
        setupFormLayout.addRow("Setup:",self.setupList)



    def addSegmentEditor(self):
        editorCollapsibleButton = ctk.ctkCollapsibleButton()
        editorCollapsibleButton.text = "Segment Editor"
        self.layout.addWidget(editorCollapsibleButton)
        hLayout=qt.QVBoxLayout(editorCollapsibleButton)

        self.segmentEditorWidget=slicer.qMRMLSegmentEditorWidget()
        hLayout.addWidget(self.segmentEditorWidget)

        self.segmentEditorWidget.setMRMLScene(slicer.mrmlScene)
        segEditorNode=slicer.vtkMRMLSegmentEditorNode()
        slicer.mrmlScene.AddNode(segEditorNode)
        self.segmentEditorWidget.setMRMLSegmentEditorNode(segEditorNode)
       
    def addWindowManipulator(self):
        windowManipulatorCollapsibleButton=ctk.ctkCollapsibleButton()
        windowManipulatorCollapsibleButton.text="CT Window Manipulator"
        self.layout.addWidget(windowManipulatorCollapsibleButton)

        hLayout=qt.QHBoxLayout(windowManipulatorCollapsibleButton)

        ctWins={'CT:bone':self.onCtBoneButtonClicked,
            'CT:air':self.onCtAirButtonClicked,
            'CT:abdomen':self.onCtAbdomenButtonClicked,
            'CT:brain':self.onCtBrainButtonClicked,
            'CT:lung':self.onCtLungButtonClicked}
        for ctWin in ctWins:
            ctButton=qt.QPushButton(ctWin)
            ctButton.clicked.connect(ctWins[ctWin])
            hLayout.addWidget(ctButton)

    def onSetupListChanged(self,i):
        status=self.logic.setConfig(self.setupList.currentText)
        try:
            if status['error']=='FILE NOT FOUND':
                print('File {} not found.'.format(self.setupList.currentText))
                return
        except KeyError:
            pass

        #sort ids
        ids=status['ids']
        ids.sort()

        self.updatePatientList(ids)
        self.onPatientListChanged(0)
 
    def onServerListChanged(self,i):
        status=self.logic.setServer(self.serverList.currentText)
        try:
            if status['error']=='KEY ERROR':
                self.serverList.setStyleSheet('background-color: violet')
            if status['error']=='ID ERROR':
                self.serverList.setStyleSheet('background-color: red')
            return
        except KeyError:
            pass 

        self.idField.setText(status['id'])
        self.userField.setText(status['displayName'])
        self.serverList.setStyleSheet('background-color: green')

    def onPatientListChanged(self,i):
        dt=datetime.datetime
        self.visitList.clear()   
        self.spectCode.setText("")
        self.ctCode.setText("")
        
        #add potential filters from setup to dbFilter
        ds=self.logic.getDataset(dbFilter={'participant':self.patientList.currentText})
       
        visitVar=self.logic.getVarName(var='visitField')
       
        studyDateVar=self.logic.getVarName(var='studyDateField')
        #label is a combination of sequence number and date of imaging
        
        
        try:
            seq={row['SequenceNum']:
                {'label':row[visitVar],'date': parseDate(row[studyDateVar])} for row in ds['rows']}
        except TypeError:
           #if studyDate is empty, this will return no possible visits
           return 
            

        #apply lookup to visitVar if available
        try:
            seq={x:
                    {'label':ds['lookups'][visitVar][seq[x]['label']],
                    'date':seq[x]['date']}
                for x in seq}
        except KeyError:
            pass

        #format label
        seq={x:'{} ({})'.format(seq[x]['label'],dt.strftime(seq[x]['date'],'%d-%b-%Y')) 
            for x in seq}

            
        for s in seq:
            #onVisitListChanged is called for every addItem
            self.visitList.addItem(seq[s],s)

        #self.onVisitListChanged(0)

    def onVisitListChanged(self,i):
    
        #ignore calls on empty list
        if self.visitList.count==0:
            return

        #get sequence num
        s=self.visitList.itemData(i)

        print("Visit: SequenceNum:{}, label{}".format(s,self.visitList.currentText))
        dbFilter={'participant':self.patientList.currentText,
            'seqNum':s}
        ds=self.logic.getDataset(dbFilter=dbFilter)
        if not len(ds['rows'])==1:
            print("Found incorrect number {} of matches for [{}]/[{}]".\
                  format(len(ds['rows']),\
                  self.patientList.currentText,s))
        row=ds['rows'][0]

        #copy row properties for data access
        self.currentRow=row
        self.spectCode.setText(row[self.spectField.text])
        self.ctCode.setText(row[self.ctField.text])
        #self.segmentationCode.setText(row[self.segmentationField.text])

    def updatePatientList(self,ids):
        self.patientList.clear()

        for id in ids:
            self.patientList.addItem(id)

    def onPatientLoadButtonClicked(self):
        print("Load")
        #delegate loading to logic
        self.logic.loadImages(self.currentRow,self.keepCached.isChecked(),
                              self.forceReload.isChecked())
        self.logic.loadSegmentation(self.currentRow)
        self.setSegmentEditor()
        #self.logic.loadReview(self.currentRow)
        #self.logic.loadAE(self.currentRow)

        #self.onReviewSegmentChanged()

    def setSegmentEditor(self):
        #use current row to set segment in segment editor
        self.segmentEditorWidget.setSegmentationNode(
            self.logic.volumeNode['Segmentation'])
        self.segmentEditorWidget.setMasterVolumeNode(
            self.logic.volumeNode['SPECT'])
  
    def onReviewSegmentChanged(self):
        pass

    def onPatientClearButtonClicked(self):
        self.logic.clearVolumesAndSegmentations()
        self.patientSave.setStyleSheet('background-color:gray')

    def onPatientSaveButtonClicked(self):
        status=self.logic.saveSegmentation()
        if status:
            self.patientSave.setStyleSheet('background-color:green')
        else:
            self.patientSave.setStyleSheet('background-color:red')


    def onCtBoneButtonClicked(self):
        self.logic.setWindow('CT:bone')

    def onCtAirButtonClicked(self):
        self.logic.setWindow('CT:air')

    def onCtAbdomenButtonClicked(self):
        self.logic.setWindow('CT:abdomen')

    def onCtBrainButtonClicked(self):
        self.logic.setWindow('CT:brain')

    def onCtLungButtonClicked(self):
        self.logic.setWindow('CT:lung')

    def cleanup(self):
        pass


def loadLibrary(name):
    #utility function to load nix library from git
    fwrapper=nixModule.getWrapper('nixWrapper.py')
    p=pathlib.Path(fwrapper)
    sys.path.append(str(p.parent))
    import nixWrapper
    return nixWrapper.loadLibrary(name)


def parseDate(x):

   print(f'Parsing date from {x}') 
   dt=datetime.datetime
   try: 
      return dt.strptime(x,'%Y/%m/%d %H:%M:%S.%f')
   except ValueError:
      pass

   try: 
      return dt.strptime(x,'%Y-%m-%d %H:%M:%S.%f')
   except ValueError:
      pass

   #raise TypeError(f'Could not convert date {x}')
   return dt.fromtimestamp(0)
#
# imageBrowserLogic
#

class imageBrowserLogic(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 __init__(self,parent=None):
        ScriptedLoadableModuleLogic.__init__(self, parent)
        print('imageBrowserLogic loading')
        if not parent==None:
            #use layout and data from parent widget
            self.parent=parent
        
        fhome=os.path.expanduser('~')
        fsetup=os.path.join(fhome,'.labkey','setup.json')
        try:
             with open(fsetup) as f:
                self.setup=json.load(f)
        except FileNotFoundError:
            self.setup={}
          
        try:
            pt=self.setup['paths']
        except KeyError:
            self.setup['paths']={}

        lName='labkeyInterface'
        loadLibrary(lName)
      
        import labkeyInterface
        import labkeyDatabaseBrowser
        import labkeyFileBrowser


        self.network=labkeyInterface.labkeyInterface() 
        self.dbBrowser=labkeyDatabaseBrowser
        self.fBrowser=labkeyFileBrowser
        self.tempDir=os.path.join(os.path.expanduser('~'),'temp')
        if not os.path.isdir(self.tempDir):
            os.mkdir(self.tempDir)
        self.lookups={}
        #self.segmentList=["Liver","Blood","Marrow","Disease","Deauville"]
        self.segmentList=["One","Two","Three","Four","Five","Six","Seven","Eight"]
        print('imageBrowserLogic setup complete')
    


    def setServer(self,serverName):
        #additional way of setting the labkey network interface 
        #if no parent was provided in logic initialization (stand-alone mode)
        status={}
        fileName="NONE"
        if serverName=="astuden":
            fileName="astuden.json"
        if serverName=="llezaic":
            fileName="llezaic.json"
        if fileName=="NONE":
            print("No path was associated with server {}".format(serverName))
            status['error']='KEY ERROR'
            return status
        fconfig=os.path.join(os.path.expanduser('~'),'.labkey',fileName)
        self.network.init(fconfig)
        self.remoteId=self.network.getUserId()

        if self.remoteId==None:
            status['error']='ID ERROR'
            return status
     

        status['displayName']=self.remoteId['displayName']
        status['id']=self.remoteId['id']

        #reset db and fb (they are thin classes anyhow)
        self.db=self.dbBrowser.labkeyDB(self.network)
        self.fb=self.fBrowser.labkeyFileBrowser(self.network)
        return status

    def setConfig(self,configName):

        status={}
        fileName=os.path.join(os.path.expanduser('~'),'.labkey',configName)
        if not os.path.isfile(fileName):
            status['error']='FILE NOT FOUND'
            return status

        with open(fileName,'r') as f:
            self.isetup=json.load(f)

        #self.project=self.isetup['project']
        #"iPNUMMretro/Study"
        #self.schema='study'
        #self.dataset=self.isetup['query']
   
        #include filters...

        ds=self.getDataset()
        try:
            filterValue=self.isetup['filterEntries']
        except KeyError:
            #this is default
            ids=[row[self.isetup['participantField']] for row in ds['rows']]
            status['ids']=list(set(ids))
            return status
        
        #look for entries where segmentation was already done
        dsSet=self.getDataset('SegmentationsMaster')
        segMap={'{}:{}'.format(r['patientCode'],r['visitCode']):r['comments'] 
                for r in dsSet['rows']}
        ids=[]
        for r in ds['rows']:
            code='{}:{}'.format(r['patientCode'],r['visitCode'])
            try:
                comment=segMap[code]
            except KeyError:
                ids.append(r['patientCode'])
                continue
            if comment==filterValue:
                ids.append(r['patientCode'])
        status['ids']=list(set(ids))
        return status
        


    def getVarName(self,name="Imaging",var="visitField"):
        dset=self.isetup['datasets'][name]
        defaults={"visitField":"imagingVisitId","studyDateField":"studyDate"}
        try:
            return dset[var]
        except KeyError:
            return defaults[var]

        
    def getDataset(self,name="Imaging",dbFilter={}):
        dset=self.isetup['datasets'][name]
        project=dset['project']
        schema=dset['schema']
        query=dset['query']

        #add default filters
        qFilter=[]
        try:
            for qf in dset['filter']:
                v=dset['filter'][qf]
                qFilter.append({'variable':qf,'value':v,'oper':'eq'})
        except KeyError:
            pass
        for f in dbFilter:
            if f=='participant':
                qFilter.append({'variable':self.isetup['participantField'],
                    'value':dbFilter[f],'oper':'eq'})
                continue
            if f=='seqNum':
                qFilter.append({'variable':'SequenceNum',
                    'value':'{}'.format(dbFilter[f]),
                    'oper':'eq'})
                continue
            qFilter.append({'variable':f,'value':dbFilter[f],'oper':'eq'})

        try:
            ds=self.db.selectRows(project,schema,query, \
                qFilter,dset['view'])
        except KeyError:
            ds=self.db.selectRows(project,schema,query,qFilter)

        #get lookups as well 
        lookups={}
        for f in ds['metaData']['fields']:
            try:
                lookup=f['lookup']
            except KeyError:
                continue
            var=f['name']
            lookupCode='{}:{}'.format(lookup['schema'],lookup['queryName'])
            try:
                lookups[var]=self.lookups[lookupCode]
            except KeyError:
                self.lookups[lookupCode]=self.loadLookup(project,lookup)
                lookups[var]=self.lookups[lookupCode]
            
        return {'rows':ds['rows'],'lookups':lookups}

    def loadLookup(self,project,lookup):

        qData={}
        key=lookup['keyColumn']
        value=lookup['displayColumn']

        fSet=self.db.selectRows(project,lookup['schema'],lookup['queryName'],[])
        for q in fSet['rows']:
            qData[q[key]]=q[value]
        return qData

    def loadImage(self,iData):

        #unpack iData
        idx=iData['idx']
        path=iData['path']
        keepCached=iData['keepCached']
        try:
            forceReload=iData['forceReload']
        except KeyError:
            forceReload=False
        dset=self.isetup['datasets'][iData['dataset']]
        
        localPath=os.path.join(self.tempDir,path[-1])

        if not os.path.isfile(localPath) or forceReload:
            #download from server
            remotePath=self.fb.formatPathURL(dset['project'],'/'.join(path))
            if not self.fb.entryExists(remotePath):
                print("Failed to get {}".format(remotePath))
                return
            #overwrites existing file from remote
            self.fb.readFileToFile(remotePath,localPath) 
          
        properties={}
        filetype='VolumeFile'

        #make sure segmentation gets loaded as a labelmap
        if idx=="Segmentation":
            filetype='SegmentationFile'
            #properties["labelmap"]=1
              
          
        self.volumeNode[idx]=slicer.util.loadNodeFromFile(localPath,
                        filetype=filetype,properties=properties)
          
        if not keepCached:
            pass
            #os.remove(localPath)


    def loadImages(self,row,keepCached, forceReload=False):
      
      
        #fields={'ctResampled':True,'petResampled':False}
        fields={"CT":self.parent.ctField.text,\
              "SPECT":self.parent.spectField.text}

        path=[self.isetup['imageDir'],row['patientCode'],row['visitCode']]
        relativePaths={x:path+[row[y]] for (x,y) in fields.items()}

        self.volumeNode={}
        for f in relativePaths:
            iData={'idx':f,'path':relativePaths[f],
                    'keepCached':keepCached,'dataset':'Imaging',
                    'forceReload':forceReload}
            self.loadImage(iData)

        #mimic abdominalCT standardized window setting
        self.volumeNode['CT'].GetScalarVolumeDisplayNode().\
              SetAutoWindowLevel(False)
        self.volumeNode['CT'].GetScalarVolumeDisplayNode().\
              SetWindowLevel(1400, -500)
        #set colormap for PET to PET-Heat (this is a verbatim setting from
        #the Volumes->Display->Lookup Table colormap identifier)
        self.volumeNode['SPECT'].GetScalarVolumeDisplayNode().\
            SetAndObserveColorNodeID(\
            slicer.util.getNode('Inferno').GetID())
        slicer.util.setSliceViewerLayers(background=self.volumeNode['CT'],\
            foreground=self.volumeNode['SPECT'],foregroundOpacity=0.5,fit=True)

    def loadSegmentation(self,row, loadFile=1):
        dbFilter={'User':'{}'.format(self.remoteId['id']),
            'participant':row[self.isetup['participantField']],
            'visitCode':row['visitCode']}
        ds=self.getDataset(name='SegmentationsMaster',
                dbFilter=dbFilter)
        if len(ds['rows'])>1:
            print('Multiple segmentations found!')
            return
        if len(ds['rows'])==1:
            #update self.segmentationEntry
            self.segmentationEntry=ds['rows'][0]
            self.segmentationEntry['origin']='database'
            if loadFile:
                self.loadSegmentationFromEntry()
            return
        #create new segmentation 
        self.createSegmentation(row)

    def getSegmentationPath(self):
        path=[self.isetup['imageDir'],
                self.segmentationEntry['patientCode'],
                self.segmentationEntry['visitCode']]
        path.append('Segmentations')
        return path

    def loadSegmentationFromEntry(self):
        #compile path
        entry=self.segmentationEntry
        path=self.getSegmentationPath()
        path.append(entry['latestFile'])
        iData={'idx':'Segmentation','path':path,
                    'keepCached':1,'dataset':'SegmentationsMaster'}
        self.loadImage(iData)
        #look for missing segments
        segNode=self.volumeNode['Segmentation']
        seg=segNode.GetSegmentation()
        segNames=[seg.GetNthSegmentID(i) for i in range(seg.GetNumberOfSegments())]
        print('Segments')
        try:
            segmentList=self.isetup['segmentList']
        except KeyError:
            segmentList=self.segmentList
        for s in segmentList:
            if s not in segNames:
                seg.AddEmptySegment(s,s)
                print(s)
        print('Done')




    def saveSegmentation(self):
        #get the latest key by adding an entry to SegmentationList
        copyFields=[self.isetup['participantField'],'patientCode','visitCode','User']
        outRow={x:self.segmentationEntry[x] for x in copyFields}
        sList=self.isetup['datasets']['SegmentationsList']
        resp=self.db.modifyRows('insert',sList['project'],
            sList['schema'],sList['query'],[outRow])
        encoding=chardet.detect(resp)['encoding']
        respJSON=json.loads(resp.decode(encoding))
        outRow=respJSON['rows'][0]
        #print(outRow)

        #construct file name with known key
        uName=re.sub(' ','_',self.remoteId['displayName'])
        fName='Segmentation_{}-{}_{}_{}.nrrd'.format(
                self.segmentationEntry['patientCode'],
                self.segmentationEntry['visitCode'],
                uName,outRow['Key'])
        path=self.getSegmentationPath()
        path.append(fName)
        status=self.saveNode(self.volumeNode['Segmentation'],'SegmentationsMaster',path)

        
        #update SegmentationList with know file name
        outRow['Segmentation']=fName
        self.db.modifyRows('update',sList['project'],
            sList['schema'],sList['query'],[outRow])

        #update SegmentationsMaster
        self.segmentationEntry['latestFile']=fName
        self.segmentationEntry['version']=outRow['Key']
        des=self.isetup['datasets']['SegmentationsMaster']
        op='insert'
        if self.segmentationEntry['origin']=='database':
            op='update'
        print('Saving: mode={}'.format(op))
        resp=self.db.modifyRows(op,des['project'],
                des['schema'],des['query'],[self.segmentationEntry])
        print(resp)
        #since we loaded a version, origin should be set to database
        self.loadSegmentation(self.segmentationEntry,0)
        return status
        #self.segmentationEntry['origin']='database'
        


    def saveNode(self,node,dataset,path):
        fName=path[-1]
        localPath=os.path.join(self.tempDir,fName)
        slicer.util.saveNode(node,localPath)

        dset=self.isetup['datasets'][dataset]
        #exclude file name when building directory structure
        remotePath=self.fb.buildPathURL(dset['project'],path[:-1])
        remotePath+='/'+fName
        self.fb.writeFileToFile(localPath,remotePath)
        return self.fb.entryExists(remotePath)
        #add entry to segmentation list

    def createSegmentation(self,entry):

        #create segmentation entry for database update
        #note that origin is not set to database
        copyFields=[self.isetup['participantField'],'patientCode','visitCode','SequenceNum']
        #copyFields=['ParticipantId','patientCode','visitCode','SequenceNum']
        self.segmentationEntry={x:entry[x] for x in copyFields}
        self.segmentationEntry['User']=self.remoteId['id']
        self.segmentationEntry['origin']='created'
        self.segmentationEntry['version']=-1111
    
        #create a segmentation node
        uName=re.sub(' ','_',self.remoteId['displayName'])
        segNode=slicer.vtkMRMLSegmentationNode()
        self.volumeNode['Segmentation']=segNode
        segNode.SetName('Segmentation_{}_{}_{}'.
                format(entry['patientCode'],entry['visitCode'],uName))
        slicer.mrmlScene.AddNode(segNode)
        segNode.CreateDefaultDisplayNodes()
        segNode.SetReferenceImageGeometryParameterFromVolumeNode(self.volumeNode['SPECT'])
        try:
            segmentList=self.isetup['segmentList']
        except KeyError:
            segmentList=self.segmentList
        for s in segmentList:
            segNode.GetSegmentation().AddEmptySegment(s,s)



    def clearVolumesAndSegmentations(self):
        nodes=slicer.util.getNodesByClass("vtkMRMLVolumeNode")
        nodes.extend(slicer.util.getNodesByClass("vtkMRMLSegmentationNode"))
        res=[slicer.mrmlScene.RemoveNode(f) for f in nodes] 
        #self.segmentationNode=None
        #self.reviewResult={}
        #self.aeList={}

    def setWindow(self,windowName):

        #default
        w=1400
        l=-500
        
        if windowName=='CT:bone':
            w=1000
            l=400

        if windowName=='CT:air':
            w=1000
            l=-426
        
        if windowName=='CT:abdomen':
            w=350
            l=40

        if windowName=='CT:brain':
            w=100
            l=50

        if windowName=='CT:lung':
            w=1400
            l=-500


        self.volumeNode['CT'].GetScalarVolumeDisplayNode().\
              SetWindowLevel(w,l)
        
        print('setWindow: {} {}/{}'.format(windowName,w,l))

class imageBrowserTest(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_irAEMMBrowser()

    def test_irAEMMBrowser(self):
        """ Ideally you should have several levels of tests.  At the lowest level
    tests sould 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
        #