Ejemplo n.º 1
0
 def sleepStep(self, secs=5, forceFail=False, tag=''):
     if forceFail:
         self.runJob('echo', " 'Failing for testing purposes...'; exit 1")
     else:
         from pyworkflow.em.packages.xmipp3 import getEnviron
         self.runJob('xmipp_work_test',
                     "--time %d --tag '%s'" % (secs, tag), env=getEnviron())
Ejemplo n.º 2
0
 def _estimateCTF(self, micFn, micDir, micName):
     """ Run ctffind, 3 or 4, with required parameters """
     # Create micrograph dir 
     pwutils.makePath(micDir)
     downFactor = self.ctfDownFactor.get()
     
     micFnMrc = self._getTmpPath(pwutils.replaceBaseExt(micFn, 'mrc'))
     if downFactor != 1:
         #Replace extension by 'mrc' cause there are some formats that cannot be written (such as dm3)
         import pyworkflow.em.packages.xmipp3 as xmipp3
         self.runJob("xmipp_transform_downsample",
                     "-i %s -o %s --step %f --method fourier" % (micFn, micFnMrc, downFactor),
                     env=xmipp3.getEnviron())
         self._params['scannedPixelSize'] = self.inputMicrographs.get().getScannedPixelSize() * downFactor
     else:
         micFnMrc = self._getTmpPath(pwutils.replaceBaseExt(micFn, "mrc"))
         em.ImageHandler().convert(micFn, micFnMrc, em.DT_FLOAT)
     
     # Update _params dictionary
     self._params['micFn'] = micFnMrc
     self._params['micDir'] = micDir
     self._params['ctffindOut'] = self._getCtfOutPath(micDir)
     self._params['ctffindPSD'] = self._getPsdPath(micDir)
     try:
         self.runJob(self._program, self._args % self._params)
     except Exception, ex:
         print >> sys.stderr, "ctffind has failed with micrograph %s" % micFnMrc
Ejemplo n.º 3
0
def runJavaIJapp(memory, appName, args, env={}):
    from pyworkflow.em.packages import xmipp3
    env.update(xmipp3.getEnviron(xmippFirst=False))

    args = getJavaIJappArguments(memory, appName, args)
    print 'java %s'%args
    return subprocess.Popen('java ' + args, shell=True, env=env)
Ejemplo n.º 4
0
def getNMAEnviron():
    """ Create the needed environment for NMA programs. """
    from pyworkflow.em.packages.xmipp3 import getEnviron

    environ = getEnviron()
    environ.update({"PATH": os.environ["NMA_HOME"]}, position=Environ.BEGIN)
    return environ
Ejemplo n.º 5
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())
Ejemplo n.º 6
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())
Ejemplo n.º 7
0
 def sleepStep(self, secs=5, forceFail=False, tag=''):
     if forceFail:
         self.runJob('echo', " 'Failing for testing purposes...'; exit 1")
     else:
         from pyworkflow.em.packages.xmipp3 import getEnviron
         self.runJob('xmipp_work_test',
                     "--time %d --tag '%s'" % (secs, tag),
                     env=getEnviron())
Ejemplo n.º 8
0
def runJavaIJapp(memory, appName, args, env={}):
    from pyworkflow.em.packages import xmipp3
    env.update(xmipp3.getEnviron(xmippFirst=False))

    args = getJavaIJappArguments(memory, appName, args)
    print 'java %s'%args
    #return subprocess.Popen('java ' + args, shell=True, env=env)
    cmd = ['java'] + shlex.split(args)
    return subprocess.Popen(cmd, env=env)
Ejemplo n.º 9
0
 def createCircularMask(self, radius, refImage, outputFile):
     """ Create a circular mask with the given radius (pixels)
     and with the same dimensions of the refImage.
     The radius should be less or equal dim(refImage)/2
     The mask will be stored in 'outputFile'
     """
     #TODO: right now we need to call an xmipp program to create 
     # the spherical mask, it would be nicer to have such utility in the binding
     import pyworkflow.em.packages.xmipp3 as xmipp3
     xmippEnv = xmipp3.getEnviron()
     inputRef = xmipp3.getImageLocation(refImage)
     runJob(None, 'xmipp_transform_mask', 
                 '-i %s --create_mask  %s --mask circular -%d' % (inputRef, outputFile, radius),
                 env=xmippEnv)
Ejemplo n.º 10
0
    def _estimateCTF(self, micFn, micDir, micName):
        """ Run ctffind, 3 or 4, with required parameters """

        doneFile = os.path.join(micDir, 'done.txt')

        if self.isContinued() and os.path.exists(doneFile):
            return

        try:
            # Create micrograph dir
            pwutils.makePath(micDir)
            downFactor = self.ctfDownFactor.get()
            scannedPixelSize = self.inputMicrographs.get().getScannedPixelSize(
            )
            micFnMrc = self._getTmpPath(pwutils.replaceBaseExt(micFn, 'mrc'))

            if downFactor != 1:
                # Replace extension by 'mrc' because there are some formats
                # that cannot be written (such as dm3)
                import pyworkflow.em.packages.xmipp3 as xmipp3
                args = "-i %s -o %s --step %f --method fourier" % (
                    micFn, micFnMrc, downFactor)
                self.runJob("xmipp_transform_downsample",
                            args,
                            env=xmipp3.getEnviron())
                self._params[
                    'scannedPixelSize'] = scannedPixelSize * downFactor
            else:
                ih = em.ImageHandler()
                if ih.existsLocation(micFn):
                    micFnMrc = self._getTmpPath(
                        pwutils.replaceBaseExt(micFn, "mrc"))
                    ih.convert(micFn, micFnMrc, em.DT_FLOAT)
                else:
                    print >> sys.stderr, "Missing input micrograph %s" % micFn

            # Update _params dictionary
            self._params['micFn'] = micFnMrc
            self._params['micDir'] = micDir
            self._params['ctffindOut'] = self._getCtfOutPath(micDir)
            self._params['ctffindPSD'] = self._getPsdPath(micDir)

        except Exception, ex:
            print >> sys.stderr, "Some error happened: %s" % ex
            import traceback
            traceback.print_exc()
Ejemplo n.º 11
0
def runProgram(program, params):
    env = None

    if program.startswith('xmipp'):
        import pyworkflow.em.packages.xmipp3 as xmipp3
        env = xmipp3.getEnviron()
    if program.startswith('relion'):
        import pyworkflow.em.packages.relion as relion
        env = relion.getEnviron()
    elif (program.startswith('e2') or program.startswith('sx')):
        import pyworkflow.em.packages.eman2 as eman2
        env = eman2.getEnviron()
    elif program.startswith('b'):
        import pyworkflow.em.packages.bsoft as bsoft
        env = bsoft.getEnviron()

    pwutils.runJob(None, program, params, env=env)
Ejemplo n.º 12
0
    def createRandomMicAtep(self, mic):
        from pyworkflow.em.packages.xmipp3 import getEnviron

        # create image
        img = xmipp.Image()
        img.setDataType(xmipp.DT_FLOAT)
        img.resize(self.xDim, self.yDim)
        img.initRandom(0., 1., xmipp.XMIPP_RND_UNIFORM)
        baseFn = self._getExtraPath(self._singleImageFn)
        img.write(baseFn)

        md1 = xmipp.MetaData()
        md1.setColumnFormat(False)
        idctf = md1.addObject()

        baseFnCtf = self._getTmpPath("ctf_%d.param" % mic)
        baseFnImageCTF = self._getExtraPath("imageCTF_%d.xmp" % mic)

        md1.setValue(xmipp.MDL_CTF_SAMPLING_RATE, 1., idctf)
        md1.setValue(xmipp.MDL_CTF_VOLTAGE, 200., idctf)
        defocus = 20000 + 10000 * random.random()
        udefocus = defocus + 1000 * random.random()
        vdefocus = defocus + 1000 * random.random()
        if udefocus < vdefocus:
            aux = vdefocus
            vdefocus = udefocus
            udefocus = aux
        md1.setValue(xmipp.MDL_CTF_DEFOCUSU, udefocus, idctf)
        md1.setValue(xmipp.MDL_CTF_DEFOCUSV, vdefocus, idctf)
        md1.setValue(xmipp.MDL_CTF_DEFOCUS_ANGLE, 180.0 * random.random(),
                     idctf)
        md1.setValue(xmipp.MDL_CTF_CS, 2., idctf)
        md1.setValue(xmipp.MDL_CTF_Q0, 0.07, idctf)
        md1.setValue(xmipp.MDL_CTF_K, 1., idctf)

        md1.write(baseFnCtf)

        # apply ctf
        args = " -i %s" % baseFn
        args += " -o %s" % baseFnImageCTF
        args += " -f ctf %s" % baseFnCtf
        args += " --sampling %f" % self.samplingRate
        self.runJob("xmipp_transform_filter", args, env=getEnviron())
        self.dictObj[baseFnImageCTF] = True
        time.sleep(self.creationInterval.get())
Ejemplo n.º 13
0
    def createRandomMicAtep(self, mic):
        from pyworkflow.em.packages.xmipp3 import getEnviron

        # create image
        img = xmipp.Image()
        img.setDataType(xmipp.DT_FLOAT)
        img.resize(self.xDim, self.yDim)
        img.initRandom(0., 1., xmipp.XMIPP_RND_UNIFORM)
        baseFn = self._getExtraPath(self._singleImageFn)
        img.write(baseFn)

        md1 = xmipp.MetaData()
        md1.setColumnFormat(False)
        idctf = md1.addObject()

        baseFnCtf = self._getTmpPath("ctf_%d.param" % mic)
        baseFnImageCTF = self._getExtraPath("imageCTF_%d.xmp" % mic)

        md1.setValue(xmipp.MDL_CTF_SAMPLING_RATE, 1., idctf)
        md1.setValue(xmipp.MDL_CTF_VOLTAGE, 200., idctf)
        defocus = 20000 + 10000 * random.random()
        udefocus = defocus + 1000 * random.random()
        vdefocus = defocus + 1000 * random.random()
        if udefocus < vdefocus:
            aux = vdefocus
            vdefocus = udefocus
            udefocus = aux
        md1.setValue(xmipp.MDL_CTF_DEFOCUSU, udefocus, idctf)
        md1.setValue(xmipp.MDL_CTF_DEFOCUSV, vdefocus, idctf)
        md1.setValue(xmipp.MDL_CTF_DEFOCUS_ANGLE, 180.0 * random.random(),
                     idctf)
        md1.setValue(xmipp.MDL_CTF_CS, 2., idctf)
        md1.setValue(xmipp.MDL_CTF_Q0, 0.07, idctf)
        md1.setValue(xmipp.MDL_CTF_K, 1., idctf)

        md1.write(baseFnCtf)

        # apply ctf
        args = " -i %s" % baseFn
        args += " -o %s" % baseFnImageCTF
        args += " -f ctf %s" % baseFnCtf
        args += " --sampling %f" % self.samplingRate
        self.runJob("xmipp_transform_filter", args, env=getEnviron())
        self.dictObj[baseFnImageCTF] = True
        time.sleep(self.creationInterval.get())
Ejemplo n.º 14
0
def runProgram(program, params):
    env = None

    if program.startswith('xmipp'):
        import pyworkflow.em.packages.xmipp3 as xmipp3
        env = xmipp3.getEnviron()
    if program.startswith('relion'):
        import pyworkflow.em.packages.relion as relion
        env = relion.getEnviron()
    elif (program.startswith('e2') or
              program.startswith('sx')):
        import pyworkflow.em.packages.eman2 as eman2
        env = eman2.getEnviron()
    elif program.startswith('b'):
        import pyworkflow.em.packages.bsoft as bsoft
        env = bsoft.getEnviron()

    pwutils.runJob(None, program, params, env=env)
Ejemplo n.º 15
0
    def _estimateCTF(self, micFn, micDir, micName):
        """ Run ctffind, 3 or 4, with required parameters """

        doneFile = os.path.join(micDir, 'done.txt')

        if self.isContinued() and os.path.exists(doneFile):
            return

        try:
            # Create micrograph dir
            pwutils.makePath(micDir)
            downFactor = self.ctfDownFactor.get()
            scannedPixelSize = self.inputMicrographs.get().getScannedPixelSize()
            micFnMrc = self._getTmpPath(pwutils.replaceBaseExt(micFn, 'mrc'))

            if downFactor != 1:
                # Replace extension by 'mrc' because there are some formats
                # that cannot be written (such as dm3)
                import pyworkflow.em.packages.xmipp3 as xmipp3
                args = "-i %s -o %s --step %f --method fourier" % (micFn, micFnMrc, downFactor)
                self.runJob("xmipp_transform_downsample",
                            args, env=xmipp3.getEnviron())
                self._params['scannedPixelSize'] =  scannedPixelSize * downFactor
            else:
                ih = em.ImageHandler()
                if ih.existsLocation(micFn):
                    micFnMrc = self._getTmpPath(pwutils.replaceBaseExt(micFn, "mrc"))
                    ih.convert(micFn, micFnMrc, em.DT_FLOAT)
                else:
                    print >> sys.stderr, "Missing input micrograph %s" % micFn

            # Update _params dictionary
            self._params['micFn'] = micFnMrc
            self._params['micDir'] = micDir
            self._params['ctffindOut'] = self._getCtfOutPath(micDir)
            self._params['ctffindPSD'] = self._getPsdPath(micDir)

        except Exception, ex:
            print >> sys.stderr, "Some error happened: %s" % ex
            import traceback
            traceback.print_exc()
Ejemplo n.º 16
0
 def createOutputStep(self):
     inputAverages = self.inputAverages.get()
     imgxdim = inputAverages.getXDim()
     fnVol = self._getExtraPath("refine.mrc")
     volxdim, _, _, _ = em.ImageHandler().getDimensions(fnVol)
     
     if imgxdim != volxdim:
         fnVolOut = self._getPath("volume.vol")
         args3 = "-i %s --dim %d -o %s"%(fnVol, imgxdim, fnVolOut)
         #TODO maybe change later using Python binding to resize images
         import pyworkflow.em.packages.xmipp3 as xmipp3
         self.runJob("xmipp_image_resize", args3, env=xmipp3.getEnviron())
     else:
         fnVolOut = fnVol
     
     vol = em.Volume()
     vol.setLocation(fnVolOut)
     vol.setSamplingRate(inputAverages.getSamplingRate())
     
     self._defineOutputs(outputVol=vol)       
     self._defineSourceRelation(self.inputAverages, vol)
Ejemplo n.º 17
0
    def createOutputStep(self):
        inputAverages = self.inputAverages.get()
        imgxdim = inputAverages.getXDim()
        fnVol = self._getExtraPath("refine.mrc")
        volxdim, _, _, _ = em.ImageHandler().getDimensions(fnVol)

        if imgxdim != volxdim:
            fnVolOut = self._getPath("volume.vol")
            args3 = "-i %s --dim %d -o %s" % (fnVol, imgxdim, fnVolOut)
            #TODO maybe change later using Python binding to resize images
            import pyworkflow.em.packages.xmipp3 as xmipp3
            self.runJob("xmipp_image_resize", args3, env=xmipp3.getEnviron())
        else:
            fnVolOut = fnVol

        vol = em.Volume()
        vol.setLocation(fnVolOut)
        vol.setSamplingRate(inputAverages.getSamplingRate())

        self._defineOutputs(outputVol=vol)
        self._defineSourceRelation(self.inputAverages, vol)
Ejemplo n.º 18
0
"""

import sys
import pyworkflow.utils as pwutils



if __name__ == '__main__':

    program = sys.argv[1]
    params = ' '.join('"%s"' % x for x in sys.argv[2:])
    
    env = None
    
    if program.startswith('xmipp'):
        import pyworkflow.em.packages.xmipp3 as xmipp3
        env = xmipp3.getEnviron()
    if program.startswith('relion'):
        import pyworkflow.em.packages.relion as relion
        env = relion.getEnviron()        
    elif (program.startswith('e2') or 
          program.startswith('sx')):
        import pyworkflow.em.packages.eman2 as eman2
        env = eman2.getEnviron()
    elif program.startswith('b'):
        import pyworkflow.em.packages.bsoft as bsoft
        env = bsoft.getEnviron()
    
    pwutils.runJob(None, program, params, env=env)
         
Ejemplo n.º 19
0
# *
# **************************************************************************
"""
Launch main project window 
"""

import sys
import pyworkflow.utils as pwutils

if __name__ == '__main__':

    program = sys.argv[1]
    params = ' '.join('"%s"' % x for x in sys.argv[2:])

    env = None

    if program.startswith('xmipp'):
        import pyworkflow.em.packages.xmipp3 as xmipp3
        env = xmipp3.getEnviron()
    if program.startswith('relion'):
        import pyworkflow.em.packages.relion as relion
        env = relion.getEnviron()
    elif (program.startswith('e2') or program.startswith('sx')):
        import pyworkflow.em.packages.eman2 as eman2
        env = eman2.getEnviron()
    elif program.startswith('b'):
        import pyworkflow.em.packages.bsoft as bsoft
        env = bsoft.getEnviron()

    pwutils.runJob(None, program, params, env=env)
Ejemplo n.º 20
0
def getNMAEnviron():
    """ Create the needed environment for NMA programs. """
    from pyworkflow.em.packages.xmipp3 import getEnviron
    environ = getEnviron()
    environ.update({'PATH': os.environ['NMA_HOME']}, position=Environ.BEGIN)
    return environ
Ejemplo n.º 21
0
 def __runXmippProgram(self, program, args):
     """ Internal shortcut function to launch a Xmipp program. """
     import pyworkflow.em.packages.xmipp3 as xmipp3
     xmippEnv = xmipp3.getEnviron()
     runJob(None, program, args, env=xmippEnv)