def convertInputStep(self, classesFn):
inputSet = self.inputSet.get()
if isinstance(inputSet, SetOfClasses2D):
writeSetOfClasses2D(inputSet, classesFn)
else:
writeSetOfParticles(inputSet, classesFn)
def convertAveragesStep(self):
if self.useAsRef == REF_CLASSES:
writeSetOfClasses2D(self.inputRefs.get(),
self.imgsRef,
writeParticles=True)
else:
writeSetOfParticles(self.inputRefs.get(), self.imgsRef)
def convertSetStep(self):
writeSetOfParticles(self.inputParticles.get(), self.imgsExp,
alignType=ALIGN_NONE)
if self.useReferenceImages:
if isinstance(self.referenceImages.get(), SetOfClasses2D):
writeSetOfClasses2D(self.referenceImages.get(), self.refSet,
writeParticles=False)
else:
writeSetOfParticles(self.referenceImages.get(), self.refSet,
alignType=ALIGN_NONE)
def convertInputStep(self, particlesId, classesId):
writeSetOfParticles(self.inputParticles.get(),
self._getFileName('input_particles'),
alignType=em.ALIGN_NONE)
if not self.randomInitialization:
if isinstance(self.initialClasses.get(), SetOfClasses2D):
writeSetOfClasses2D(self.initialClasses.get(),
self._getFileName('input_references'),
writeParticles=False)
else:
writeSetOfParticles(self.initialClasses.get(),
self._getFileName('input_references'))
def denoiseImages(self, inputId, inputClassesId):
# We start preparing writing those elements we're using as input to keep them untouched
imagesMd = self._getPath('images.xmd')
writeSetOfParticles(self.inputParticles.get(), imagesMd)
classesMd = self._getPath('classes.xmd')
writeSetOfClasses2D(self.inputClasses.get(), classesMd)
fnRoot = self._getExtraPath('pca')
fnRootDenoised = self._getExtraPath('imagesDenoised')
args = '-i Particles@%s --oroot %s --eigenvectors %d --maxImages %d' % (
imagesMd, fnRoot, self.maxPCABases.get(), self.maxClasses.get())
self.runJob("xmipp_image_rotational_pca", args)
N = min(self.maxPCABases.get(), self.PCABases2Project.get())
args='-i %s -o %s.stk --save_metadata_stack %s.xmd --basis %s.stk %d'\
% (imagesMd, fnRootDenoised, fnRootDenoised, fnRoot, N)
self.runJob("xmipp_transform_filter", args)
self.outputMd = String('%s.stk' % fnRootDenoised)
def convertStep(self):
metadata = self._getExtraPath(self.CLASSES_MD)
writeSetOfClasses2D(self.inputClasses.get(),
metadata,
writeParticles=True)
def convertInputStep(self, classesFn):
inputSet = self.inputSet.get()
if isinstance(inputSet, SetOfClasses2D):
writeSetOfClasses2D(inputSet, classesFn, writeParticles=False)
else:
writeSetOfParticles(inputSet, classesFn)
# To re-sample input images
fnDir = self._getExtraPath()
fnNewParticles = join(fnDir, "input_classes.stk")
TsOrig = self.inputSet.get().getSamplingRate()
TsRefVol = -1
if self.thereisRefVolume:
TsRefVol = self.refVolume.get().getSamplingRate()
if self.useMaxRes:
self.TsCurrent = max([TsOrig, self.maxResolution.get(), TsRefVol])
self.TsCurrent = self.TsCurrent / 3
Xdim = self.inputSet.get().getDimensions()[0]
self.newXdim = long(round(Xdim * TsOrig / self.TsCurrent))
if self.newXdim < 40:
self.newXdim = long(40)
self.TsCurrent = float(TsOrig) * (float(Xdim) /
float(self.newXdim))
if self.newXdim != Xdim:
self.runJob("xmipp_image_resize",
"-i %s -o %s --fourier %d" %
(self.imgsFn, fnNewParticles, self.newXdim),
numberOfMpi=self.numberOfMpi.get() *
self.numberOfThreads.get())
else:
self.runJob("xmipp_image_convert",
"-i %s -o %s "
"--save_metadata_stack %s" %
(self.imgsFn, fnNewParticles,
join(fnDir, "input_classes.xmd")),
numberOfMpi=1)
# To resample the refVolume if exists with the newXdim calculated
# previously
if self.thereisRefVolume:
fnFilVol = self._getExtraPath('filteredVolume.vol')
copy(self.refVolume.get().getFileName(), fnFilVol)
# TsVol = self.refVolume.get().getSamplingRate()
if self.useMaxRes:
if self.newXdim != Xdim:
self.runJob('xmipp_image_resize',
"-i %s --fourier %d" %
(fnFilVol, self.newXdim),
numberOfMpi=1)
self.runJob('xmipp_transform_window',
"-i %s --size %d" % (fnFilVol, self.newXdim),
numberOfMpi=1)
args = "-i %s --fourier low_pass %f --sampling %f " % (
fnFilVol, self.maxResolution.get(), self.TsCurrent)
self.runJob("xmipp_transform_filter", args, numberOfMpi=1)
if not self.useMaxRes:
inputVolume = self.refVolume.get()
else:
inputVolume = Volume(fnFilVol)
inputVolume.setSamplingRate(self.TsCurrent)
inputVolume.setObjId(self.refVolume.get().getObjId())
fnVolumes = self._getExtraPath('input_volumes.xmd')
row = XmippMdRow()
volumeToRow(inputVolume, row, alignType=ALIGN_NONE)
md = xmippLib.MetaData()
row.writeToMd(md, md.addObject())
md.write(fnVolumes)
def realignStep(self):
inputMdName = self._getExtraPath('inputClasses.xmd')
writeSetOfClasses2D(self.inputClasses.get(), inputMdName,
writeParticles=True)
centeredStackName = self._getExtraPath('centeredStack.stk')
self._params = {'input': inputMdName,
'output': centeredStackName}
args = ('-i %(input)s -o %(output)s --save_metadata_transform')
self.runJob("xmipp_transform_center_image", args % self._params,
numberOfMpi=1)
centeredMdName = centeredStackName.replace('stk', 'xmd')
centeredMd = md.MetaData(centeredMdName)
centeredStack = md.MetaData(centeredStackName)
listName = []
listTransform=[]
for rowStk in md.iterRows(centeredStack):
listName.append(rowStk.getValue(md.MDL_IMAGE))
for rowMd in md.iterRows(centeredMd):
listTransform.append(rowToAlignment(rowMd, ALIGN_2D))
mdNewClasses = md.MetaData()
for i, row in enumerate(md.iterRows(inputMdName)):
newRow = md.Row()
newRow.setValue(md.MDL_IMAGE, listName[i])
refNum = row.getValue(md.MDL_REF)
newRow.setValue(md.MDL_REF, refNum)
classCount = row.getValue(md.MDL_CLASS_COUNT)
newRow.setValue(md.MDL_CLASS_COUNT, classCount)
newRow.addToMd(mdNewClasses)
mdNewClasses.write('classes@' + self._getExtraPath('final_classes.xmd'),
MD_APPEND)
mdImages = md.MetaData()
i=0
mdBlocks = md.getBlocksInMetaDataFile(inputMdName)
resultMat = Transform()
for block in mdBlocks:
if block.startswith('class00'):
newMat = listTransform[i]
newMatrix = newMat.getMatrix()
mdClass = md.MetaData(block + "@" + inputMdName)
mdNewClass = md.MetaData()
i+=1
for rowIn in md.iterRows(mdClass):
#To create the transformation matrix (and its parameters)
# for the realigned particles
if rowIn.getValue(md.MDL_ANGLE_PSI)!=0:
flag_psi=True
if rowIn.getValue(md.MDL_ANGLE_ROT)!=0:
flag_psi=False
inMat = rowToAlignment(rowIn, ALIGN_2D)
inMatrix = inMat.getMatrix()
resultMatrix = np.dot(newMatrix,inMatrix)
resultMat.setMatrix(resultMatrix)
rowOut=md.Row()
rowOut.copyFromRow(rowIn)
alignmentToRow(resultMat, rowOut, ALIGN_2D)
if flag_psi==False:
newAngle = rowOut.getValue(md.MDL_ANGLE_PSI)
rowOut.setValue(md.MDL_ANGLE_PSI, 0.)
rowOut.setValue(md.MDL_ANGLE_ROT, newAngle)
#To create the new coordinates for the realigned particles
inPoint = np.array([[0.],[0.],[0.],[1.]])
invResultMat = np.linalg.inv(resultMatrix)
centerPoint = np.dot(invResultMat,inPoint)
rowOut.setValue(md.MDL_XCOOR, rowOut.getValue(
md.MDL_XCOOR)+int(centerPoint[0]))
rowOut.setValue(md.MDL_YCOOR, rowOut.getValue(
md.MDL_YCOOR)+int(centerPoint[1]))
rowOut.addToMd(mdNewClass)
mdNewClass.write(block + "@" + self._getExtraPath(
'final_classes.xmd'), MD_APPEND)
mdImages.unionAll(mdNewClass)
mdImages.write(self._getExtraPath('final_images.xmd'))
