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 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 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 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 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
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
def importImages(log, InputFile, WorkingDir, DoCopy, ImportAll, SubsetMode, Nsubset):
imagesFn = getImagesFilename(WorkingDir)
fnInput = FileName(InputFile)
md = MetaData(InputFile)
#check if micrographs or ctfparam exists
doMic=False
doCTFParam=False
if md.containsLabel(MDL_MICROGRAPH):
doMic = True
if md.containsLabel(MDL_CTF_MODEL):
doCTFParam = True
if fnInput.isMetaData():
inputRelativePath = dirname(relpath(InputFile, '.'))
projectPath = findProjectPath(InputFile)
for id in md:
imgFn = md.getValue(MDL_IMAGE, id)
imgNo, imgFn = splitFilename(imgFn)
imgFn = xmippRelpath(fixPath(imgFn, projectPath, inputRelativePath, '.'))
if imgNo != None:
imgFn = "%s@%s" % (imgNo, imgFn)
md.setValue(MDL_IMAGE, imgFn, id)
#micrograph
if doMic:
imgFn = md.getValue(MDL_MICROGRAPH, id)
imgNo, imgFn = splitFilename(imgFn)
imgFn = xmippRelpath(fixPath(imgFn, projectPath, inputRelativePath, '.'))
if imgNo != None:
imgFn = "%s@%s" % (imgNo, imgFn)
md.setValue(MDL_MICROGRAPH, imgFn, id)
#ctf param
if doCTFParam:
ctfFn = md.getValue(MDL_CTF_MODEL, id)
ctfFn = xmippRelpath(fixPath(ctfFn, projectPath, inputRelativePath, '.'))
md.setValue(MDL_CTF_MODEL, ctfFn, id)
outExt = '.stk'
else:
outExt = '.%s' % fnInput.getExtension()
imagesStk = imagesFn.replace('.xmd', outExt)
writeImagesMd(log, md, ImportAll, SubsetMode, Nsubset, imagesFn, imagesStk, DoCopy)
def gatherPairs(log, WorkingDir, ExtraDir, ClassSelection, ClassFile, ExtractDir, PickingDir):
mdImages = getImagesMd(ExtractDir)
fnMicrographs = getProtocolFilename("micrographs", WorkingDir=ExtractDir)
mdTiltAngles = MetaData("micrographPairs@" + fnMicrographs)
mdU = getImagesMd(ExtractDir, "untilted")
mdUAux = MetaData()
mdUAux.setColumnValues(MDL_IMAGE, mdU.getColumnValues(MDL_IMAGE))
mdUAux.setColumnValues(MDL_MICROGRAPH, mdU.getColumnValues(MDL_MICROGRAPH))
mdT = getImagesMd(ExtractDir, "tilted")
mdTAux = MetaData()
mdTAux.setColumnValues(MDL_IMAGE_TILTED, mdT.getColumnValues(MDL_IMAGE))
mdTAux.setColumnValues(MDL_MICROGRAPH_TILTED, mdT.getColumnValues(MDL_MICROGRAPH))
fnExtractImages = os.path.join(ExtractDir, "images.xmd")
mdJoin1 = MetaData()
mdJoin2 = MetaData()
mdJoin3 = MetaData()
mdJoin4 = MetaData()
fixedMdClass = MetaData()
fnOut = join(ExtraDir, "rct_classes.xmd")
for classNo in ClassSelection:
MDclass = MetaData(getClassBlock(classNo, ClassFile))
if not MDclass.containsLabel(MDL_IMAGE_TILTED):
if MDclass.containsLabel(MDL_IMAGE_ORIGINAL):
fixedMdClass.join2(MDclass, mdImages, MDL_IMAGE_ORIGINAL, MDL_IMAGE, INNER_JOIN)
else:
fixedMdClass.join1(MDclass, mdImages, MDL_IMAGE, INNER_JOIN)
else:
fixedMdClass = MDclass
mdJoin1.join1(fixedMdClass, mdImages, MDL_IMAGE, LEFT_JOIN)
mdJoin2.join1(mdJoin1, mdUAux, MDL_IMAGE, LEFT_JOIN)
mdJoin3.join1(mdJoin2, mdTAux, MDL_IMAGE_TILTED, LEFT_JOIN)
mdJoin4.join1(mdJoin3, mdTiltAngles, MDL_MICROGRAPH, LEFT_JOIN)
fnClassOut = getClassBlock(classNo, fnOut)
mdJoin4.write(fnClassOut, MD_APPEND)
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,
)
def visualize(self):
fn = self.getFilename('images')
if exists(fn):
from protlib_utils import runShowJ
if getattr(self, 'TiltPairs', False):
runShowJ(fn,extraParams="--mode metadata --render first")
else:
runShowJ(fn)
from protlib_gui_figure import XmippPlotter
from xmipp import MDL_ZSCORE
md = MetaData(fn)
if md.containsLabel(MDL_ZSCORE):
#MD.sort(MDL_ZSCORE)
xplotter = XmippPlotter(windowTitle="Zscore particles sorting")
xplotter.createSubPlot("Particle sorting", "Particle number", "Zscore")
xplotter.plotMd(md, False, mdLabelY=MDL_ZSCORE)
xplotter.show()
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
particleSize *= factor
gui.setVarValue("ParticleSize", str(int(particleSize)))
if getattr(pickingProt,'TiltPairs', False):
gui.setVarValue("DoFlip", str(False))
else:
md = MetaData(pickingProt.getFilename("micrographs"))
gui.setVarValue("DoFlip", str(md.containsLabel(MDL_CTF_MODEL)))
#This wizard is specific for cl2d protocol
def wizardCL2DNumberOfClasses(gui, var):
fnSel = gui.getVarValue('InSelFile')
if exists(fnSel):
md = MetaData(fnSel)
gui.setVarValue("NumberOfReferences", int(round(md.size()/200.0)))
#Select micrograph extension
#return unit. pixel, angstrom
def wizardHelperSetRadii(gui, inputVarName, outerVarName, innerVarName=None, unit='pixel', sampling=1.):
fileList = gui.getVarValue(inputVarName).split()
showInner = innerVarName is not None
innerRadius = 0
try:
