def summary(self):
        message=ProtInitVolumeBase.summary(self)
        message.append("RANSAC iterations: %d"%self.NRansac)
        
        for n in range(self.NumVolumes):

            fnBase='volumeProposed%05d'%n
            fnRoot=self.workingDirPath(fnBase+".xmd")
                           
            if os.path.isfile(fnRoot):
                md=MetaData(fnRoot)
                if (md.size()< 5) :
                    message.append("Num of inliers for %s too small and equal to %d"%(fnRoot,md.size()))
                    message.append("Decrease the value of Inlier Threshold parameter and run again")
                                
        fnBase="ransac00000.xmd"
        fnRoot=self.workingDirPath("tmp/"+fnBase)    
        
        if os.path.isfile(fnRoot):
            md=MetaData(fnRoot)
        
            if (md.size()< 5) :
                message.append("Num of random samples too small and equal to %d"%(md.size()))
                message.append("If the option Dimensionality reduction is on, increase the number of grids per dimension")
                message.append("If the option Dimensionality reduction is off, increase the number of random samples")
            
        if self.UseSA:
            message.append("Simulated annealing used")
        return message
예제 #2
0
    def __init__(self, filename=None):
        self._md = MetaData()
        self._md.setColumnFormat(False)
        self._id = self._md.addObject()

        if filename:
            self.read(filename)
def getBestVolumes(log,WorkingDir,NRansac,NumVolumes,UseAll):
    volumes = []
    inliers = []
    
    for n in range(NRansac):
        fnAngles = os.path.join(WorkingDir,"tmp/angles_ransac%05d"%n+".xmd")
        md=MetaData("inliers@"+fnAngles)
        numInliers=md.getValue(MDL_WEIGHT,md.firstObject())
        volumes.append(fnAngles)
        inliers.append(numInliers)
    
    index = sorted(range(inliers.__len__()), key=lambda k: inliers[k])
    fnBestAngles = ''
    threshold=getCCThreshold(WorkingDir)
 
    i=NRansac-1
    indx = 0
    while i>=0 and indx<NumVolumes:
        fnBestAngles = volumes[index[i]]
        fnBestAnglesOut=os.path.join(WorkingDir,"volumeProposed%05d"%indx+".xmd")
        copyFile(log,fnBestAngles,fnBestAnglesOut)
        print("Best volume "+str(indx)+" = "+fnBestAngles)
        if not UseAll:
            runJob(log,"xmipp_metadata_utilities","-i %s -o %s --query select \"maxCC>%f \" --mode append" %(fnBestAnglesOut,fnBestAnglesOut,threshold))
            if getMdSize(fnBestAnglesOut) > 0:
                indx += 1
        else:
            indx += 1
        i -= 1
        
    # Remove unnecessary files
    for n in range(NRansac):
        fnAngles = os.path.join(WorkingDir,"tmp/angles_ransac%05d"%n+".xmd")
        deleteFile(log, fnAngles)
예제 #4
0
    def summary(self):
        _, _, _, _, size = MetaDataInfo(self.ImgMd)
        lines = ["Input images:  [%s] (<%u>)" % (self.ImgMd, size)]

        if self.DoMlf:
            if self.DoCorrectAmplitudes:
                suffix = "with CTF correction "
            else:
                suffix = "ignoring CTF effects "
            lines.append("Using a ML in <Fourier-space> " + suffix)
        
        if self.DoGenerateReferences:
            lines.append("Number of references: <%d>" % self.NumberOfReferences)
        else:
            lines.append("Reference image(s): [%s]" % self.RefMd)
        
        
        #logs = self.getFilename('iter_logs')   
        lastIter = lastIteration(self) 
        if lastIter > 0:#exists(logs):
            logs = self.getFilename('iter_logs', iter=lastIter)
            md = MetaData(logs)
            id = md.lastObject()
            #iteration = md.getValue(MDL_ITER, id)
            lines.append("Last iteration:  <%d>" % lastIter)
            LL = md.getValue(MDL_LL, id)
            lines.append("LogLikelihood:  %f" % LL)
            mdRefs = self.getFilename('iter_refs', iter=lastIter)
            lines.append("Last classes: [%s]" % mdRefs)

        return lines
예제 #5
0
    def launchProjSubPlots(self, selectedPlots):
        ''' Launch some plots for a Projection Matching protocol run '''
        import numpy as np
        _log = self.Log

        xplotter=None
        self._plot_count = 0
        
        def doPlot(plotName):
            return plotName in selectedPlots
        
        file_name_tmp = join(self.CtfGroupDirectoryName, self.CtfGroupRootName) +'Info.xmd'
        file_name = join(self.PrevRun.WorkingDir, file_name_tmp)
                         
        if exists(file_name):
            auxMD = MetaData("numberGroups@"+file_name)
            self.NumberOfCtfGroups = auxMD.getValue(MDL_COUNT,auxMD.firstObject())
        else:
            self.NumberOfCtfGroups = 1
            
        
        if doPlot('DisplayReference'):
            for indexCtf in range(1, self.NumberOfCtfGroups+1): 
                file_name = self.getFilename('SubtractedStack', ctf=indexCtf)+'ref'
                    
                if exists(file_name):
                    try:
                        runShowJ(file_name)
                    except Exception, e:
                        showError("Error launching java app", str(e), self.master)
예제 #6
0
 def validate(self):
     errors = []
     N1=getMdSize(self.Operand1)
     Operation=self.Operation
     checkDimensions=False
     if Operation=='column' or Operation=='slice' or Operation=='row':
         if not self.Operand2.isdigit():
             errors.append('You should give a number for the column, slice or row')
     elif Operation=='dot product':
         if self.Operand2.isdigit():
             errors.append('Second operand cannot be a number')
         else:
             checkDimensions=True
     elif Operation=='plus' or Operation=='minus' or Operation=='multiply' or Operation=='divide' or Operation=='minimum' or \
        Operation=='maximum':
         if not self.Operand2.isdigit():
             checkDimensions=True
     if checkDimensions:
         md1=MetaData(self.Operand1)
         md2=MetaData(self.Operand2)
         x1, y1, z1, _, _ = MetaDataInfo(md1)    
         x2, y2, z2, _, _ = MetaDataInfo(md2)
         if x1!=x2 or y1!=y2 or z1!=z2:
             errors.append("Image/Volume sizes in the two operands are not the same")    
         if md2.size()>1:
             if md2.size()!=md1.size():
                 errors.append("The number of images/volumes in the two operands are not the same")
     return errors
예제 #7
0
 def __init__(self, scriptname, project):
     XmippProtocol.__init__(self, protDict.ml2d.name, scriptname, project)
     self.Import = 'from protocol_ml2d import *'
     self.acquisionInfo = self.findAcquisitionInfo(self.ImgMd)
     if not self.acquisionInfo is None: 
         md = MetaData(self.acquisionInfo)
         self.SamplingRate = md.getValue(MDL_SAMPLINGRATE, md.firstObject())
예제 #8
0
    def createOutput(self):
        import glob

        levelFiles = glob.glob(self._getExtraPath("results_classes_level*.xmd"))
        if levelFiles:
            levelFiles.sort()
            lastLevelFile = levelFiles[-1]
            setOfClasses = self._createSetOfClassesVol()
            setOfClasses.setImages(self.inputVolumes.get())
            readSetOfClassesVol(setOfClasses, lastLevelFile)
            self._defineOutputs(outputClasses=setOfClasses)
            self._defineSourceRelation(self.inputVolumes, self.outputClasses)
        if self.generateAligned.get():
            setOfVolumes = self._createSetOfVolumes()
            fnAligned = self._getExtraPath("results_aligned.xmd")
            self.runJob(
                "xmipp_metadata_selfile_create",
                "-p %s -o %s -s" % (self._getExtraPath("results_aligned.stk"), fnAligned),
            )
            md = MetaData(fnAligned)
            md.addItemId()
            md.write(fnAligned)
            readSetOfVolumes(fnAligned, setOfVolumes)
            volumeList = self.inputVolumes.get()
            setOfVolumes.setSamplingRate(volumeList.getSamplingRate())
            self._defineOutputs(alignedVolumes=setOfVolumes)
            self._defineTransformRelation(self.inputVolumes, self.alignedVolumes)
예제 #9
0
def wizardBrowseCTF2(gui, var):
    error = None
    vList = ['LowResolCutoff', 'HighResolCutoff']
    freqs = gui.getVarlistValue(vList)
    importRunName = gui.getVarValue('ImportRun')
    prot = gui.project.getProtocolFromRunName(importRunName)
    path = prot.WorkingDir
    if path and exists(path):
        mdPath = prot.getFilename('micrographs')
        if exists(mdPath):
            from xmipp import MetaData, MDL_MICROGRAPH
            md = MetaData(mdPath)
            if md.size():
                image = md.getValue(MDL_MICROGRAPH, md.firstObject())     
                if image:         
                    filterExt = "*" + splitext(image)[1]
                    value = gui.getVarValue('DownsampleFactor')
                    results = wizardHelperSetDownsampling(gui, var, path, filterExt, value, freqs, md)
                    if results:
                        gui.setVarlistValue(vList, results[1:])
                else:
                    error = "Not micrograph found in metadata <%s>" % mdPath
                    #gui.setVarValue('LowResolCutoff', results[1])
                    #gui.setVarValue('HighResolCutoff', results[2])
            else:
                error = "Micrograph metadata <%s> is empty" % mdPath
        else:
            error = "Micrograph metadata <%s> doesn't exists" % mdPath
    else:
        error = "Import run <%s> doesn't exists" % str(path)
    if error:
        showWarning("Select Downsampling Wizard", error, gui.master)
        return None
    else:
        return results
예제 #10
0
def wizardDesignMask(gui, var):
    selfile = gui.getVarValue('InSelFile')
    ##workingDir = getWorkingDirFromRunName(gui.getVarValue('RunName'))
    from xmipp import MetaData, MDL_IMAGE
    md = MetaData(selfile)
    fnImg = md.getValue(MDL_IMAGE, md.firstObject())
    #runShowJ(fnImg, extraParams="--mask_toolbar")
    runMaskToolbar(fnImg)
예제 #11
0
def mdFirstRow(filename):
    """ Create a MetaData but only read the first row.
    This method should be used for validations of labels
    or metadata size, but the full metadata is not needed.
    """
    md = MetaData()
    md.read(filename, 1)
    
    return md
예제 #12
0
 def runSymmetrize(self, fnVol, dihedral, fnParams, fnOut, cylinderRadius, height):
     md=MetaData(fnParams)
     objId=md.firstObject()
     rot0=md.getValue(MDL_ANGLE_ROT,objId)
     z0=md.getValue(MDL_SHIFT_Z,objId)
     args="-i %s --sym %s --helixParams %f %f -o %s"%(fnVol,self.getSymmetry(dihedral),z0,rot0,fnOut)
     self.runJob('xmipp_transform_symmetrize',args)
     if cylinderRadius>0:
         args="-i %s --mask cylinder %d %d"%(fnOut,-cylinderRadius,-height)
         self.runJob('xmipp_transform_mask',args)
예제 #13
0
 def runFineSearch(self, fnVol, dihedral, fnCoarse, fnFine, z0, zF, rot0, rotF, cylinderRadius, height):
     md=MetaData(fnCoarse)
     objId=md.firstObject()
     rotInit=md.getValue(MDL_ANGLE_ROT,objId)
     zInit=md.getValue(MDL_SHIFT_Z,objId)
     args="-i %s --sym %s --localHelical %f %f -o %s -z %f %f 1 --rotHelical %f %f 1 "%(fnVol,self.getSymmetry(dihedral),
                                                                                        zInit,rotInit,fnFine,z0,zF,rot0,rotF)
     if cylinderRadius>0:
         args+=" --mask cylinder %d %d"%(-cylinderRadius,-height)
     self.runJob('xmipp_volume_find_symmetry',args)
예제 #14
0
def extractDeformations(log, WorkingDir):
    MD = MetaData(os.path.join(WorkingDir, "images.xmd"))
    deformations = MD.getColumnValues(MDL_NMA)
    fnDef = os.path.join(WorkingDir, "extra/deformations.txt")
    fhDef = open(fnDef, "w")
    for deformation in deformations:
        for coef in deformation:
            fhDef.write("%f " % coef)
        fhDef.write("\n")
    fhDef.close()
예제 #15
0
 def _plotFSC(self, a, fnFSC):
     md = MetaData(fnFSC)
     resolution_inv = [md.getValue(MDL_RESOLUTION_FREQ, f) for f in md]
     frc = [md.getValue(MDL_RESOLUTION_FRC, f) for f in md]
     self.maxFrc = max(frc)
     self.minInv = min(resolution_inv)
     self.maxInv = max(resolution_inv)
     a.plot(resolution_inv, frc)
     a.xaxis.set_major_formatter(self._plotFormatter)
     a.set_ylim([-0.1, 1.1])
 def _plotFSC(self, a, fnFSC):
     md = MetaData(fnFSC)
     resolution_inv = [md.getValue(MDL_RESOLUTION_FREQ, f) for f in md]
     frc = [md.getValue(MDL_RESOLUTION_FRC, f) for f in md]
     self.maxFrc = max(frc)
     self.minInv = min(resolution_inv)
     self.maxInv = max(resolution_inv)
     a.plot(resolution_inv, frc)
     a.xaxis.set_major_formatter(self._plotFormatter)
     a.set_ylim([-0.1, 1.1])
예제 #17
0
def createMetaDataFromPattern(pattern, isStack=False, label="image"):
    ''' Create a metadata from files matching pattern'''
    import glob
    files = glob.glob(pattern)
    files.sort()

    from xmipp import MetaData, FileName, getImageSize, MDL_ENABLED, str2Label
    label = str2Label(label) #Check for label value
    
    mD = MetaData()
    inFile = FileName()
    
    nSize = 1
    for file in files:
        fileAux=file
        if isStack:
            if file.endswith(".mrc"):
                fileAux=file+":mrcs"
            x, x, x, nSize = getImageSize(fileAux)
        if nSize != 1:
            counter = 1
            for jj in range(nSize):
                inFile.compose(counter, fileAux)
                objId = mD.addObject()
                mD.setValue(label, inFile, objId)
                mD.setValue(MDL_ENABLED, 1, objId)
                counter += 1
        else:
            objId = mD.addObject()
            mD.setValue(label, fileAux, objId)
            mD.setValue(MDL_ENABLED, 1, objId)
    return mD
예제 #18
0
 def validate(self):
     errors = []
     inputExt=os.path.splitext(self.InputFile)[1]
     if not inputExt in ['.mrc','.stk','.sel','.xmd','.hed','.img', '.ctfdat']:
         errors.append("Input file must be stack or metadata (valid extensions are .mrc, .stk, .sel, .xmd, .hed, .img, .ctfdat")
     else:
         if inputExt in ['.sel', '.xmd', '.ctfdat']:
             md = MetaData(self.InputFile)
             if not md.containsLabel(MDL_IMAGE):
                 errors.append("Cannot find label for images in the input file")
     return errors
예제 #19
0
 def getAngles(self, fnAngles=""):
     if fnAngles=="":
         if self.searchMode.get()==self.GLOBAL_SEARCH:
             fnAngles = self._getExtraPath("coarse.xmd")
         else:
             fnAngles = self._getExtraPath("fine.xmd")
     md = MetaData(fnAngles)
     objId = md.firstObject()
     rot0 = md.getValue(MDL_ANGLE_ROT, objId)
     tilt0 = md.getValue(MDL_ANGLE_TILT, objId)
     return (rot0,tilt0)
예제 #20
0
def createSubset(log, inputFile, inputFileLabel, subsetFile, subsetFileLabel, outputFile):
    mdInputFile  = MetaData(inputFile)
    mdSubsetFile = MetaData(subsetFile)
    mdOutputFile = MetaData()
    print inputFile, inputFileLabel, subsetFile, subsetFileLabel, outputFile
    mdOutputFile.join2(  mdInputFile
                       , mdSubsetFile
                       , str2Label(inputFileLabel)
                       , str2Label(subsetFileLabel)
                       , INNER_JOIN)
    mdOutputFile.write(outputFile)
예제 #21
0
def symmetrize(log,WorkingDir,InputVolume,OutputVolume,CylinderRadius,fnFine):
    md=MetaData(fnFine)
    id=md.firstObject()
    rot0=md.getValue(MDL_ANGLE_ROT,id)
    z0=md.getValue(MDL_SHIFT_Z,id)
    args="-i %s --sym helical --helixParams %f %f -o %s"%(InputVolume,z0,rot0,OutputVolume)
    runJob(log,'xmipp_transform_symmetrize',args)
    if CylinderRadius>0:
        [xdim,ydim,zdim,ndim]=getImageSize(InputVolume)
        args="-i %s --mask cylinder %d %d"%(OutputVolume,int(-CylinderRadius),int(-xdim))
        runJob(log,'xmipp_transform_mask',args)
예제 #22
0
def fineSearch(log,WorkingDir,InputVolume,CylinderRadius,fnCoarse,Rot0, RotF, Z0, ZF,fnFine):
    md=MetaData(fnCoarse)
    id=md.firstObject()
    rot0=md.getValue(MDL_ANGLE_ROT,id)
    z0=md.getValue(MDL_SHIFT_Z,id)
    args="-i %s --sym helical -z %f %f --rotHelical %f %f --localHelical %f %f -o %s"%(InputVolume,float(Z0),float(ZF),
                                                                                       float(Rot0),float(RotF),z0,rot0,fnFine)
    if CylinderRadius>0:
        [xdim,ydim,zdim,ndim]=getImageSize(InputVolume)
        args+=" --mask cylinder %d %d"%(int(-CylinderRadius),int(-xdim))
    runJob(log,'xmipp_volume_find_symmetry',args)
 def createOutput(self):
     volume = Volume()
     volume.setFileName(self._getPath('volume_symmetrized.vol'))
     #volume.setSamplingRate(self.inputVolume.get().getSamplingRate())
     volume.copyInfo(self.inputVolume.get())
     self._defineOutputs(outputVolume=volume)
     self._defineTransformRelation(self.inputVolume, self.outputVolume)
     
     md = MetaData(self._getExtraPath('fineParams.xmd'))
     objId = md.firstObject()
     self._defineOutputs(deltaRot=pwobj.Float(md.getValue(MDL_ANGLE_ROT, objId)),
                         deltaZ=pwobj.Float(md.getValue(MDL_SHIFT_Z, objId)))
예제 #24
0
def rewriteClassBlock(log,WorkingDir,ExtraDir):
    fnClassMetadata=os.path.join(ExtraDir,"kerdensom_classes.xmd")
    fnClass="classes@%s"%fnClassMetadata
    fnClassStack=os.path.join(ExtraDir,"classes.stk")
    mD = MetaData(fnClass)
    counter = 1
    for id in mD:
        mD.setValue(MDL_IMAGE,"%06d@%s"%(counter,fnClassStack),id)
        counter += 1
    mD.write(fnClass,MD_APPEND)
    createLink(log,fnClassMetadata,os.path.join(WorkingDir,"classes.xmd"))
    createLink(log,os.path.join(ExtraDir,"kerdensom_images.xmd"),os.path.join(WorkingDir,"images.xmd"))
예제 #25
0
 def validate(self):
     errors = []
     if self.NumberOfInitialReferences>self.NumberOfReferences:
         errors.append("The number of initial classes cannot be larger than the number of final classes")
     mD = MetaData()
     mD.read(self.InSelFile, 1)
     
     if not mD.containsLabel(MDL_IMAGE):
         errors.append("%s does not contain a column of images" % self.InSelFile)
     if self.Tolerance < 0:
         errors.append("Tolerance must be larger than 0")
     return errors
예제 #26
0
    def visualize(self):
        from protlib_gui_figure import XmippArrayPlotter1D, XmippArrayPlotter2D, XmippArrayPlotter3D

        components = self.DisplayRawDeformation.split()
        dim = len(components)
        if dim > 0:
            modeList = []
            modeNameList = []
            # Get modes
            MD = MetaData(self.Modesfile)
            MD.removeDisabled()
            for modeComponent in components:
                mode = int(modeComponent)
                if mode > MD.size():
                    from protlib_gui_ext import showWarning

                    showWarning("Warning", "You don't have so many modes", parent=self.master)
                else:
                    mode -= 1
                    currentMode = 0
                    modeName = ""
                    for id in MD:
                        modeName = MD.getValue(MDL_NMA_MODEFILE, id)
                        currentMode += 1
                        if currentMode > mode:
                            break
                    modeNameList.append(modeName)
                    modeList.append(mode)

            # Actually plot
            if dim == 1:
                XmippArrayPlotter1D(
                    self.extraPath("deformations.txt"),
                    modeList[0],
                    "Histogram for mode %s" % modeNameList[0],
                    "Deformation value",
                    "Number of images",
                )
            elif dim == 2:
                XmippArrayPlotter2D(
                    self.extraPath("deformations.txt"), modeList[0], modeList[1], "", modeNameList[0], modeNameList[1]
                )
            elif dim == 3:
                XmippArrayPlotter3D(
                    self.extraPath("deformations.txt"),
                    modeList[0],
                    modeList[1],
                    modeList[2],
                    "",
                    modeNameList[0],
                    modeNameList[1],
                    modeNameList[2],
                )
예제 #27
0
파일: xmipp3.py 프로젝트: I2PC/scipion
 def runFineSearch(self, fnVol, dihedral, fnCoarse, fnFine, heightFraction, z0, zF, rot0, rotF, cylinderInnerRadius, cylinderOuterRadius, height, Ts):
     md=MetaData(fnCoarse)
     objId=md.firstObject()
     rotInit=md.getValue(MDL_ANGLE_ROT,objId)
     zInit=md.getValue(MDL_SHIFT_Z,objId)
     args="-i %s --sym %s --heightFraction %f --localHelical %f %f -o %s -z %f %f 1 --rotHelical %f %f 1 --sampling %f"%(fnVol,self.getSymmetry(dihedral),heightFraction,
                                                                                        zInit,rotInit,fnFine,z0,zF,rot0,rotF,Ts)
     if cylinderOuterRadius>0 and cylinderInnerRadius<0:
         args+=" --mask cylinder %d %d"%(-cylinderOuterRadius,-height)
     elif cylinderOuterRadius>0 and cylinderInnerRadius>0:
         args+=" --mask tube %d %d %d"%(-cylinderInnerRadius,-cylinderOuterRadius,-height)
     self.runJob('xmipp_volume_find_symmetry',args, numberOfMpi=1)
예제 #28
0
def wizardBrowseCTF(gui, var):    
    importRunName = gui.getVarValue('ImportRun')
    downsample = gui.getVarValue('DownsampleFactor')
    prot = gui.project.getProtocolFromRunName(importRunName)
    path = prot.WorkingDir
    md = MetaData()
    fnMicrographs = join(path, "micrographs.xmd")
    if exists(fnMicrographs):
        md.read(fnMicrographs)
    fnMicrographs = join(path, "tilted_pairs.xmd")
    if exists(fnMicrographs):
        md.read(fnMicrographs)
    wizardHelperSetDownsampling(gui, var, '.', None, downsample, md=md)
예제 #29
0
def sortClasses(log,ExtraDir,Nproc,suffix):
    if Nproc==1:
        Nproc=2
    if Nproc>8:
        Nproc=8
    for filename in glob.glob(os.path.join(ExtraDir,"level_??/level_classes%s.xmd"%suffix)):
        level=int(re.search('level_(\d\d)',filename).group(1))
        fnRoot=os.path.join(ExtraDir,"level_%02d/level_classes%s_sorted"%(level,suffix))
        params= "-i classes@"+filename+" --oroot "+fnRoot
        runJob(log,"xmipp_image_sort",params,Nproc)
        mD=MetaData(fnRoot+".xmd")
        mD.write("classes_sorted@"+filename,MD_APPEND)
        deleteFile(log,fnRoot+".xmd")
예제 #30
0
 def summary(self):
     message=[]
     message.append("Input volume: [%s] "%self.InputVolume)
     if os.path.exists(self.fnSym):
         message.append("Symmetrized volume: [%s] "%self.fnSym)
     if os.path.exists(self.fnFine):
         md=MetaData(self.fnFine)
         id=md.firstObject()
         rot0=md.getValue(MDL_ANGLE_ROT,id)
         z0=md.getValue(MDL_SHIFT_Z,id)
         message.append("DeltaRot=%f"%rot0)
         message.append("DeltaZ=%f"%z0)
     return message
예제 #31
0
def wizardChooseSizeToExtract(gui, var):
    from xmipp import MDL_PICKING_PARTICLE_SIZE, MDL_CTF_MODEL, MDL_SAMPLINGRATE, MDL_SAMPLINGRATE_ORIGINAL
    from protlib_gui_ext import ListboxDialog
    pickingRun = gui.getVarValue('PickingRun')
    pickingProt = gui.project.getProtocolFromRunName(pickingRun)
    fnConfig = pickingProt.getFilename("config")  
    if not exists(fnConfig):
        showWarning("Warning", "No elements to select", parent=gui.master)
        return
    md = MetaData(fnConfig)
    particleSize = md.getValue(MDL_PICKING_PARTICLE_SIZE, md.firstObject())
    type = gui.getVarValue("DownsampleType")
    mdAcquisition = MetaData(pickingProt.getFilename('acquisition'))
    objId = mdAcquisition.firstObject()
    tsOriginal = tsPicking = mdAcquisition.getValue(MDL_SAMPLINGRATE, objId)
    
    if mdAcquisition.containsLabel(MDL_SAMPLINGRATE_ORIGINAL):
        tsOriginal = mdAcquisition.getValue(MDL_SAMPLINGRATE_ORIGINAL, objId)
    
    if type == "same as picking":
        factor = 1
    else:
        factor = tsPicking / tsOriginal;
        if type == "other":
            try:
                factor /= float(gui.getVarValue("DownsampleFactor"))
            except Exception, e:
                showWarning("Warning", "Please select valid downsample factor", parent=gui.master)
                return
    def createOutput(self):
        volume = Volume()
        volume.setFileName(self._getPath('volume_symmetrized.vol'))
        #volume.setSamplingRate(self.inputVolume.get().getSamplingRate())
        volume.copyInfo(self.inputVolume.get())
        self._defineOutputs(outputVolume=volume)
        self._defineTransformRelation(self.inputVolume, self.outputVolume)

        md = MetaData(self._getExtraPath('fineParams.xmd'))
        objId = md.firstObject()
        self._defineOutputs(deltaRot=pwobj.Float(
            md.getValue(MDL_ANGLE_ROT, objId)),
                            deltaZ=pwobj.Float(md.getValue(MDL_SHIFT_Z,
                                                           objId)))
예제 #33
0
    def defineSteps(self):
        self.insertStep("createDir", path=self.ExtraDir)
        pickingDir = getWorkingDirFromRunName(self.ExtractionRun)
        self.insertStep("createLink2", filename="acquisition_info.xmd", dirSrc=pickingDir, dirDest=self.WorkingDir)

        classSelection = getListFromRangeString(self.SelectedClasses)
        fnRCTClasses = self.extraPath("rct_classes.xmd")
        self.insertStep(
            "gatherPairs",
            verifyfiles=[fnRCTClasses],
            WorkingDir=self.WorkingDir,
            ExtraDir=self.ExtraDir,
            ClassSelection=classSelection,
            ClassFile=self.ClassifMd,
            ExtractDir=self.ExtractDir,
            PickingDir=pickingDir,
        )

        mdClasses = MetaData("classes@" + self.ClassifMd)
        hasImage = mdClasses.containsLabel(MDL_IMAGE)

        for classId in mdClasses:
            classNo = mdClasses.getValue(MDL_REF, classId)
            if classNo in classSelection:
                # Locate class representative
                classImage = ""
                if hasImage:
                    classImage = mdClasses.getValue(MDL_IMAGE, classId)
                classNameIn = "class%06d_images@%s" % (classNo, fnRCTClasses)
                classNameOut = self.extraPath("rct_images_%06d.xmd" % classNo)
                classVolumeOut = self.workingDirPath("rct_%06d.vol" % classNo)
                self.insertParallelStep(
                    "reconstructClass",
                    verifyfiles=[classNameOut, classVolumeOut],
                    WorkingDir=self.WorkingDir,
                    ExtraDir=self.ExtraDir,
                    ClassNameIn=classNameIn,
                    ClassNameOut=classNameOut,
                    ClassImage=classImage,
                    CenterMaxShift=self.CenterMaxShift,
                    ThinObject=self.ThinObject,
                    SkipTiltedTranslations=self.SkipTiltedTranslations,
                    ClassVolumeOut=classVolumeOut,
                    ReconstructAdditionalParams=self.ReconstructAdditionalParams,
                    DoLowPassFilter=self.DoLowPassFilter,
                    LowPassFilter=self.LowPassFilter,
                    parent_step_id=XmippProjectDb.FIRST_STEP,
                )
예제 #34
0
 def plotMdFile(self, mdFilename, mdLabelX, mdLabelY, color='g', **args):
     """ plot metadataFile columns mdLabelX and mdLabelY
         if nbins is in args then and histogram over y data is made
     """
     from xmipp import MetaData
     md = MetaData(mdFilename)
     self.plotMd(md, mdLabelX, mdLabelY, color='g', **args)
예제 #35
0
 def runFineSearch(self, fnVol, dihedral, fnCoarse, fnFine, heightFraction,
                   z0, zF, rot0, rotF, cylinderInnerRadius,
                   cylinderOuterRadius, height, Ts):
     md = MetaData(fnCoarse)
     objId = md.firstObject()
     rotInit = md.getValue(MDL_ANGLE_ROT, objId)
     zInit = md.getValue(MDL_SHIFT_Z, objId)
     args = "-i %s --sym %s --heightFraction %f --localHelical %f %f -o %s -z %f %f 1 --rotHelical %f %f 1 --sampling %f" % (
         fnVol, self.getSymmetry(dihedral), heightFraction, zInit, rotInit,
         fnFine, z0, zF, rot0, rotF, Ts)
     if cylinderOuterRadius > 0 and cylinderInnerRadius < 0:
         args += " --mask cylinder %d %d" % (-cylinderOuterRadius, -height)
     elif cylinderOuterRadius > 0 and cylinderInnerRadius > 0:
         args += " --mask tube %d %d %d" % (-cylinderInnerRadius,
                                            -cylinderOuterRadius, -height)
     self.runJob('xmipp_volume_find_symmetry', args)
예제 #36
0
 def __init__(self, filename=None):
     self._md = MetaData()
     self._md.setColumnFormat(False)
     self._id = self._md.addObject()
     
     if filename:
         self.read(filename)
예제 #37
0
    def projMatchStep(self, volume, angularSampling, symmetryGroup, images,
                      fnAngles, Xdim):
        from pyworkflow.utils.path import cleanPath
        # Generate gallery of projections
        fnGallery = self._getExtraPath('gallery.stk')
        if volume.endswith('.mrc'):
            volume += ":mrc"

        self.runJob("xmipp_angular_project_library", "-i %s -o %s --sampling_rate %f --sym %s --method fourier 1 0.25 bspline --compute_neighbors --angular_distance -1 --experimental_images %s"\
                   % (volume, fnGallery, angularSampling, symmetryGroup, images))

        # Assign angles
        self.runJob("xmipp_angular_projection_matching", "-i %s -o %s --ref %s --Ri 0 --Ro %s --max_shift 1000 --search5d_shift %s --search5d_step  %s --append"\
                   % (images, fnAngles, fnGallery, str(Xdim/2), str(int(Xdim/10)), str(int(Xdim/25))))

        cleanPath(self._getExtraPath('gallery_sampling.xmd'))
        cleanPath(self._getExtraPath('gallery_angles.doc'))
        cleanPath(self._getExtraPath('gallery.doc'))

        # Write angles in the original file and sort
        MD = MetaData(fnAngles)
        for id in MD:
            galleryReference = MD.getValue(xmipp.MDL_REF, id)
            MD.setValue(xmipp.MDL_IMAGE_REF,
                        "%05d@%s" % (galleryReference + 1, fnGallery), id)
        MD.write(fnAngles)
예제 #38
0
    def run(self):
        from xmipp import MetaData, str2Label
        from protlib_gui_figure import XmippPlotter

        md = MetaData(self.getParam('-i'))
        if self.checkParam('--xlabel'):
            xlabel = self.getParam('--xlabel')
            mdLabelX = str2Label(xlabel)
        else:
            xlabel = ""
            mdLabelX = None

        if self.checkParam('--xtitle'):
            xlabel = self.getParam('--xtitle')
        ylabels = self.getParam('--ylabel').split()
        if self.checkParam('--ytitle'):
            ylabel = self.getParam('--ytitle')
        else:
            ylabel = ylabels[0]

        colors, lenColors = self.getList('--colors',
                                         ['g', 'b', 'r', 'y', 'c', 'm', 'k'])
        markers, lenMarkers = self.getList('--markers')
        styles, lenStyles = self.getList('--style')

        if self.checkParam('--nbins'):
            nBins = self.getIntParam('--nbins')
        else:
            nBins = None

        title = self.getParam('--title')
        xplotter = XmippPlotter()
        xplotter.createSubPlot(title, xlabel, ylabel)

        for i, l in enumerate(ylabels):
            c = colors[i % lenColors]
            m = markers[i % lenMarkers]
            if m == "none":
                m = None
            s = styles[i % lenStyles]
            if s == "none":
                s = None
            xplotter.plotMd(md,
                            mdLabelX,
                            str2Label(l),
                            color=c,
                            marker=m,
                            linestyle=s,
                            nbins=nBins)  # if nbins is present do an histogram

        legendLocation = self.getParam('--legend')
        if legendLocation != 'none':
            xplotter.showLegend(ylabels, loc=legendLocation.replace('_', ' '))
        xplotter.show()
예제 #39
0
 def runSymmetrize(self, fnVol, dihedral, fnParams, fnOut, heightFraction,
                   cylinderInnerRadius, cylinderOuterRadius, height, Ts):
     md = MetaData(fnParams)
     objId = md.firstObject()
     rot0 = md.getValue(MDL_ANGLE_ROT, objId)
     z0 = md.getValue(MDL_SHIFT_Z, objId)
     args = "-i %s --sym %s --helixParams %f %f --heightFraction %f -o %s --sampling %f" % (
         fnVol, self.getSymmetry(dihedral), z0, rot0, heightFraction, fnOut,
         Ts)
     self.runJob('xmipp_transform_symmetrize', args)
     doMask = False
     if cylinderOuterRadius > 0 and cylinderInnerRadius < 0:
         args = "-i %s --mask cylinder %d %d" % (
             fnVol, -cylinderOuterRadius, -height)
         doMask = True
     elif cylinderOuterRadius > 0 and cylinderInnerRadius > 0:
         args = "-i %s --mask tube %d %d %d" % (
             fnVol, -cylinderInnerRadius, -cylinderOuterRadius, -height)
         doMask = True
     if doMask:
         self.runJob('xmipp_transform_mask', args)
예제 #40
0
    def evaluateDeformationsStep(self):
        N = self.inputStructures.get().getSize()
        import numpy
        distances = numpy.zeros([N, N])
        for volCounter in range(1, N + 1):
            pdb1 = open(self._getPath('pseudoatoms_%02d.pdb' %
                                      volCounter)).readlines()
            for volCounter2 in range(1, N + 1):
                if volCounter != volCounter2:
                    davg = 0.
                    Navg = 0.
                    pdb2 = open(
                        self._getExtraPath(
                            'alignment_%02d_%02d.pdb' %
                            (volCounter, volCounter2))).readlines()
                    for i in range(len(pdb1)):
                        line1 = pdb1[i]
                        if line1.startswith("ATOM"):
                            line2 = pdb2[i]
                            x1 = float(line1[30:37])
                            y1 = float(line1[38:45])
                            z1 = float(line1[46:53])
                            x2 = float(line2[30:37])
                            y2 = float(line2[38:45])
                            z2 = float(line2[46:53])
                            dx = x1 - x2
                            dy = y1 - y2
                            dz = z1 - z2
                            d = math.sqrt(dx * dx + dy * dy + dz * dz)
                            davg += d
                            Navg += 1
                    if Navg > 0:
                        davg /= Navg
                    distances[volCounter - 1, volCounter2 - 1] = davg
        distances = 0.5 * (distances + numpy.transpose(distances))
        numpy.savetxt(self._getPath('distances.txt'), distances)
        distances1D = numpy.mean(distances, axis=0)
        print("Average distance to rest of volumes=", distances1D)
        imin = numpy.argmin(distances1D)
        print("The volume in the middle is pseudoatoms_%02d.pdb" % (imin + 1))
        createLink(self._getPath("pseudoatoms_%02d.pdb" % (imin + 1)),
                   self._getPath("pseudoatoms.pdb"))
        createLink(self._getPath("modes_%02d.xmd" % (imin + 1)),
                   self._getPath("modes.xmd"))
        createLink(
            self._getExtraPath("pseudoatoms_%02d_distance.hist" % (imin + 1)),
            self._getExtraPath("pseudoatoms_distance.hist"))

        # Measure range
        minDisplacement = 1e38 * numpy.ones([self.numberOfModes.get(), 1])
        maxDisplacement = -1e38 * numpy.ones([self.numberOfModes.get(), 1])
        mdNMA = MetaData(self._getPath("modes.xmd"))
        for volCounter in range(1, N + 1):
            if volCounter != imin + 1:
                md = MetaData(
                    self._getExtraPath("alignment_%02d_%02d.xmd" %
                                       (imin + 1, volCounter)))
                displacements = md.getValue(MDL_NMA, md.firstObject())
                idx1 = 0
                idx2 = 0
                for idRow in mdNMA:
                    if mdNMA.getValue(MDL_ENABLED, idRow) == 1:
                        minDisplacement[idx2] = min(minDisplacement[idx2],
                                                    displacements[idx1])
                        maxDisplacement[idx2] = max(maxDisplacement[idx2],
                                                    displacements[idx1])
                        idx1 += 1
                    else:
                        minDisplacement[idx2] = 0
                        maxDisplacement[idx2] = 0
                    idx2 += 1
        idx2 = 0
        for idRow in mdNMA:
            mdNMA.setValue(MDL_NMA_MINRANGE, float(minDisplacement[idx2]),
                           idRow)
            mdNMA.setValue(MDL_NMA_MAXRANGE, float(maxDisplacement[idx2]),
                           idRow)
            idx2 += 1
        mdNMA.write(self._getPath("modes.xmd"))

        # Create output
        volCounter = 0
        for inputStructure in self.inputStructures.get():
            if volCounter == imin:
                print("The corresponding volume is %s" %
                      (getImageLocation(inputStructure)))
                finalStructure = inputStructure
                break
            volCounter += 1

        pdb = PdbFile(self._getPath('pseudoatoms.pdb'), pseudoatoms=True)
        self._defineOutputs(outputPdb=pdb)
        modes = NormalModes(filename=self._getPath('modes.xmd'))
        self._defineOutputs(outputModes=modes)

        self._defineSourceRelation(self.inputStructures, self.outputPdb)
예제 #41
0
 def _iterAngles(self, fnAngles):
     md = MetaData(fnAngles)
     for objId in md:
         rot = md.getValue(MDL_ANGLE_ROT, objId)
         tilt = md.getValue(MDL_ANGLE_TILT, objId)
         yield rot, tilt
예제 #42
0
    def produceAlignedImagesStep(self, volumeIsCTFCorrected, fn, images):

        from numpy import array, dot
        fnOut = 'classes_aligned@' + fn
        MDin = MetaData(images)
        MDout = MetaData()
        n = 1
        hasCTF = MDin.containsLabel(xmipp.MDL_CTF_MODEL)
        for i in MDin:
            fnImg = MDin.getValue(xmipp.MDL_IMAGE, i)
            fnImgRef = MDin.getValue(xmipp.MDL_IMAGE_REF, i)
            maxCC = MDin.getValue(xmipp.MDL_MAXCC, i)
            rot = MDin.getValue(xmipp.MDL_ANGLE_ROT, i)
            tilt = MDin.getValue(xmipp.MDL_ANGLE_TILT, i)
            psi = -1. * MDin.getValue(xmipp.MDL_ANGLE_PSI, i)
            flip = MDin.getValue(xmipp.MDL_FLIP, i)
            if flip:
                psi = -psi
            eulerMatrix = Euler_angles2matrix(0., 0., psi)
            x = MDin.getValue(xmipp.MDL_SHIFT_X, i)
            y = MDin.getValue(xmipp.MDL_SHIFT_Y, i)
            shift = array([x, y, 0])
            shiftOut = dot(eulerMatrix, shift)
            [x, y, z] = shiftOut
            if flip:
                x = -x
            id = MDout.addObject()
            MDout.setValue(xmipp.MDL_IMAGE, fnImg, id)
            MDout.setValue(xmipp.MDL_IMAGE_REF, fnImgRef, id)
            MDout.setValue(xmipp.MDL_IMAGE1,
                           "%05d@%s" % (n, self._getExtraPath("diff.stk")), id)
            if hasCTF:
                fnCTF = MDin.getValue(xmipp.MDL_CTF_MODEL, i)
                MDout.setValue(xmipp.MDL_CTF_MODEL, fnCTF, id)
            MDout.setValue(xmipp.MDL_MAXCC, maxCC, id)
            MDout.setValue(xmipp.MDL_ANGLE_ROT, rot, id)
            MDout.setValue(xmipp.MDL_ANGLE_TILT, tilt, id)
            MDout.setValue(xmipp.MDL_ANGLE_PSI, psi, id)
            MDout.setValue(xmipp.MDL_SHIFT_X, x, id)
            MDout.setValue(xmipp.MDL_SHIFT_Y, y, id)
            MDout.setValue(xmipp.MDL_FLIP, flip, id)
            MDout.setValue(xmipp.MDL_ENABLED, 1, id)
            n += 1
        MDout.write(fnOut, xmipp.MD_APPEND)

        # Actually create the differences
        img = Image()
        imgRef = Image()
        if hasCTF and volumeIsCTFCorrected:
            Ts = MDin.getValue(xmipp.MDL_SAMPLINGRATE, MDin.firstObject())

        for i in MDout:
            img.readApplyGeo(MDout, i)
            imgRef.read(MDout.getValue(xmipp.MDL_IMAGE_REF, i))
            if hasCTF and volumeIsCTFCorrected:
                fnCTF = MDout.getValue(xmipp.MDL_CTF_MODEL, i)
                imgRef.applyCTF(fnCTF, Ts)
                img.convert2DataType(DT_DOUBLE)
            imgDiff = img - imgRef
            imgDiff.write(MDout.getValue(xmipp.MDL_IMAGE1, i))
예제 #43
0
 def readFromFile(self, fn):
     md = MetaData(fn)
     self.readFromMd(md, md.firstObject())
예제 #44
0
class RowMetaData():
    """ This class is a wrapper for MetaData in row mode.
    Where only one object is used.
    """
    def __init__(self, filename=None):
        self._md = MetaData()
        self._md.setColumnFormat(False)
        self._id = self._md.addObject()

        if filename:
            self.read(filename)

    def setValue(self, label, value):
        self._md.setValue(label, value, self._id)

    def getValue(self, label):
        return self._md.getValue(label, self._id)

    def write(self, filename, mode=MD_APPEND):
        self._md.write(filename, mode)

    def read(self, filename):
        self._md.read(filename)
        self._md.setColumnFormat(False)
        self._id = self._md.firstObject()

    def containsLabel(self, label):
        return self._md.containsLabel(label)

    def __str__(self):
        return str(self._md)
예제 #45
0
 def writeToFile(self, fn):
     md = MetaData()
     self.writeToMd(md, md.addObject())
     md.write(fn)