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
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)
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
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)
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.0 * MDin.getValue(xmipp.MDL_ANGLE_PSI, i)
flip = MDin.getValue(xmipp.MDL_FLIP, i)
if flip:
psi = -psi
eulerMatrix = Euler_angles2matrix(0.0, 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))
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())
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))
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)
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)
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)
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)
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)
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)
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)
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 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)
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)))
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
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)))
def createAcquisition(log,InputFile,WorkingDir,DoResize,NewSize):
fnAcqIn = findAcquisitionInfo(InputFile)
if not fnAcqIn is None:
fnAcqOut = getProtocolFilename('acquisition', WorkingDir=WorkingDir)
if not DoResize:
createLink(log, fnAcqIn, fnAcqOut)
else:
md = MetaData(fnAcqIn)
id = md.firstObject()
Ts = md.getValue(MDL_SAMPLINGRATE, id)
(Xdim, Ydim, Zdim, Ndim, _) = MetaDataInfo(InputFile)
downsampling = float(Xdim)/NewSize;
md.setValue(MDL_SAMPLINGRATE,Ts*downsampling,id)
md.write(getProtocolFilename('acquisition', WorkingDir=WorkingDir))
def summary(self):
super(ProtPartialProjectionSubtraction, self).summary()
summary = []
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
summary += ['Number of CTFgroups is %d ' %(self.NumberOfCtfGroups)]
return summary
def calculateSpectra(log, Selfile, ExtraDir, SpectraInnerRadius, SpectraOuterRadius,
SpectraLowHarmonic, SpectraHighHarmonic):
MD = MetaData(join(ExtraDir, "center2d_center.xmd"))
id = MD.firstObject()
xOffset=MD.getValue(MDL_X, id)
yOffset=MD.getValue(MDL_Y, id)
runJob(log, "xmipp_image_rotational_spectra",
' -i ' + Selfile + \
' -o ' + join(ExtraDir,"rotSpectra.xmd") + \
' --x0 ' + str(xOffset) + \
' --y0 ' + str(yOffset) + \
' --r1 ' + str(SpectraInnerRadius) + \
' --r2 ' + str(SpectraOuterRadius) + \
' --low ' + str(SpectraLowHarmonic) + \
' --high ' + str(SpectraHighHarmonic))
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,numberOfMpi=1)
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,numberOfMpi=1)
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)
def ImportProtocol(self):
self.pmprotWorkingDir = self.PrevRun.WorkingDir
# if (self.SymmetryGroup == ''):
# self.SymmetryGroup = self.PrevRun.SymmetryGroup
# if (len(self.AngSamplingRateDeg) <1):
# self.AngSamplingRateDeg = getComponentFromVector(self.PrevRun.AngSamplingRateDeg,self.iterationNo - 1)
# if (len(self.MaxChangeInAngles) <1):
# self.MaxChangeInAngles = float(getComponentFromVector(self.PrevRun.MaxChangeInAngles,self.iterationNo - 1))
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.defocusGroupNo = auxMD.getValue(MDL_COUNT,auxMD.firstObject())
else:
self.defocusGroupNo = 1
def _getMdString(self, filename, block=None):
from xmipp import MetaData, MDL_IMAGE, label2Str, labelIsImage
md = MetaData()
if block:
md.read(block + '@' + filename)
else:
md.read(filename, 1)
labels = md.getActiveLabels()
msg = "Metadata items: *%d*\n" % md.getParsedLines()
msg += "Metadata labels: " + ''.join(["\n - %s" % label2Str(l) for l in labels])
imgPath = None
for label in labels:
if labelIsImage(label):
imgPath = self._getImgPath(filename, md.getValue(label, md.firstObject()))
break
if imgPath:
self._imgPreview = self._getImagePreview(imgPath)
self._imgInfo = self._getImageString(imgPath)
return msg
def evaluateVolumes(log,WorkingDir,NRansac):
fnCorr=os.path.join(WorkingDir,"extra/correlations.xmd")
fnCorr = 'corrThreshold@'+fnCorr
mdCorr= MetaData(fnCorr)
objId = mdCorr.firstObject()
CorrThresh = mdCorr.getValue(MDL_WEIGHT,objId)
for n in range(NRansac):
fnRoot=os.path.join("ransac%05d"%n)
fnAngles=os.path.join(WorkingDir,"tmp/angles_"+fnRoot+".xmd")
md=MetaData(fnAngles)
numInliers=0
for objId in md:
corr = md.getValue(MDL_MAXCC, objId)
if (corr >= CorrThresh) :
numInliers = numInliers+corr
md= MetaData()
objId = md.addObject()
md.setValue(MDL_WEIGHT,float(numInliers),objId)
md.write("inliers@"+fnAngles,MD_APPEND)
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)
def defineSteps(self):
self.insertStep("createDir",verifyfiles=[self.ExtraDir],path=self.ExtraDir)
md = MetaData(self.Input['config'])
for objId in md:
self.particleSizeForAuto = md.getValue(MDL_PICKING_PARTICLE_SIZE, objId)
filesToImport = [self.Input[k] for k in self.keysToImport]
filesToImport += [self.PrevRun.getFilename(k, model=self.model) for k in ['training', 'pca', 'rotpca', 'svm', 'average', 'config', 'templates']]
self.insertImportOfFiles(filesToImport)
self.insertCopyFile(self.MicrographsMd, self.getFilename('micrographs'))
md = MetaData(self.MicrographsMd)
particleSize = self.particleSizeForAuto
modelRoot = self.extraPath(self.model)
for objId in md:
# Get micrograph path and name
path = md.getValue(MDL_MICROGRAPH, objId)
micrographName = removeBasenameExt(path)
proceed = True
if not self.anotherSet:
fnPos = self.PrevRun.getFilename('pos', micrograph=micrographName)
if xmippExists(fnPos):
blocks = getBlocksInMetaDataFile(fnPos)
copy = True
if 'header' in blocks:
mdheader = MetaData("header@" + fnPos)
state = mdheader.getValue(MDL_PICKING_MICROGRAPH_STATE, mdheader.firstObject())
if state == "Available":
copy = False
if copy:
# Copy manual .pos file of this micrograph
self.insertCopyFile(fnPos, self.getFilename('pos', micrograph=micrographName))
proceed = False
if proceed:
oroot = self.extraPath(micrographName)
cmd = "-i %(path)s --particleSize %(particleSize)d --model %(modelRoot)s --outputRoot %(oroot)s --mode autoselect" % locals()
if self.Fast:
cmd += " --fast "
self.insertParallelRunJobStep("xmipp_micrograph_automatic_picking", cmd)
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)
def launchML2DPlots(protML, selectedPlots):
''' Launch some plot for an ML2D protocol run '''
#import matplotlib
import numpy as np
from protlib_gui_figure import XmippPlotter
protML._plot_count = 0
lastIter = lastIteration(protML)
if lastIter == 0:
return
refs = protML.getFilename('iter_refs', iter=lastIter)
# if not exists(refs):
# return
# blocks = getBlocksInMetaDataFile(refs)
# lastBlock = blocks[-1]
def doPlot(plotName):
return plotName in selectedPlots
# Remove 'mirror' from list if DoMirror is false
if doPlot('DoShowMirror') and not protML.DoMirror:
selectedPlots.remove('DoShowMirror')
n = len(selectedPlots)
if n == 0:
showWarning("ML2D plots", "Nothing to plot", protML.master)
return
elif n == 1:
gridsize = [1, 1]
elif n == 2:
gridsize = [2, 1]
else:
gridsize = [2, 2]
xplotter = XmippPlotter(*gridsize)
# Create data to plot
iters = range(1, lastIter+1)
ll = []
pmax = []
for iter in iters:
logs = protML.getFilename('iter_logs', iter=iter)
md = MetaData(logs)
id = md.firstObject()
ll.append(md.getValue(MDL_LL, id))
pmax.append(md.getValue(MDL_PMAX, id))
if doPlot('DoShowLL'):
a = xplotter.createSubPlot('Log-likelihood (should increase)', 'iterations', 'LL', yformat=True)
a.plot(iters, ll)
#Create plot of mirror for last iteration
if doPlot('DoShowMirror'):
from numpy import arange
from matplotlib.ticker import FormatStrFormatter
md = MetaData(refs)
mirrors = [md.getValue(MDL_MIRRORFRAC, id) for id in md]
nrefs = len(mirrors)
ind = arange(1, nrefs + 1)
width = 0.85
a = xplotter.createSubPlot('Mirror fractions on last iteration', 'references', 'mirror fraction')
a.set_xticks(ind + 0.45)
a.xaxis.set_major_formatter(FormatStrFormatter('%1.0f'))
a.bar(ind, mirrors, width, color='b')
a.set_ylim([0, 1.])
a.set_xlim([0.8, nrefs + 1])
if doPlot('DoShowPmax'):
a = xplotter.createSubPlot('Probabilities distribution', 'iterations', 'Pmax/Psum')
a.plot(iters, pmax, color='green')
if doPlot('DoShowSignalChange'):
md = MetaData()
for iter in iters:
fn = protML.getFilename('iter_refs', iter=iter)
md2 = MetaData(fn)
md2.fillConstant(MDL_ITER, str(iter))
md.unionAll(md2)
# 'iter(.*[1-9].*)@2D/ML2D/run_004/ml2d_iter_refs.xmd')
#a = plt.subplot(gs[1, 1])
#print "md:", md
md2 = MetaData()
md2.aggregate(md, AGGR_MAX, MDL_ITER, MDL_SIGNALCHANGE, MDL_MAX)
signal_change = [md2.getValue(MDL_MAX, id) for id in md2]
xplotter.createSubPlot('Maximum signal change', 'iterations', 'signal change')
xplotter.plot(iters, signal_change, color='green')
return xplotter
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(finalStructure, self.outputPdb)
self._defineSourceRelation(self.outputPdb, self.outputModes)
def getCCThreshold(WorkingDir):
fnCorr=os.path.join(WorkingDir,"extra/correlations.xmd")
mdCorr=MetaData("corrThreshold@"+fnCorr)
return mdCorr.getValue(MDL_WEIGHT, mdCorr.firstObject())
def getFirstImage(mdFn):
''' Read the first image from Metadata'''
md = MetaData(mdFn)
return md.getValue(xmipp.MDL_IMAGE, md.firstObject())
def readFromFile(self, fn):
md = MetaData(fn)
self.readFromMd(md, md.firstObject())
def readFromFile(self, fn):
md = MetaData(fn)
self.readFromMd(md, md.firstObject())
