コード例 #1
0
ファイル: MainWindow.py プロジェクト: ajrichards/cytostream
class MainWindow(QtGui.QMainWindow):

    def __init__(self,debug=False,projectID=None):
        '''
        constructor
        '''

        ## construct and set main variables
        QtGui.QMainWindow.__init__(self)

        ## variables
        self.buff = 2.0
        self.controller = Controller(debug=debug)
        self.mainWidget = QtGui.QWidget(self)
        self.reset_view_workspace()
        self.stateList = ['Initial','Data Processing','Quality Assurance','Model Run','Model Results',
                          'Analysis','Analysis Results','Reports']
        self.resultsModeList = ['modes','components']

        ## enable the transition class
        self.transitions = Transitions(self)
        self.transitions.move_to_initial()
        
        ## settings
        self.showMaximized()
        self.setWindowTitle(self.controller.appName)
        screen = QtGui.QDesktopWidget().screenGeometry()
        self.screenWidth = screen.width()
        self.screenHeight = screen.height()
        self.eSize = 0.04 * self.screenWidth

        self.printer = None
        self.sizeLabel = QtGui.QLabel()
        self.sizeLabel.setFrameStyle(QtGui.QFrame.StyledPanel|QtGui.QFrame.Sunken)
        self.create_statusbar()
        create_menubar_toolbar(self)

        ## error check and use shortcut to open existing project if specified form cmd line
        if projectID != None:
            if os.path.isdir(projectID) == False:
                homeDir = os.path.join(self.controller.baseDir,"projects",projectID)
            else:
                homeDir = projectID
            if os.path.isdir(homeDir) == False:
                print "Controller: ERROR: home dir specified not found: fatal error"
                print "\t", homeDir
                sys.exit()
                if os.path.exists(os.path.join(homeDir,os.path.split(homeDir)[-1]+".log")) == False:
                    print "Controller: ERROR: home dir specified not a valid cytostream dir: fatal error"
                    print "\t", homeDir
                    sys.exit()
            self.open_existing_project_handler(homeDir)
       
    def reset_view_workspace(self):
        self.log = self.controller.log
        self.model = self.controller.model
        self.image = QtGui.QImage()
        self.dirty = False
        self.filename = None
        self.dockWidget = None
        self.fileSelector = None
        self.plotSelector = None
        self.plotTickControls = None
        self.channelSelector = None
        self.vizModeSelector = None
        self.subsampleSelector = None
        self.clusterSelector = None
        self.gateSelector = None
        self.saveImgsBtn = None
        self.dpc = None
        self.pDock = None
        self.dock = None
        self.tv = None
        self.nwv = None
        self.allFilePaths = []
        self.controller.masterChannelList = None
        self.reset_layout()

    def reset_layout(self):
        ''' 
        reset the main widget layouts
        '''
        
        self.vbl = QtGui.QVBoxLayout()
        self.vboxTop = QtGui.QVBoxLayout()
        self.vboxTop.setAlignment(QtCore.Qt.AlignTop)
        self.vboxCenter = QtGui.QVBoxLayout()
        self.vboxCenter.setAlignment(QtCore.Qt.AlignCenter)
        self.vboxBottom = QtGui.QVBoxLayout()
        self.vboxBottom.setAlignment(QtCore.Qt.AlignBottom)        
        self.vbl.addLayout(self.vboxTop)
        self.vbl.addLayout(self.vboxBottom)
        self.vbl.addLayout(self.vboxCenter)

    def create_statusbar(self):
        self.status = self.statusBar()
        self.status.setSizeGripEnabled(False)
        self.status.addPermanentWidget(self.sizeLabel)
        self.status.showMessage("Ready", 5000)

    def restore_docks(self,override=False):
        '''
        a dummy function to restore the application docks
        '''
        restore_docks(self,override=override)

    def add_pipeline_dock(self,noBtns=False):
        
        ## prepare widget
        self.pipelineDock = QtGui.QDockWidget(self)
        self.pipelineDock.setObjectName("PipelineDockWidget")
        self.pipelineDock.setAllowedAreas(QtCore.Qt.TopDockWidgetArea|QtCore.Qt.BottomDockWidgetArea)
 
        try:
            appColor = self.controller.log.log['app_color']
        except:
            appColor = '#999999'

        self.pipelineDockWidget = QtGui.QWidget(self)
        self.pDock = PipelineDock(self.controller.log, self.stateList,parent=self.pipelineDockWidget,eSize=0.07*self.screenWidth,mainWindow=self,
                                  appColor=appColor,noBtns=noBtns)
        palette = self.pipelineDockWidget.palette()
        role = self.pipelineDockWidget.backgroundRole()
        palette.setColor(role, QtGui.QColor('black'))
        self.pipelineDockWidget.setPalette(palette)
        self.pipelineDockWidget.setAutoFillBackground(True)
        hbl1 = QtGui.QHBoxLayout()
        hbl1.setAlignment(QtCore.Qt.AlignCenter)
        hbl1.addWidget(self.pipelineDock)
        vbl = QtGui.QVBoxLayout(self.pipelineDockWidget)
        vbl.addLayout(hbl1)
        vbl.setAlignment(QtCore.Qt.AlignCenter)
        
        self.pipelineDock.setWidget(self.pDock)
        self.addDockWidget(QtCore.Qt.RightDockWidgetArea, self.pipelineDock)
        self.pipelineDock.setMinimumWidth(0.08 * self.screenWidth)
        self.pipelineDock.setMaximumWidth(0.08 * self.screenWidth)

    def remove_project(self):
        projectID,projectInd = self.existingProjectOpener.get_selected_project()

        reply = QtGui.QMessageBox.question(self, self.controller.appName,
                                           "Are you sure you want to completely remove '%s'?"%projectID, QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
        if reply == QtGui.QMessageBox.Yes:
            homeDir = os.path.join(self.controller.baseDir,"projects",projectID)
            self.controller.remove_project(homeDir)
            self.transitions.move_to_open()
        else:
            pass

    def create_new_project(self):
        ## ask for project name
        projectID, ok = QtGui.QInputDialog.getText(self, 'Name designation', 'Enter the name of your new project:')
        projectID = re.sub("\s+","_",str(projectID))
        idValid = True

        if projectID == '':
            self.status.showMessage("New project creation aborted", 5000)
            return None

        defaultDir = self.controller.defaultDir
        projectDir = QtGui.QFileDialog.getExistingDirectory(self, 'Select a location to save your project', 
                                                            options=QtGui.QFileDialog.ShowDirsOnly, directory=defaultDir)
        projectID = re.sub("\s+","_",str(projectID))

        if projectDir == '':
            self.status.showMessage("New project creation aborted", 5000)
            return None
        
        projectDir = str(projectDir)

        if os.path.isdir(projectDir) == False:
            print "ERROR: MainWindow - specified project directory does not exist"
            self.status.showMessage("New project creation aborted", 5000)
            return None

        ## ensure project name is valid and not alreaedy used
        homeDir = os.path.join(projectDir,projectID)
        if os.path.isdir(homeDir) == True:
            idValid = False

        while idValid == False: 
            reply = QtGui.QMessageBox.question(self, 'Message', "A project named\n'%s'\nalready exists. Do you want to overwrite it?"%homeDir, 
                                               QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                idValid = True
                if self.controller.verbose == True:
                    print 'INFO: overwriting old project'
            else:
                self.status.showMessage("New project creation aborted", 5000)
                return None

        ## check to see if project creation was canceled
        if projectID == '':
            self.status.showMessage("New project creation aborted", 5000)
            return None

        if self.controller.verbose == True:
            print 'INFO: creating new project', projectID
        
        ## initialize and load project
        goFlag = self.controller.create_new_project(homeDir)
        if goFlag == True:
            self.transitions.move_to_data_processing()
            self.status.showMessage("New project successfully created", 5000)
        else:
            print "ERROR: create new project did not succeed"

    def open_existing_project(self):
        '''
        a reference function to move to the open screen

        '''
        
        if self.controller.verbose == True:
            print 'INFO: open existing project'
           
        self.transitions.move_to_open()
        self.status.showMessage("Existing project successfully loaded", 5000)

    def open_existing_project_handler(self,homeDir):
        '''
        from the open projects page open a selected project

        '''

        ## error check
        if homeDir == None:
            print "ERROR: mainWindow.open_existing_projects_handler - homeDir is None"
            return
        
        if os.path.isdir(homeDir) == False:
            print "ERROR: mainWindow.open_existing_projects_handler - homeDir does not exist"
            return
    
        projectID = os.path.split(homeDir)[-1]
        projectLog = os.path.join(homeDir,projectID+".log")
        if os.path.exists(projectLog) == False:
            print "ERROR: mainWindow.open_existing_projects_handler - homeDir not a cytostream project"
            self.display_warning("Specified project dir is not a valid cytostream project")
            return
    
        ## prepare variables and move
        print 'open existing project handler'        
        move_transition(self)
        print '...move transition made'
        self.reset_view_workspace()
        print '...reset workspace'
        self.controller.initialize_project(homeDir,loadExisting=True)
        print '...initializing controller'
        self.controller.masterChannelList = self.model.get_master_channel_list()
        print '...getting master channel list'
        self.refresh_state()
        
        
    def load_files_with_progressbar(self,progressBar):
        '''
        callback for loading files from data processing
        '''

        ## error check
        if type(self.allFilePaths) != type([]):
            print "ERROR: MainWindow -- load_files_with_progressbar -- bad input type"
        if len(self.allFilePaths) < 1:
            print "WARNING: MainWindow -- load_files_with_progressbar -- allFilePaths is empty"


        if len(self.dpc.fileUploader.loadedFilePaths) > 0:
            compensationFilePath = self.dpc.fileUploader.loadedFilePaths[0]
            self.controller.compensationFilePath = compensationFilePath

        self.controller.load_files_handler(self.allFilePaths,progressBar=progressBar,view=self)
        self.allFilePaths = []
        move_transition(self)
        self.refresh_state()

    def fileSave(self):
        '''
        saves current state of software
        '''

        if self.controller.homeDir != None:
            self.controller.save()
        else:
            self.display_warning("Must open project first before saving")
            return None

        self.display_info("Progress saved")

    def fileSaveAs(self):
        self.display_info("This function is not yet implemented")

    def filePrint(self):
        self.display_info("This function is not yet implemented")
        #if self.image.isNull():
        #    return
        #if self.printer is None:
        #    self.printer = QtGui.QPrinter(QtGui.QPrinter.HighResolution)
        #    self.printer.setPageSize(QtGui.QPrinter.Letter)
        #form = QtGui.QPrintDialog(self.printer, self)
        #if form.exec_():
        #    painter = QtGui.QPainter(self.printer)
        #    rect = painter.viewport()
        #    size = self.image.size()
        #    size.scale(rect.size(), QtCore.Qt.KeepAspectRatio)
        #    painter.setViewport(rect.x(), rect.y(), size.width(),
        #                        size.height())
        #    painter.drawImage(0, 0, self.image)

    def helpAbout(self):
        QtGui.QMessageBox.about(self, "About %s"%self.controller.appName,
                """<b>%s</b> v %s
                <p>Copyright &copy; 2010 Duke University. 
                All rights reserved.
                <p>This application can be used to perform
                model based analysis of flow cytometry data.
                <p>Python %s - Qt %s - PyQt %s on %s""" % (self.controller.appName,
                __version__, platform.python_version(),
                QT_VERSION_STR, PYQT_VERSION_STR, platform.system()))

    def show_model_log_info(self):
        self.set_selected_model()

        selectedModel, selectedModelIndex = self.fileSelector.get_selected_model()
        fullModelName = re.sub("\.fcs|\.pickle","",self.log.log['selected_file']) + "_" + selectedModel
        QtGui.QMessageBox.about(self, "%s - Model Information"%self.controller.appName,
                         """<br><b>Project ID</b> - %s
                             <br><b>Model name</b> - %s
                             <br><b>Date time</b>  - %s
                             <br><b>Full  name</b> - %s
                             <br><b>File name</b>  - %s 
                             <br><b>Components</b> - %s
                             <br><b>Modes</b>      - %s
                             <br><b>Run time</b>   - %s"""%(modelLogFile['project id'],selectedModel,modelLogFile['timestamp'],
                                                     modelLogFile['full model name'],modelLogFile['file name'],
                                                     modelLogFile['number components'], modelLogFile['number modes'],modelLogFile['model runtime'])
                          )

    def show_more_info(self):
        currentState = self.log.log['current_state']
        if moreInfoDict.has_key(currentState):
            msg = moreInfoDict[currentState]
        else:
            msg = """<br>Helpful information not yet present... %s"""%currentState   

        QtGui.QMessageBox.about(self, "%s - Information"%self.controller.appName,msg)
        
    def helpHelp(self):
        self.display_info("The help is not yet implimented")
        #form = helpform.HelpForm("index.html", self)
        #form.show()

    ################################################################################################3
    def generic_callback(self):
        print "this button/widget does not do anything yet"

    def set_num_components(self,value):
        diff = value % 16
        if diff == 0:
            newValue = value
        elif (value - diff) % 16 == 0:
            newValue = value - diff
        elif (value + diff) % 16 == 0:
            newValue = value + diff

        self.log.log['selected_k'] = newValue

    
    def handle_model_to_run_callback(self,item=None):
        '''
        handles the selection of model to run

        '''

        if item in ['dpmm']:
            self.log.log['model_to_run'] == item
        else:
            self.display_info("Selected model is not yet available")
            self.modelToRunSelector.set_checked('dpmm')

    def handle_model_mode_callback(self,item=None):
        '''
        handles the selection of model to run
        normal, onefit, pooled, target

        '''
        if item in ['normal']:
            self.log.log['model_mode'] == item
            self.log.log('file_in_focus','all')
        else:
            self.display_info("Selected model mode is not yet available")
            self.modelModeSelector.set_checked('normal')
            
    def handle_model_edit_return(self):
        '''
        handles the model edit return
        '''
        self.move_to_model_run(self,modelMode='progressbar')

    def handle_save_images_callback(self):

        if self.log.log['current_state'] == 'Quality Assurance':
            figMode = 'qa'
        else:
            figMode = 'analysis'

        validViews = ['plot']
        currentPlotView = str(self.controller.currentPlotView)

        if currentPlotView in validViews:
            defaultDir = os.path.join(self.controller.homeDir,'documents')
            fileFilter = "*.png;;*.jpg;;*.pdf"
            imgFileName, extension = QtGui.QFileDialog.getSaveFileNameAndFilter(self, 'Save As', directory=defaultDir, filter=fileFilter) 
            imgFileName = str(imgFileName)
            extension = str(extension)[1:]
            figName = re.sub(extension,"",imgFileName) + extension    
            numSubplots = int(re.sub('plot-','',currentPlotView))
            figTitle = None
            ss = SaveSubplots(self.controller.homeDir,figName,numSubplots,figMode=figMode,figTitle=figTitle,forceScale=True)
            print 'plot saved as ', figName
        else:
            print "WARNING: MainWindow.handle_save_images_callback - call to save from invalid mode",

    def update_highest_state(self):
        '''
        keep track of the highest state achieved in software
        '''

        ## keep track of the highest state
        if self.stateList.__contains__(self.controller.log.log['current_state']):
            if self.stateList.index(self.controller.log.log['current_state']) > int(self.controller.log.log['highest_state']):
                self.controller.log.log['highest_state'] = self.stateList.index(self.controller.log.log['current_state'])
                self.controller.save()
    
    def run_file_aligner(self):
        '''
        handles the running of the file aligner
        '''

        print 'this is where we run the file aligner'


    def run_progress_bar(self):
        mode = self.log.log['current_state']

        ## handle subsampling
        if self.log.log['current_state'] == 'Quality Assurance':
            subsample = self.log.log['subsample_qa']
        else:
            subsample = self.log.log['subsample_analysis']

        self.controller.handle_subsampling(subsample)

        fileList = get_fcs_file_names(self.controller.homeDir)
        if mode == 'Quality Assurance':
            self.qac.progressBar.button.setText('Please wait...')
            self.qac.progressBar.button.setEnabled(False)
            self.fileSelector.setEnabled(False)
            self.subsampleSelector.setEnabled(False)
            self.channelSelector.setEnabled(False)
            self.moreInfoBtn.setEnabled(False)
            QtCore.QCoreApplication.processEvents()
            self.controller.process_images('qa',progressBar=self.qac.progressBar,view=self)
            self.display_thumbnails()
        elif mode == 'Model Run':
            self.mc.set_disable()
            QtCore.QCoreApplication.processEvents()
            if  self.controller.log.log['model_to_run'] in ['dpmm-mcmc']:
                self.controller.run_selected_model_cpu(progressBar=self.mc.progressBar,view=self)
            else:
                self.controller.run_selected_model_cpu(progressBar=self.mc.progressBar,view=self)
        else:
            print "ERROR: got unexpected mode for MainWindow.run_progress_bar",mode

    def on_model_run_finish(self):
        '''
        after completion of model run automatically creatue figures
        '''

        self.transitions.move_to_model_run()
        self.mc.set_disable()
        QtCore.QCoreApplication.processEvents()
        self.mc.widgetSubtitle.setText("Creating figures...")
        self.mc.progressBar.progressLabel.setText("Creating figures...")
        subsample = self.controller.log.log['subsample_analysis']
        modelRunID = 'run' + str(self.log.log['models_run_count'])
        self.controller.handle_subsampling(subsample)
        self.controller.process_images('analysis',modelRunID=modelRunID,progressBar=self.mc.progressBar,view=self)
        self.transitions.move_to_model_results(mode='menu')

    def recreate_figures(self):
        '''
        call back from state transtions to enable thumbnail figure recreation
        '''
        
        if self.log.log['current_state'] == 'Quality Assurance':
            self.transitions.move_to_quality_assurance(mode='progressbar')
        elif self.log.log['current_state'] == 'Model Results':
            self.transitions.move_to_model_results()
            #self.on_model_run_finish()

    def plots_enable_disable(self,mode='thumbnails'):
        '''
        enables and disables widgets for thumbnail and plot view modes

        '''

        ## docks check
        if self.dockWidget == None:
            add_left_dock(self)
        if self.pDock == None:
            self.add_pipeline_dock()

        if mode == 'thumbnails':
            if self.fileSelector:
                self.fileSelector.setEnabled(True)
            if self.plotSelector:
                self.plotSelector.setEnabled(False)
            if self.channelSelector:
                self.channelSelector.setEnabled(False)
            if self.plotTickControls:
                self.plotTickControls.setEnabled(False)
            if self.vizModeSelector:
                self.vizModeSelector.setEnabled(True)
                self.vizModeSelector.set_checked(mode)
            if self.subsampleSelector:
                self.subsampleSelector.setEnabled(False)
            if self.clusterSelector:
                self.clusterSelector.setEnabled(False)
            if self.gateSelector:
                self.gsScrollArea.setEnabled(False)
                self.gateSelector.setEnabled(False)

        elif mode == 'plot':
            if self.log.log['current_state'] == 'Quality Assurance':
                self.pDock.enable_continue_btn(self.transitions.move_to_model_run)
                self.plotTickControls.labelsCB.setEnabled(False)
            else:
                self.plotTickControls.labelsCB.setEnabled(True)
            
            if self.fileSelector:
                self.fileSelector.setEnabled(True)
            if self.plotSelector:
                self.plotSelector.setEnabled(True)
            if self.channelSelector:
                self.channelSelector.setEnabled(True)
            if self.plotTickControls:
                self.plotTickControls.setEnabled(True)
            if self.vizModeSelector:
                self.vizModeSelector.setEnabled(True)
                self.vizModeSelector.set_checked(mode)
            if self.subsampleSelector:
                self.subsampleSelector.setEnabled(True)
            if self.clusterSelector:
                self.clusterSelector.setEnabled(True)
            if self.gateSelector:
                self.gsScrollArea.setEnabled(True)
                self.gateSelector.setEnabled(True)          

            if self.saveImgsBtn and self.controller.log.log['num_subplots'] != '1':
                self.saveImgsBtn.setEnabled(True)

            self.pDock.contBtn.setEnabled(True)
            self.pDock.enable_disable_states()

    def display_thumbnails(self,runNew=False,forceMode=None):
        ''' 
        displays thumbnail images for quality assurance or results navigation states
        '''

        ## enable/disable
        if forceMode != None:
            mode = forceMode
        else:
            mode = self.log.log['current_state']

        ## setup layout
        self.reset_layout()
        hbl = QtGui.QHBoxLayout()
        hbl.setAlignment(QtCore.Qt.AlignCenter)
        
        ## adjust the selected file
        fileList = get_fcs_file_names(self.controller.homeDir)
        if type(self.log.log['excluded_files']) == type([]) and len(self.log.log['excluded_files']) > 0:
            for f in self.log.log['excluded_files']:
                fileList.remove(f)
                
        self.log.log['selected_file'] == re.sub("\.txt|\.fcs","",fileList[0])

        if mode == 'Quality Assurance':
            excludedChannels = self.log.log['excluded_channels_qa']
            self.mainWidget = QtGui.QWidget(self)
            imgDir = os.path.join(self.controller.homeDir,"figs")
            fileChannels = self.log.log['alternate_channel_labels']
            channelsToView = np.array(fileChannels)[list(set(range(len(fileChannels))).difference(set(excludedChannels)))].tolist()
            thumbDir = os.path.join(imgDir,'qa',self.log.log['selected_file']+"_thumbs")
            self.tv = ThumbnailViewer(self.mainWidget,thumbDir,fileChannels,self.controller.channelDict,mainWindow=self)
        elif mode == 'Model Results':
            excludedChannels = self.log.log['excluded_channels_analysis']
            self.mainWidget = QtGui.QWidget(self)
            fileChannels = self.log.log['alternate_channel_labels']
            imgDir = os.path.join(self.controller.homeDir,'figs',self.log.log['selected_model'])
            
            if os.path.isdir(imgDir) == False:
                print "ERROR: MainWindow.display_thumbnails -- a bad imgDir has been specified", imgDir

            thumbDir = os.path.join(imgDir,self.log.log['selected_file']+"_thumbs")
            channelsToView = np.array(fileChannels)[list(set(range(len(fileChannels))).difference(set(excludedChannels)))].tolist()
            self.tv = ThumbnailViewer(self.mainWidget,thumbDir,channelsToView,self.controller.channelDict,mainWindow=self)
        else:
            print "ERROR: bad mode specified in display thumbnails", mode
            return

        ## for either mode
        self.plots_enable_disable(mode='thumbnails')
        self.tvScrollarea = QtGui.QScrollArea()
        self.tvScrollarea.setWidget(self.tv)
        self.tvScrollarea.setAlignment(QtCore.Qt.AlignCenter)

        #hbl.addWidget(self.tv)
        hbl.addWidget(self.tvScrollarea)
        self.vboxCenter.addLayout(hbl)
        self.mainWidget.setLayout(self.vbl)
        self.refresh_main_widget()
        
        ## disable buttons
        if self.dock != None:
            self.dock.disable_all()

        QtCore.QCoreApplication.processEvents()
        return True

    def models_run_btn_callback(self):
        '''
        Left dock button callback to return to Results Nav. menu
        '''

        self.transitions.move_to_model_results()

    def set_selected_file(self):
        '''
        set the selected file
        '''
    
        selectedFile = self.fileSelector.get_selected_file() 
        self.log.log['selected_file'] = re.sub("\.txt|\.fcs","",selectedFile)
        self.controller.save()

    def get_master_channel_list(self):
        ''' 
        returns the master channels list
        '''

        if self.controller.masterChannelList == None or len(self.controller.masterChannelList) == 0:
            self.controller.masterChannelList = self.model.get_master_channel_list()
        return self.controller.masterChannelList


    def refresh_state(self,withProgressBar=False,qaMode='thumbnails'):
        '''
        given the current state return to normal widget view
        '''

        if self.controller.log.log['current_state'] == "Data Processing":
            self.transitions.move_to_data_processing(withProgressBar=withProgressBar)
        elif self.controller.log.log['current_state'] == "Quality Assurance":
            self.transitions.move_to_quality_assurance(mode=qaMode)
        elif self.controller.log.log['current_state'] == "Model Run":
            self.transitions.move_to_model_run()
        elif self.controller.log.log['current_state'] == "Model Results":
            self.transitions.move_to_model_results()
        elif self.controller.log.log['current_state'] == "Analysis":
            self.transitions.move_to_analysis(self)
        elif self.controller.log.log['current_state'] == "Sample Aligner":
            self.transitions.move_to_sample_aligner(self)
        elif self.controller.log.log['current_state'] == "Basic Subsets":
            self.transitions.move_to_basic_subsets(self)
        elif self.controller.log.log['current_state'] == "Positivity":
            self.transitions.move_to_positivity(self)
        elif self.controller.log.log['current_state'] == "Analysis Results":
            self.transitions.move_to_analysis_results(self)
        elif self.controller.log.log['current_state'] == "Reports":
            self.transitions.move_to_reports(self)
        elif self.controller.log.log['current_state'] == "Initial":
            self.transitions.move_to_initial(self)
        else:
            print "ERROR: MainWindow.refresh_state was given invalid state", self.log.log['current_state']

        QtCore.QCoreApplication.processEvents()

    def handle_show_plot(self,img=None,gating=False):
        '''
        main handle to show a plot
        '''

        self.transitions.begin_wait()
        mode = self.log.log['current_state']
        self.set_selected_file()
        
        ## handle transition from thumbnails to plot view
        if img != None:
            self.log.log['num_subplots'] = 1
            self.vizModeSelector.update_num_subplots(1)
            chanInds = re.findall("\d+\_\d+\_thumb",img)
            i,j,k = chanInds[0].split("_")
            i,j = int(i),int(j)

            self.controller.log.log['plots_to_view_channels'][0] = (i,j)
            self.controller.log.log['plots_to_view_files'][0] = self.controller.fileNameList.index(self.log.log['selected_file'])
            self.controller.save()

        ## initialize transition
        fileChannels = self.log.log['alternate_channel_labels']
        self.reset_layout()
        self.mainWidget = QtGui.QWidget(self)

        ## set the model runs to view to be currently selected model
        self.log.log['plots_to_view_runs'] = [self.log.log['selected_model'] for i in self.log.log['plots_to_view_runs']]
        self.controller.save()

        ## mode specific variables for NWayViewer
        if self.log.log['current_state'] == "Quality Assurance":
            figMode = 'qa'
        elif self.log.log['current_state'] == "Model Results":
            figMode = 'model results'
        else:
            print "ERROR: MainWindow --- unspecified state"

        self.nwv = NWayViewer(self.controller,self.log.log['plots_to_view_channels'],self.log.log['plots_to_view_files'],
                         self.log.log['plots_to_view_runs'],self.log.log['plots_to_view_highlights'],
                         self.log.log['num_subplots'],figMode=figMode,background=True,modelType='components',
                         useScaled=self.log.log['use_scaled_plots'],parent=self,mainWindow=self,gating=gating)
        
        hbl = QtGui.QHBoxLayout()
        hbl.setAlignment(QtCore.Qt.AlignCenter)
        hbl.addWidget(self.nwv)

        ## enable/disable
        self.plots_enable_disable(mode='plot')

        ## finalize layout
        self.vboxCenter.addLayout(hbl)
        self.mainWidget.setLayout(self.vbl)
        self.refresh_main_widget()
        QtCore.QCoreApplication.processEvents()
        self.transitions.end_wait()

    def display_info(self,msg):
        '''
        display info
        generic function to display info to user
        '''
        reply = QtGui.QMessageBox.information(self,'Information',msg)

    def display_warning(self,msg):
        '''
        display warning
        generic function to display a warning to user
        '''
        reply = QtGui.QMessageBox.warning(self, "Warning", msg)

    def refresh_main_widget(self):
        '''
        main function to reset main widget
        '''

        self.setCentralWidget(self.mainWidget)
        self.mainWidget.activateWindow()
        self.mainWidget.update()
        self.show()
コード例 #2
0
ファイル: NoGuiAnalysis.py プロジェクト: ajrichards/GenesDI
class NoGuiAnalysis():
    def __init__(self,projectID,allFiles,subsample='1e4',makeQaFigs=True,makeResultsFigs=True, numComponents=16):
        ## error checking
        if type(allFiles) != type([]):
            print "ERROR:allFiles input must be of type list"
            return None

        self.projectID = projectID
        self.allFiles = allFiles
        self.subsample = subsample
        self.makeQaFigs = makeQaFigs
        self.makeResultsFigs = makeResultsFigs
        self.numComponents = numComponents
        self.initialize()

        for fileName in self.allFiles:
            self.controller.log.log['selectedFile'] = os.path.split(fileName)[-1]
            print 'running model on', self.controller.log.log['selectedFile']
            self.run_selected_model()

        ## create figures
        if self.makeResultsFigs == True:
            print 'creating results figures'
            self.controller.process_images('results')

    def initialize(self):
        self.controller = Controller()
        self.controller.initialize_project(self.projectID)
        
        firstFile = True
        goFlag = True
        for fileName in self.allFiles:

            if os.path.isfile(fileName) == False:
                print 'ERROR: Bad file name skipping', fileName
                continue

            print 'adding...', fileName
            fileName = str(fileName)
            if firstFile == True:
                self.controller.create_new_project(fileName)
                firstFile = False
            else:
                goFlag = self.controller.load_additional_fcs_files(fileName)

        if self.controller.homeDir == None:
            print "ERROR: project failed to initialize"
            return
        else:
            print "project created."
        
        # subsampling
        print "handling subsampling"
        self.controller.log.log['subsample'] = self.subsample
        self.controller.handle_subsampling()
        self.controller.save()
        
        # qa image creation
        if self.makeQaFigs == True:
            print 'making qa images'
            self.controller.process_images('qa')

    def run_selected_model(self):
        self.controller.log.log['numComponents'] = self.numComponents
        self.controller.log.log['modelToRun'] = 'dpmm'
        self.controller.run_selected_model()
        selectedFile = self.controller.log.log['selectedFile']
        modelName = "%s_sub%s_dpmm"%(re.sub("\.fcs|\.pickle","",selectedFile),int(float(self.subsample)))
        statModelModes, statModelClasses = self.controller.model.load_model_results_pickle(modelName,'modes')