Esempio n. 1
0
 def applyMaskStep(self):
     import pyworkflow.em.packages.xmipp3 as xmipp3
     from pyworkflow.em.packages.xmipp3.convert import getImageLocation
     
     params = ' -i %s --mult %s -o %s' % (getImageLocation(self.inputVolume.get()),
                                          getImageLocation(self.refMask.get()),
                                          self._getFileName('volume_masked'))
     self.runJob('xmipp_image_operate', params, env=xmipp3.getEnviron())
    def applyMaskStep(self):
        import pyworkflow.em.packages.xmipp3 as xmipp3
        from pyworkflow.em.packages.xmipp3.convert import getImageLocation

        params = ' -i %s --mult %s -o %s' % (getImageLocation(
            self.inputVolume.get()), getImageLocation(
                self.refMask.get()), self._getFileName('volume_masked'))
        self.runJob('xmipp_image_operate', params, env=xmipp3.getEnviron())
    def _insertAllSteps(self):

        cutoffStr = ''
        if self.cutoffMode == NMA_CUTOFF_REL:
            cutoffStr = 'Relative %f' % self.rcPercentage.get()
        else:
            cutoffStr = 'Absolute %f' % self.rc.get()

        maskArgs = ''
        alignArgs = self._getAlignArgs()
        ALIGN_ALGORITHM_EXHAUSTIVE_LOCAL = 1
        self.alignmentAlgorithm = ALIGN_ALGORITHM_EXHAUSTIVE_LOCAL

        volList = [vol.clone() for vol in self._iterInputVolumes()]
        nVoli = 1

        for voli in volList:
            fnIn = getImageLocation(voli)
            fnMask = self._insertMaskStep(fnIn)
            suffix = "_%d" % nVoli

            self._insertFunctionStep('convertToPseudoAtomsStep', fnIn, fnMask,
                                     voli.getSamplingRate(), suffix)
            fnPseudoAtoms = self._getPath("pseudoatoms_%d.pdb" % nVoli)

            self._insertFunctionStep('computeModesStep', fnPseudoAtoms,
                                     self.numberOfModes, cutoffStr)
            self._insertFunctionStep('reformatOutputStep',
                                     os.path.basename(fnPseudoAtoms))

            self._insertFunctionStep(
                'qualifyModesStep', self.numberOfModes,
                self.collectivityThreshold.get(),
                self._getPath("pseudoatoms_%d.pdb" % nVoli), suffix)

            #rigid alignment
            nVolj = 1
            for volj in volList:
                if nVolj != nVoli:
                    refFn = getImageLocation(voli)
                    inVolFn = getImageLocation(volj)
                    volId = volj.getObjId()
                    outVolFn = self._getPath(
                        'outputRigidAlignment_vol_%d_to_%d.vol' %
                        (nVolj, nVoli))
                    self._insertFunctionStep('alignVolumeStep', refFn, inVolFn,
                                             outVolFn, maskArgs, alignArgs,
                                             volId)
                    self._insertFunctionStep('elasticAlignmentStep', nVoli,
                                             voli, nVolj)
                nVolj += 1
            nVoli += 1

        self._insertFunctionStep('gatherResultsStep')
        self._insertFunctionStep('managingOutputFilesStep')
Esempio n. 4
0
    def _insertAllSteps(self):
        """Insert all steps to calculate the resolution of a 3D reconstruction. """

        self.inputVol = getImageLocation(self.inputVolume.get())
        if self.referenceVolume.hasValue():
            self.refVol = getImageLocation(self.referenceVolume.get())

        if self.doFSC:
            self._insertFunctionStep('calculateFscStep')
        if self.doComputeBfactor:
            self._insertFunctionStep('computeBfactorStep')
        self._insertFunctionStep('createSummaryStep')
Esempio n. 5
0
 def _insertAllSteps(self):
     """Insert all steps to calculate the resolution of a 3D reconstruction. """
     
     self.inputVol = getImageLocation(self.inputVolume.get())
     if self.referenceVolume.hasValue():
         self.refVol = getImageLocation(self.referenceVolume.get())
     
     if self.doFSC:
         self._insertFunctionStep('calculateFscStep')
     if self.doComputeBfactor:
         self._insertFunctionStep('computeBfactorStep')
     self._insertFunctionStep('createSummaryStep')
Esempio n. 6
0
    def _insertAllSteps(self):
        
        cutoffStr=''
        if self.cutoffMode == NMA_CUTOFF_REL:
            cutoffStr = 'Relative %f'%self.rcPercentage.get()
        else:
            cutoffStr = 'Absolute %f'%self.rc.get()

        maskArgs = ''
        alignArgs = self._getAlignArgs()
        ALIGN_ALGORITHM_EXHAUSTIVE_LOCAL = 1
        self.alignmentAlgorithm = ALIGN_ALGORITHM_EXHAUSTIVE_LOCAL 
                                                
        volList = [vol.clone() for vol in self._iterInputVolumes()]
        nVoli = 1
                                   
        for voli in volList:
            fnIn = getImageLocation(voli)
            fnMask = self._insertMaskStep(fnIn)
            suffix = "_%d"%nVoli        
            
            self._insertFunctionStep('convertToPseudoAtomsStep', 
                                     fnIn, fnMask, voli.getSamplingRate(), suffix)
            fnPseudoAtoms = self._getPath("pseudoatoms_%d.pdb"%nVoli)
            
            self._insertFunctionStep('computeModesStep', fnPseudoAtoms,
                                     self.numberOfModes, cutoffStr)
            self._insertFunctionStep('reformatOutputStep', os.path.basename(fnPseudoAtoms))
                                            
            self._insertFunctionStep('qualifyModesStep', self.numberOfModes, 
                                     self.collectivityThreshold.get(), 
                                     self._getPath("pseudoatoms_%d.pdb"%nVoli), suffix)
            
            #rigid alignment            
            nVolj = 1
            for volj in volList:
                if nVolj != nVoli:
                    refFn = getImageLocation(voli)
                    inVolFn = getImageLocation(volj)
                    volId = volj.getObjId()
                    outVolFn = self._getPath('outputRigidAlignment_vol_%d_to_%d.vol' % (nVolj, nVoli))
                    self._insertFunctionStep('alignVolumeStep', refFn, inVolFn, outVolFn,
                                             maskArgs, alignArgs, volId)
                    self._insertFunctionStep('elasticAlignmentStep',nVoli, voli, nVolj)
                nVolj += 1   
            nVoli += 1
               
        self._insertFunctionStep('gatherResultsStep')
        self._insertFunctionStep('managingOutputFilesStep')
Esempio n. 7
0
 def _insertAllSteps(self):
     # Iterate through all input volumes and align them 
     # againt the reference volume
     refFn = getImageLocation(self.inputReference.get())
     maskArgs = self._getMaskArgs()
     alignArgs = self._getAlignArgs()
     alignSteps = []
     
     for vol in self._iterInputVolumes():
         volFn = getImageLocation(vol)
         stepId = self._insertFunctionStep('alignVolumeStep', refFn, volFn, vol.outputName, 
                                           maskArgs, alignArgs, prerequisites=[])
         alignSteps.append(stepId)
         
     self._insertFunctionStep('createOutputStep', prerequisites=alignSteps)
 def _insertAllSteps(self):
     # Iterate throught all input volumes and align them 
     # againt the reference volume
     refFn = getImageLocation(self.inputReference.get())
     maskArgs = self._getMaskArgs()
     alignArgs = self._getAlignArgs()
     alignSteps = []
     
     for vol in self._iterInputVolumes():
         volFn = getImageLocation(vol)
         stepId = self._insertFunctionStep('alignVolumeStep', refFn, volFn, vol.outputName, 
                                           maskArgs, alignArgs, prerequisites=[])
         alignSteps.append(stepId)
         
     self._insertFunctionStep('createOutputStep', prerequisites=alignSteps)
    def _insertAllSteps(self):
        convertId = self._insertFunctionStep("convertInputStep", self.inputParticles.get().getObjId())
        deps = []  # store volumes steps id to use as dependencies for last step
        commonParams = self._getCommonParams()
        commonParamsRef = self._getCommonParamsRef()
        sym = self.symmetryGroup.get()

        for i, vol in enumerate(self._iterInputVols()):
            volName = getImageLocation(vol)
            volDir = self._getVolDir(i + 1)

            sigStepId = self._insertFunctionStep(
                "significantStep", volName, volDir, "exp_particles.xmd", commonParams, prerequisites=[convertId]
            )

            phanProjStepId = self._insertFunctionStep("phantomProject", volName, prerequisites=[convertId])

            sigStepId = self._insertFunctionStep(
                "significantStep", volName, volDir, "ref_particles.xmd", commonParamsRef, prerequisites=[phanProjStepId]
            )

            volStepId = self._insertFunctionStep("validationStep", volName, volDir, sym, prerequisites=[sigStepId])

            deps.append(volStepId)

        self._insertFunctionStep("createOutputStep", prerequisites=deps)
Esempio n. 10
0
 def _computeRightPreview(self):
     """ This function should compute the right preview
     using the self.lastObj that was selected
     """
     from pyworkflow.em.packages.xmipp3.convert import getImageLocation
     xmipp.gaussianFilter(self.rightImage, getImageLocation(self.lastObj),
                          self.getFreqSigma(), self.dim)
Esempio n. 11
0
    def _insertAllSteps(self):
        #divide work in several threads
        numberOfThreads = self.numberOfThreads.get() - 1
        if numberOfThreads == 0:
            numberOfThreads = 1
        partSet = self.inputParticles.get()
        nPart = len(partSet)
        numberOfThreads = min(numberOfThreads, nPart)
        samplingRate = partSet.getSamplingRate()
        inputVolume = getImageLocation(self.inputVolume.get())
        mdFn = self._getInputParticlesFn()
        convertId = self._insertFunctionStep('convertInputStep', inputVolume)

        deps = [convertId]

        # Create xmipp metadata
        # partSet
        #writeSetOfParticles(partSet, mdFn, blockName="images")
        groupSize = nPart / numberOfThreads
        groupRemainder = nPart % numberOfThreads

        depsOutPut = []
        for thread in range(0, numberOfThreads):
            start = long(thread * groupSize + 1)
            end = long(thread * groupSize + groupSize)
            if thread == (numberOfThreads - 1):
                end += groupRemainder
            idStep = self._insertFunctionStep('projectStep',
                                              start,
                                              end,
                                              samplingRate,
                                              thread,
                                              prerequisites=deps)
            depsOutPut.append(idStep)
        self._insertFunctionStep('createOutputStep', prerequisites=depsOutPut)
Esempio n. 12
0
    def _insertAllSteps(self):
        #divide work in several threads
        numberOfThreads = self.numberOfThreads.get()-1
        if numberOfThreads == 0:
            numberOfThreads = 1
        partSet = self.inputParticles.get()
        nPart = len(partSet)
        numberOfThreads = min(numberOfThreads, nPart)
        samplingRate = partSet.getSamplingRate()
        inputVolume = getImageLocation(self.inputVolume.get())
        mdFn = self._getInputParticlesFn()
        convertId = self._insertFunctionStep('convertInputStep',
                                            inputVolume)

        deps = [convertId]

        # Create xmipp metadata
        # partSet
        #writeSetOfParticles(partSet, mdFn, blockName="images")
        groupSize = nPart/numberOfThreads
        groupRemainder = nPart%numberOfThreads

        depsOutPut=[]
        for thread in range(0, numberOfThreads):
            start = long(thread * groupSize+1)
            end = long(thread * groupSize+groupSize)
            if thread == (numberOfThreads-1):
                end += groupRemainder
            idStep = self._insertFunctionStep('projectStep', start, end,
                                              samplingRate, thread,
                                              prerequisites=deps)
            depsOutPut.append(idStep)
        self._insertFunctionStep('createOutputStep', prerequisites=depsOutPut)
Esempio n. 13
0
 def _computeRightPreview(self):
     """ This function should compute the right preview
     using the self.lastObj that was selected
     """
     from pyworkflow.em.packages.xmipp3.convert import getImageLocation
     xmipp.gaussianFilter(self.rightImage, getImageLocation(self.lastObj),
                          self.getFreqSigma(), self.dim)
 def _insertAllSteps(self):
     self._insertFunctionStep('copyInput')
     self._insertFunctionStep('coarseSearch')
     self._insertFunctionStep('fineSearch')
     self._insertFunctionStep('symmetrize')
     self._insertFunctionStep('createOutput')
     self.fnVol = getImageLocation(self.inputVolume.get())
     self.fnVolSym = self._getPath('volume_symmetrized.vol')
     [self.height, _, _] = self.inputVolume.get().getDim()
 def _insertAllSteps(self):
     self._insertFunctionStep('copyInput')
     self._insertFunctionStep('coarseSearch')
     self._insertFunctionStep('fineSearch')
     self._insertFunctionStep('symmetrize')
     self._insertFunctionStep('createOutput')
     self.fnVol = getImageLocation(self.inputVolume.get())
     self.fnVolSym=self._getPath('volume_symmetrized.vol')
     [self.height,_,_]=self.inputVolume.get().getDim()
Esempio n. 16
0
    def convertInputStep(self, volName):
        # Read volume and convert to DOUBLE
        self.vol = xmipp.Image(volName)
        self.vol.convert2DataType(xmipp.DT_DOUBLE)
        # Mask volume if needed
        if self.refMask.get() is not None:
            maskName = getImageLocation(self.refMask.get())
            self.mask = xmipp.Image(maskName)
            self.mask.convert2DataType(xmipp.DT_DOUBLE)
            self.vol.inplaceMultiply(self.mask)
        padding = 2
        maxFreq = 0.5
        splineDegree = 3
        ###
        self.fourierProjectVol = xmipp.FourierProjector(
            self.vol, padding, maxFreq, splineDegree)
        ###
        partSet = self.inputParticles.get()
        nPart = len(partSet)
        numberOfTasks = min(nPart, max(self.numberOfThreads.get() - 1, 1))
        taskSize = nPart / numberOfTasks
        md = xmipp.MetaData()

        # Convert angles and shifts from volume system of coordinates to
        # projection system of coordinates
        mdCount = 0

        for index, part in enumerate(partSet):
            objId = md.addObject()
            imgRow = XmippMdRow()
            particleToRow(part, imgRow)
            shifts, angles = geometryFromMatrix(
                part.getTransform().getMatrix(), True)

            imgRow.setValue(xmipp.MDL_SHIFT_X, -shifts[0])
            imgRow.setValue(xmipp.MDL_SHIFT_Y, -shifts[1])
            imgRow.setValue(xmipp.MDL_SHIFT_Z, 0.)
            imgRow.setValue(xmipp.MDL_ANGLE_ROT, angles[0])
            imgRow.setValue(xmipp.MDL_ANGLE_TILT, angles[1])
            imgRow.setValue(xmipp.MDL_ANGLE_PSI, angles[2])

            imgRow.writeToMd(md, objId)

            # Write a new metadata every taskSize number of elements
            # except in the last chunk where we want to add also the
            # remainder and the condition is the last element
            if ((index % taskSize == taskSize - 1
                 and mdCount < numberOfTasks - 1) or index == nPart - 1):
                md.write(self._getInputParticlesSubsetFn(mdCount))
                md.clear()
                mdCount += 1

        x, y, _ = partSet.getDim()
        xmipp.createEmptyFile(self._getProjGalleryFn(), x, y, 1, nPart)
Esempio n. 17
0
 def _insertMaskStep(self, fnVol, prefix=''):
     """ Check the mask selected and insert the necessary steps.
     Return the mask filename if needed.
     """
     fnMask = ''
     if self.maskMode == NMA_MASK_THRE:
         fnMask = self._getExtraPath('mask%s.vol' % prefix)
         maskParams = '-i %s -o %s --select below %f --substitute binarize' % (fnVol, fnMask, self.maskThreshold.get())
         self._insertRunJobStep('xmipp_transform_threshold', maskParams)
     elif self.maskMode == NMA_MASK_FILE:
         fnMask = getImageLocation(self.volumeMask.get())
     return fnMask
Esempio n. 18
0
    def convertInputStep(self, volName):
        # Read volume and convert to DOUBLE
        self.vol = xmipp.Image(volName)
        self.vol.convert2DataType(xmipp.DT_DOUBLE)
        # Mask volume if needed
        if self.refMask.get() is not None:
            maskName = getImageLocation(self.refMask.get())
            self.mask = xmipp.Image(maskName)
            self.mask.convert2DataType(xmipp.DT_DOUBLE)
            self.vol.inplaceMultiply(self.mask)
        padding = 2
        maxFreq = 0.5
        splineDegree = 3
        ###
        self.fourierProjectVol = xmipp.FourierProjector(self.vol, padding, maxFreq, splineDegree)
        ###
        partSet = self.inputParticles.get()
        nPart = len(partSet)
        numberOfTasks = min(nPart, max(self.numberOfThreads.get()-1, 1))
        taskSize = nPart / numberOfTasks
        md = xmipp.MetaData()

        # Convert angles and shifts from volume system of coordinates to
        # projection system of coordinates
        mdCount = 0

        for index, part in enumerate(partSet):
            objId = md.addObject()
            imgRow = XmippMdRow()
            particleToRow(part, imgRow)
            shifts, angles = geometryFromMatrix(part.getTransform().getMatrix(), True)

            imgRow.setValue(xmipp.MDL_SHIFT_X,-shifts[0])
            imgRow.setValue(xmipp.MDL_SHIFT_Y,-shifts[1])
            imgRow.setValue(xmipp.MDL_SHIFT_Z,0.)
            imgRow.setValue(xmipp.MDL_ANGLE_ROT,angles[0])
            imgRow.setValue(xmipp.MDL_ANGLE_TILT,angles[1])
            imgRow.setValue(xmipp.MDL_ANGLE_PSI,angles[2])

            imgRow.writeToMd(md, objId)

            # Write a new metadata every taskSize number of elements
            # except in the last chunk where we want to add also the
            # remainder and the condition is the last element
            if ((index % taskSize == taskSize-1 and
                 mdCount < numberOfTasks-1) or index == nPart-1):
                md.write(self._getInputParticlesSubsetFn(mdCount))
                md.clear()
                mdCount += 1

        x, y, _ = partSet.getDim()
        xmipp.createEmptyFile(self._getProjGalleryFn(), x, y, 1, nPart)
    def _insertAllSteps(self):
        convertId = self._insertFunctionStep(
            'convertInputStep',
            self.inputParticles.get().getObjId())
        deps = [
        ]  # store volumes steps id to use as dependencies for last step
        commonParams = self._getCommonParams()
        commonParamsRef = self._getCommonParamsRef()

        sym = self.symmetryGroup.get()

        for i, vol in enumerate(self._iterInputVols()):

            volName = getImageLocation(vol)
            volDir = self._getVolDir(i + 1)

            pmStepId = self._insertFunctionStep('projectionLibraryStep',
                                                volName,
                                                volDir,
                                                self.angularSampling.get(),
                                                prerequisites=[convertId])

            sigStepId1 = self._insertFunctionStep('significantStep',
                                                  volName,
                                                  volDir,
                                                  'exp_particles.xmd',
                                                  commonParams,
                                                  prerequisites=[pmStepId])

            phanProjStepId = self._insertFunctionStep(
                'phantomProject', prerequisites=[sigStepId1])

            sigStepId2 = self._insertFunctionStep(
                'significantStep',
                volName,
                volDir,
                'ref_particles.xmd',
                commonParamsRef,
                prerequisites=[phanProjStepId])

            if (not (self.pseudoSymmetryGroup.get() == '')):
                sym = self.pseudoSymmetryGroup.get()

            volStepId = self._insertFunctionStep('alignabilityStep',
                                                 volName,
                                                 volDir,
                                                 sym,
                                                 prerequisites=[sigStepId2])

            deps.append(volStepId)

        self._insertFunctionStep('createOutputStep', prerequisites=deps)
 def _insertMaskStep(self, fnVol, prefix=''):
     """ Check the mask selected and insert the necessary steps.
     Return the mask filename if needed.
     """
     fnMask = ''
     if self.maskMode == NMA_MASK_THRE:
         fnMask = self._getExtraPath('mask%s.vol' % prefix)
         maskParams = '-i %s -o %s --select below %f --substitute binarize' % (
             fnVol, fnMask, self.maskThreshold.get())
         self._insertRunJobStep('xmipp_transform_threshold', maskParams)
     elif self.maskMode == NMA_MASK_FILE:
         fnMask = getImageLocation(self.volumeMask.get())
     return fnMask
Esempio n. 21
0
 def copyDeformationsStep(self, deformationMd):
     copyFile(deformationMd, self.imgsFn)
     # We need to update the image name with the good ones
     # and the same with the ids.
     inputSet = self.inputParticles.get()
     mdImgs = md.MetaData(self.imgsFn)
     for objId in mdImgs:
         imgPath = mdImgs.getValue(md.MDL_IMAGE, objId)
         index, fn = xmippToLocation(imgPath)
         # Conside the index is the id in the input set
         particle = inputSet[index]
         mdImgs.setValue(md.MDL_IMAGE, getImageLocation(particle), objId)
         mdImgs.setValue(md.MDL_ITEM_ID, long(particle.getObjId()), objId)
     mdImgs.write(self.imgsFn)
 def copyDeformationsStep(self, deformationMd):
     copyFile(deformationMd, self.imgsFn)
     # We need to update the image name with the good ones
     # and the same with the ids.
     inputSet = self.inputParticles.get()
     md = xmipp.MetaData(self.imgsFn)
     for objId in md:
         imgPath = md.getValue(xmipp.MDL_IMAGE, objId)
         index, fn = xmippToLocation(imgPath)
         # Conside the index is the id in the input set
         particle = inputSet[index]
         md.setValue(xmipp.MDL_IMAGE, getImageLocation(particle), objId)
         md.setValue(xmipp.MDL_ITEM_ID, long(particle.getObjId()), objId)
     md.write(self.imgsFn)
    def _insertAllSteps(self):                
        convertId = self._insertFunctionStep('convertInputStep', 
                                             self.inputParticles.get().getObjId())
        deps = [] # store volumes steps id to use as dependencies for last step
        commonParams    = self._getCommonParams()
        commonParamsRef = self._getCommonParamsRef()

        sym = self.symmetryGroup.get()
        
        for i, vol in enumerate(self._iterInputVols()):
            
            volName = getImageLocation(vol)
            volDir = self._getVolDir(i+1)
                   
            pmStepId = self._insertFunctionStep('projectionLibraryStep',                                                    
                                                volName, volDir,self.angularSampling.get(),
                                                prerequisites=[convertId])
            
            sigStepId1 = self._insertFunctionStep('significantStep', 
                                                 volName, volDir,
                                                 'exp_particles.xmd',
                                                 commonParams, 
                                                 prerequisites=[pmStepId])
            
            phanProjStepId = self._insertFunctionStep('phantomProject',
                                                 prerequisites=[sigStepId1])

            sigStepId2 = self._insertFunctionStep('significantStep',
                                                 volName, volDir,
                                                 'ref_particles.xmd',
                                                 commonParamsRef, 
                                                 prerequisites=[phanProjStepId])

            if ( not (self.pseudoSymmetryGroup.get() == '') ):
                sym = self.pseudoSymmetryGroup.get()
                
            volStepId = self._insertFunctionStep('alignabilityStep', 
                                                 volName, volDir,
                                                 sym,
                                                 prerequisites=[sigStepId2])
            
            deps.append(volStepId)
          

        self._insertFunctionStep('createOutputStep', 
                                 prerequisites=deps)
    def significantStep(self, isTilt):
        if isTilt == 1:
            params =  '  -i %s' % self._getPath('input_tilted_particles.xmd')
            outputDir = self._getExtraPath("tilted")
        elif isTilt == 0:
            params =  '  -i %s' % self._getPath('input_untilted_particles.xmd')
            outputDir = self._getExtraPath("untilted")
                    
        firstImage = self.inputTiltPair.get().getUntilted().getFirstItem()
        maxShift = 0.35 * firstImage.getDim()[0]
        
        params += ' --sym %s' % self.symmetryGroup.get()
        params += ' --alpha0 %f --alphaF %f' % ((1-self.alpha.get())/100,(1-self.alpha.get())/100)
        params += ' --angularSampling %f' % self.angularSampling.get()
        params += ' --dontReconstruct'
        params += ' --iter 1'
        params += ' --initvolumes %s' % getImageLocation(self.inputVolume.get())  
        params += ' --useForValidation 3'  
        params += ' --maxShift %f' % maxShift
        params += ' --odir %s' % outputDir

        makePath(outputDir)  
        self.runJob('xmipp_reconstruct_significant', params)
 def _insertAllSteps(self):
     inputVol = self.inputStructure.get()
     fnIn = getImageLocation(inputVol)
     fnMask = self._insertMaskStep(fnIn)        
     self._insertFunctionStep('convertToPseudoAtomsStep', fnIn, fnMask, inputVol.getSamplingRate())
     self._insertFunctionStep('createOutputStep')
 def _getSecondVolumeFn(self):
     if self._isSingleInput():
         return getImageLocation(self.inputVolumes2.get())
     else:
         return self._getSecondSetFn()
Esempio n. 27
0
 def _getSecondVolumeFn(self):
     if self._isSingleInput():
         return getImageLocation(self.inputVolumes2.get())
     else:
         return self._getSecondSetFn()