def convertStep(self, imgsFn):
from convert import writeSetOfClasses2D, writeSetOfParticles
imgSet = self.inputSet.get()
if isinstance(imgSet, SetOfClasses2D):
writeSetOfClasses2D(imgSet, self.imgsFn, writeParticles=False)
else:
writeSetOfParticles(imgSet, self.imgsFn)
def convertInputStep(self, classesFn):
inputSet = self.inputSet.get()
if isinstance(inputSet, SetOfClasses2D):
writeSetOfClasses2D(inputSet, classesFn)
else:
writeSetOfParticles(inputSet, classesFn)
def convertInputStep(self, resetDeps):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
Params:
particlesId, volumesId: use this parameters just to force redo of
convert if either the input particles and/or input volumes are
changed.
"""
self._imgFnList = []
imgSet = self._getInputParticles()
imgStar = self._getFileName('input_star')
subset = em.SetOfParticles(filename=":memory:")
newIndex = 1
for img in imgSet.iterItems(orderBy='RANDOM()', direction='ASC'):
self._scaleImages(newIndex, img)
newIndex += 1
subset.append(img)
subsetSize = self.subsetSize.get()
minSize = min(subsetSize, imgSet.getSize())
if subsetSize > 0 and subset.getSize() == minSize:
break
writeSetOfParticles(subset,
imgStar,
self._getExtraPath(),
alignType=em.ALIGN_NONE,
postprocessImageRow=self._postprocessParticleRow)
self._convertInput(subset)
self._convertRef()
def convertInputStep(self, moviesId, partsId):
self._ih = em.ImageHandler() # used to convert movies
inputMovies = self.getInputMovies()
firstMovie = inputMovies.getFirstItem()
self._linkOrConvertMovie = self._getConvertFunc(firstMovie)
# convert movies to mrcs and write a movie star file
writeSetOfMovies(inputMovies,
self._getPath(self._getFileName('inputMovies')),
preprocessImageRow=self._preprocessMovieRow)
inputParts = self.getParticles()
firstPart = inputParts.getFirstItem()
self._linkOrConvertPart = self._getConvertFunc(firstPart)
# convert particle set to star file
# we avoid to use the defaul convertBinaryFiles because we want
# to set a different naming convention to map between movie mrcs
# and particles stack mrcs
writeSetOfParticles(
inputParts,
self._getPath(self._getFileName('inputParts')),
None, # do not use convertBinaryFiles
fillMagnification=True,
alignType=inputParts.getAlignment(),
postprocessImageRow=self._postprocessParticleRow)
def convertInputStep(self, particlesId, classesId):
writeSetOfParticles(self.inputParticles.get(),self.imgsFn,alignType=em.ALIGN_NONE)
if not self.randomInitialization:
if isinstance(self.initialClasses.get(), SetOfClasses2D):
writeSetOfClasses2D(self.initialClasses.get(),self.initialClassesFn, writeParticles=False)
else:
writeSetOfParticles(self.initialClasses.get(),self.initialClassesFn)
def convertInputStep(self, classesFn):
inputSet = self.inputSet.get()
if isinstance(inputSet, SetOfClasses2D):
writeSetOfClasses2D(inputSet, classesFn)
else:
writeSetOfParticles(inputSet, classesFn)
def convertInputStep(self, particlesId):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
Params:
particlesId: use this parameter just to force redo of convert if
the input particles are changed.
"""
imgSet = self._getInputParticles()
imgStar = self._getFileName('movie_particles')
imgStarTmp = self._getTmpPath('movie_particles.star')
self.info("Converting set from '%s' into '%s'" %
(imgSet.getFileName(), imgStarTmp))
writeSetOfParticles(imgSet, imgStarTmp, self._getExtraPath(),
alignType=imgSet.getAlignment(),
extraLabels=MOVIE_EXTRA_LABELS)
mdImg = md.MetaData(imgStarTmp)
# replace mdColumn from *.stk to *.mrcs as Relion2 requires
if getVersion() == V1_3:
mdColumn = md.RLN_PARTICLE_NAME
else:
mdColumn = md.RLN_PARTICLE_ORI_NAME
from convert import relionToLocation, locationToRelion
for objId in mdImg:
index, imgPath = relionToLocation(mdImg.getValue(mdColumn, objId))
if not imgPath.endswith('mrcs'):
newName = pwutils.replaceBaseExt(os.path.basename(imgPath), 'mrcs')
newPath = self._getTmpPath(newName)
newLoc = locationToRelion(index, newPath)
if not exists(newPath):
pwutils.createLink(imgPath, newPath)
mdImg.setValue(mdColumn, newLoc, objId)
mdImg.write(imgStar)
def convertStep(self, imgsFn):
from convert import writeSetOfClasses2D, writeSetOfParticles
imgSet = self.inputSet.get()
if isinstance(imgSet, SetOfClasses2D):
writeSetOfClasses2D(imgSet, self.imgsFn, writeParticles=False)
else:
writeSetOfParticles(imgSet, self.imgsFn)
def convertInputStep(self):
writeSetOfParticles(self.inputParticles.get(), self.imgsFn)
if not self.randomInitialization:
if isinstance(self.initialClasses.get(), SetOfClasses2D):
writeSetOfClasses2D(self.initialClasses.get(), self.initialClassesFn, writeParticles=False)
else:
writeSetOfParticles(self.initialClasses.get(), self.initialClassesFn)
def convertInputStep(self, resetDeps):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
Params:
particlesId, volumesId: use this parameters just to force redo of
convert if either the input particles and/or input volumes are
changed.
"""
self._imgFnList = []
imgSet = self._getInputParticles()
imgStar = self._getFileName('input_star')
subset = em.SetOfParticles(filename=":memory:")
newIndex = 1
for img in imgSet.iterItems(orderBy='RANDOM()', direction='ASC'):
self._scaleImages(newIndex, img)
newIndex += 1
subset.append(img)
subsetSize = self.subsetSize.get()
minSize = min(subsetSize, imgSet.getSize())
if subsetSize > 0 and subset.getSize() == minSize:
break
writeSetOfParticles(subset, imgStar, self._getExtraPath(),
alignType=em.ALIGN_NONE,
postprocessImageRow=self._postprocessParticleRow)
self._convertInput(subset)
self._convertRef()
def convertInputStep(self, inputId):
""" Write the input images as a Xmipp metadata file. """
writeSetOfParticles(self.inputParticles.get(),
self._getFileName('input_particles'))
# If input references, also convert to xmipp metadata
if not self.doGenerateReferences:
writeSetOfParticles(self.inputReferences.get(),
self._getFileName('input_references'))
def convertInputStep(self, particlesId):
""" Write the input images as a Xmipp metadata file.
particlesId: is only need to detect changes in
input particles and cause restart from here.
"""
imgSet = self.inputParticles.get()
writeSetOfParticles(imgSet, self._getFileName('input_star'),
self._getExtraPath())
def convertInputStep(self, particlesId):
""" Write the input images as a Xmipp metadata file.
particlesId: is only need to detect changes in
input particles and cause restart from here.
"""
imgSet = self.inputParticles.get()
writeSetOfParticles(imgSet, self._getFileName('input_star'),
self._getExtraPath())
def convertInputStep(self, inputId):
""" Write the input images as a Xmipp metadata file. """
writeSetOfParticles(self.inputParticles.get(),
self._getFileName('input_particles'))
# If input references, also convert to xmipp metadata
if not self.doGenerateReferences:
writeSetOfParticles(self.inputReferences.get(),
self._getFileName('input_references'))
def convertInputStep(self):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
"""
imgSet = self.inputParticles.get()
imgStar = self._getFileName('input_particles.star')
from convert import writeSetOfParticles
# Pass stack file as None to avoid write the images files
writeSetOfParticles(imgSet,imgStar,self._getTmpPath(), alignType=ALIGN_PROJ)
def convertInputStep(self, particlesId, classesId):
writeSetOfParticles(self.inputParticles.get(),
self.imgsFn,
alignType=em.ALIGN_NONE)
if not self.randomInitialization:
if isinstance(self.initialClasses.get(), SetOfClasses2D):
writeSetOfClasses2D(self.initialClasses.get(),
self.initialClassesFn,
writeParticles=False)
else:
writeSetOfParticles(self.initialClasses.get(),
self.initialClassesFn)
def convertInputStep(self, inputParticlesId):
writeSetOfParticles(self.inputParticles.get(), self.imgsFn)
self.runJob('xmipp_metadata_utilities',
'-i %s --fill image1 constant noImage' % self.imgsFn,
numberOfMpi=1)
self.runJob('xmipp_metadata_utilities',
'-i %s --operate modify_values "image1=image"' %
self.imgsFn,
numberOfMpi=1)
self.runJob('xmipp_metadata_utilities',
'-i %s --operate rename_column "itemId particleId"' %
self.imgsFn,
numberOfMpi=1)
def convertInputStep(self):
inputParts = self.inputParticles.get()
imgStar = self._getPath('input_particles.star')
self.info("Converting set from '%s' into '%s'" %
(inputParts.getFileName(), imgStar))
inputFolder = self._getPath('input')
pwutils.makePath(inputFolder)
convert.writeSetOfParticles(inputParts, imgStar, inputFolder,
alignType=em.ALIGN_PROJ,
fillMagnification=True,
fillRandomSubset=True)
def sortImages(self, inputId):
imagesMd = self._getPath('images.xmd')
writeSetOfParticles(self.inputParticles.get(), imagesMd)
args = "-i Particles@%s --addToInput " % imagesMd
if self.autoParRejection == self.REJ_MAXZSCORE:
args += "--zcut " + str(self.maxZscore.get())
elif self.autoParRejection == self.REJ_PERCENTAGE:
args += "--percent " + str(self.percentage.get())
self.runJob("xmipp_image_sort_by_statistics", args)
self.outputMd = String(imagesMd)
def convertStep(self, imgsFn):
from convert import writeSetOfClasses2D, writeSetOfParticles
imgSet = self.inputSet.get()
if isinstance(imgSet, SetOfClasses2D):
writeSetOfClasses2D(imgSet, self.imgsFn, writeParticles=True)
else:
writeSetOfParticles(imgSet, self.imgsFn)
from pyworkflow.em.convert import ImageHandler
img = ImageHandler()
fnVol = self._getTmpPath("volume.vol")
img.convert(self.inputVolume.get(), fnVol)
xdim=self.inputVolume.get().getDim()[0]
if xdim!=self._getDimensions():
self.runJob("xmipp_image_resize","-i %s --dim %d"%(fnVol,self._getDimensions()))
def convertInputStep(self, particlesId):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
Params:
particlesId: use this parameters just to force redo of convert if
the input particles are changed.
"""
imgSet = self._getInputParticles()
imgStar = self._getFileName('input_star')
self.info("Converting set from '%s' into '%s'" %
(imgSet.getFileName(), imgStar))
# Pass stack file as None to avoid write the images files
writeSetOfParticles(imgSet, imgStar, self._getExtraPath())
if self.doCtfManualGroups:
self._splitInCTFGroups(imgStar)
if not self.IS_CLASSIFY:
if self.realignMovieFrames:
movieParticleSet = self.inputMovieParticles.get()
auxMovieParticles = self._createSetOfMovieParticles(suffix='tmp')
auxMovieParticles.copyInfo(movieParticleSet)
# Discard the movie particles that are not present in the refinement set
for movieParticle in movieParticleSet:
particle = imgSet[movieParticle.getParticleId()]
if particle is not None:
auxMovieParticles.append(movieParticle)
writeSetOfParticles(auxMovieParticles,
self._getFileName('movie_particles'), None, originalSet=imgSet,
postprocessImageRow=self._postprocessImageRow)
mdMovies = md.MetaData(self._getFileName('movie_particles'))
mdParts = md.MetaData(self._getFileName('input_star'))
if getVersion() == "1.4":
mdParts.renameColumn(md.RLN_IMAGE_NAME, md.RLN_PARTICLE_ORI_NAME)
else:
mdParts.renameColumn(md.RLN_IMAGE_NAME, md.RLN_PARTICLE_NAME)
mdParts.removeLabel(md.RLN_MICROGRAPH_NAME)
detectorPxSize = movieParticleSet.getAcquisition().getMagnification() * movieParticleSet.getSamplingRate() / 10000
mdAux = md.MetaData()
mdMovies.fillConstant(md.RLN_CTF_DETECTOR_PIXEL_SIZE, detectorPxSize)
mdAux.join2(mdMovies, mdParts, md.RLN_PARTICLE_ID, md.RLN_IMAGE_ID, md.INNER_JOIN)
mdAux.write(self._getFileName('movie_particles'), md.MD_OVERWRITE)
cleanPath(auxMovieParticles.getFileName())
def sortImages(self, inputId):
imagesMd = self._getPath('images.xmd')
writeSetOfParticles(self.inputParticles.get(), imagesMd)
args = "-i Particles@%s --addToInput " % imagesMd
if self.autoParRejection == self.REJ_MAXZSCORE:
args += "--zcut " + str(self.maxZscore.get())
elif self.autoParRejection == self.REJ_PERCENTAGE:
args += "--percent " + str(self.percentage.get())
self.runJob("xmipp_image_sort_by_statistics", args)
self.outputMd = String(imagesMd)
def convertStep(self, imgsFn):
from convert import writeSetOfClasses2D, writeSetOfParticles
imgSet = self.inputSet.get()
if isinstance(imgSet, SetOfClasses2D):
writeSetOfClasses2D(imgSet, self.imgsFn, writeParticles=True)
else:
writeSetOfParticles(imgSet, self.imgsFn)
from pyworkflow.em.convert import ImageHandler
img = ImageHandler()
fnVol = self._getTmpPath("volume.vol")
img.convert(self.inputVolume.get(), fnVol)
xdim = self.inputVolume.get().getDim()[0]
if xdim != self._getDimensions():
self.runJob("xmipp_image_resize",
"-i %s --dim %d" % (fnVol, self._getDimensions()))
def convertInputStep(self, inputId, avgId, volId):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
Params:
particlesId: use this parameters just to force redo of convert if
the input particles are changed.
"""
inputSet = self.inputSet.get()
imgStar = self._getFileName('input_particles')
refStar = self._getFileName('input_refs')
# Pass stack file as None to avoid write the images files
self.info("Converting set from '%s' into '%s'" %
(inputSet.getFileName(), imgStar))
refSet = None
# case refine3D
if self.isInputClasses():
refSet = self.inputSet.get() # 2D or 3D classes
else:
if self.isInputAutoRefine():
em.ImageHandler().convert(self.referenceVolume.get(),
self._getFileName('input_refvol'))
else: # Autopicking case
refSet = self.referenceAverages.get()
self.classDict = {}
if refSet:
self.info("Converting reference from '%s' into %s" %
(refSet.getFileName(), refStar))
# Compute class mapping
classList = [cls.getObjId() for cls in refSet]
classList.sort()
for i, c in enumerate(classList):
self.classDict[c] = i + 1
writeReferences(refSet,
removeExt(refStar),
postprocessImageRow=self._updateClasses)
# Write particles star file
allParticles = self._allParticles(iterate=False)
writeSetOfParticles(allParticles,
imgStar,
self._getPath(),
postprocessImageRow=self._postProcessImageRow)
def convertInputStep(self, classesFn):
inputSet = self.inputSet.get()
if isinstance(inputSet, SetOfClasses2D):
writeSetOfClasses2D(inputSet, classesFn, writeParticles=False)
else:
writeSetOfParticles(inputSet, classesFn)
if self.thereisRefVolume:
inputVolume = self.refVolume.get()
fnVolumes = self._getExtraPath('input_volumes.xmd')
row = XmippMdRow()
volumeToRow(inputVolume, row, alignType=ALIGN_NONE)
md = xmipp.MetaData()
row.writeToMd(md, md.addObject())
md.write(fnVolumes)
def convertInputStep(self, classesFn):
inputSet = self.inputSet.get()
if isinstance(inputSet, SetOfClasses2D):
writeSetOfClasses2D(inputSet, classesFn, writeParticles=False)
else:
writeSetOfParticles(inputSet, classesFn)
if self.thereisRefVolume:
inputVolume= self.refVolume.get()
fnVolumes = self._getExtraPath('input_volumes.xmd')
row = XmippMdRow()
volumeToRow(inputVolume, row, alignType = ALIGN_NONE)
md = xmipp.MetaData()
row.writeToMd(md, md.addObject())
md.write(fnVolumes)
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 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 exportParticlesStep(self, particlesId):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
"""
imgSet = self.inputParticles.get()
self._stackType = self.stackType.get()
self._ih = em.ImageHandler()
self._stackDict = {}
particlesPath = self._getPath('Particles')
pwutils.cleanPath(particlesPath)
pwutils.makePath(particlesPath)
alignType = imgSet.getAlignment() if self.useAlignment else em.ALIGN_NONE
# Create links to binary files and write the relion .star file
writeSetOfParticles(imgSet, self._getPath("particles.star"),
outputDir=self._getExtraPath(),
alignType=alignType,
postprocessImageRow=self._postprocessImageRow,
fillMagnification=True)
pwutils.prettyDict(self._stackDict)
def convertInputStep(self, particlesId):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
Params:
particlesId: use this parameter just to force redo of convert if
the input particles are changed.
"""
imgSet = self._getInputParticles()
imgStar = self._getFileName('movie_particles')
imgStarTmp = self._getTmpPath('movie_particles.star')
self.info("Converting set from '%s' into '%s'" %
(imgSet.getFileName(), imgStarTmp))
writeSetOfParticles(imgSet,
imgStarTmp,
self._getExtraPath(),
alignType=imgSet.getAlignment(),
extraLabels=MOVIE_EXTRA_LABELS)
mdImg = md.MetaData(imgStarTmp)
# replace mdColumn from *.stk to *.mrcs as Relion2 requires
if getVersion() == V1_3:
mdColumn = md.RLN_PARTICLE_NAME
else:
mdColumn = md.RLN_PARTICLE_ORI_NAME
from convert import relionToLocation, locationToRelion
for objId in mdImg:
index, imgPath = relionToLocation(mdImg.getValue(mdColumn, objId))
if not imgPath.endswith('mrcs'):
newName = pwutils.replaceBaseExt(os.path.basename(imgPath),
'mrcs')
newPath = self._getTmpPath(newName)
newLoc = locationToRelion(index, newPath)
if not exists(newPath):
pwutils.createLink(imgPath, newPath)
mdImg.setValue(mdColumn, newLoc, objId)
mdImg.write(imgStar)
def exportParticlesStep(self, particlesId):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
"""
imgSet = self.inputParticles.get()
self._stackType = self.stackType.get()
self._ih = em.ImageHandler()
self._stackDict = {}
particlesPath = self._getPath('Particles')
pwutils.cleanPath(particlesPath)
pwutils.makePath(particlesPath)
alignType = imgSet.getAlignment(
) if self.useAlignment else em.ALIGN_NONE
# Create links to binary files and write the relion .star file
writeSetOfParticles(imgSet,
self._getPath("particles.star"),
outputDir=self._getExtraPath(),
alignType=alignType,
postprocessImageRow=self._postprocessImageRow,
fillMagnification=True)
pwutils.prettyDict(self._stackDict)
def convertInputStep(self):
writeSetOfParticles(self.inputParticles.get(),
self.imgsFn,
alignType=em.ALIGN_NONE)
def convertInputStep(self):
writeSetOfParticles(self.inputParticles.get(), self.imgsFn)
def convertInputStep(self, particlesId):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
Params:
particlesId: use this parameters just to force redo of convert if
the input particles are changed.
"""
imgSet = self._getInputParticles()
imgStar = self._getFileName('input_star')
self.info("Converting set from '%s' into '%s'" %
(imgSet.getFileName(), imgStar))
# Pass stack file as None to avoid write the images files
writeSetOfParticles(imgSet, imgStar, self._getExtraPath())
if self.doCtfManualGroups:
self._splitInCTFGroups(imgStar)
if not self.IS_CLASSIFY:
if self.realignMovieFrames:
movieParticleSet = self.inputMovieParticles.get()
auxMovieParticles = self._createSetOfMovieParticles(
suffix='tmp')
auxMovieParticles.copyInfo(movieParticleSet)
# Discard the movie particles that are not present in the refinement set
for movieParticle in movieParticleSet:
particle = imgSet[movieParticle.getParticleId()]
if particle is not None:
auxMovieParticles.append(movieParticle)
writeSetOfParticles(
auxMovieParticles,
self._getFileName('movie_particles'),
None,
originalSet=imgSet,
postprocessImageRow=self._postprocessImageRow)
mdMovies = md.MetaData(self._getFileName('movie_particles'))
mdParts = md.MetaData(self._getFileName('input_star'))
if getVersion() == "1.4":
mdParts.renameColumn(md.RLN_IMAGE_NAME,
md.RLN_PARTICLE_ORI_NAME)
else:
mdParts.renameColumn(md.RLN_IMAGE_NAME,
md.RLN_PARTICLE_NAME)
mdParts.removeLabel(md.RLN_MICROGRAPH_NAME)
detectorPxSize = movieParticleSet.getAcquisition(
).getMagnification() * movieParticleSet.getSamplingRate(
) / 10000
mdAux = md.MetaData()
mdMovies.fillConstant(md.RLN_CTF_DETECTOR_PIXEL_SIZE,
detectorPxSize)
mdAux.join2(mdMovies, mdParts, md.RLN_PARTICLE_ID,
md.RLN_IMAGE_ID, md.INNER_JOIN)
mdAux.write(self._getFileName('movie_particles'),
md.MD_OVERWRITE)
cleanPath(auxMovieParticles.getFileName())
def convertInputStep(self, movId, partId, postId):
inputMovies = self.inputMovies.get()
inputParts = self.inputParticles.get()
imgStar = self._getPath('input_particles.star')
inputPartsFolder = self._getInputPath('particles')
pwutils.makePath(inputPartsFolder)
self.info("Converting set from '%s' into '%s'" %
(inputParts.getFileName(), imgStar))
tableMovies = Table(
columns=['rlnMicrographName', 'rlnMicrographMetadata'])
tableGeneral = Table(columns=[
'rlnImageSizeX', 'rlnImageSizeY', 'rlnImageSizeZ',
'rlnMicrographMovieName', 'rlnMicrographBinning',
'rlnMicrographOriginalPixelSize', 'rlnMicrographDoseRate',
'rlnMicrographPreExposure', 'rlnVoltage',
'rlnMicrographStartFrame', 'rlnMotionModelVersion'
])
tableShifts = Table(columns=[
'rlnMicrographFrameNumber', 'rlnMicrographShiftX',
'rlnMicrographShiftY'
])
tableCoeffs = Table(
columns=['rlnMotionModelCoeffsIdx', 'rlnMotionModelCoeff'])
# Create the first row, later only the movieName will be updated
xdim, ydim, ndim = inputMovies.getDim()
acq = inputMovies.getAcquisition()
firstMovie = inputMovies.getFirstItem()
a0, aN = firstMovie.getAlignment().getRange()
moviesPixelSize = inputMovies.getSamplingRate()
binningFactor = inputParts.getSamplingRate() / moviesPixelSize
hasLocal = firstMovie.hasAttribute('_rlnMotionModelCoeff')
motionMode = 1 if hasLocal else 0
tableGeneral.addRow(xdim, ydim, ndim, 'movieName',
binningFactor, moviesPixelSize,
acq.getDosePerFrame(), acq.getDoseInitial(),
acq.getVoltage(), a0, motionMode)
row = tableGeneral[0]
for movie in inputMovies:
movieFn = movie.getFileName()
movieBase = os.path.basename(movieFn)
movieStar = self._getInputPath(
pwutils.replaceBaseExt(movieFn, 'star'))
tableMovies.addRow(movieBase, movieStar)
with open(movieStar, 'w') as f:
# Update Movie name
tableGeneral[0] = row._replace(rlnMicrographMovieName=movieFn)
tableGeneral.writeStar(f, tableName='general', singleRow=True)
# Write shifts
tableShifts.clearRows()
alignment = movie.getAlignment()
shiftsX, shiftsY = alignment.getShifts()
a0, aN = alignment.getRange()
empty = -9999.000
for i in range(1, a0):
tableShifts.addRow(i, empty, empty)
# Adjust the shifts to be relative to the first frame
# so let's add the opposite value
xoff, yoff = -shiftsX[0], -shiftsY[0]
for i in range(a0, aN + 1):
tableShifts.addRow(i, shiftsX[i - a0] + xoff,
shiftsY[i - a0] + yoff)
for i in range(aN + 1, ndim + 1):
tableShifts.addRow(i, empty, empty)
tableShifts.writeStar(f, tableName='global_shift')
# Write coefficients
if hasLocal:
coeffs = movie.getAttributeValue('_rlnMotionModelCoeff',
'')
tableCoeffs.clearRows()
for i, c in enumerate(json.loads(coeffs)):
tableCoeffs.addRow(i, c)
tableCoeffs.writeStar(f, tableName='local_motion_model')
with open(self._getPath('input_corrected_micrographs.star'), 'w') as f:
tableMovies.writeStar(f)
convert.writeSetOfParticles(inputParts,
imgStar,
inputPartsFolder,
alignType=em.ALIGN_PROJ,
fillMagnification=True,
fillRandomSubset=True)
def convertInputStep(self, particlesId):
""" Write the input images as a Relion star file.
"""
imgSet = self.inputParticles.get()
writeSetOfParticles(imgSet, self._getFileName('input_star'),
self._getExtraPath())
def convertInputStep(self, resetDeps, copyAlignment):
""" Create the input file in STAR format as expected by Relion.
If the input particles comes from Relion, just link the file.
"""
imgStar = self._getFileName('input_star', lev=self._level, rLev=1)
if self._level == 1:
makePath(self._getRunPath(self._level, 1))
imgSet = self._getInputParticles()
self.info("Converting set from '%s' into '%s'" %
(imgSet.getFileName(), imgStar))
# Pass stack file as None to avoid write the images files
# If copyAlignment is set to False pass alignType to ALIGN_NONE
alignType = imgSet.getAlignment() if copyAlignment \
else em.ALIGN_NONE
hasAlign = alignType != em.ALIGN_NONE
alignToPrior = hasAlign and self._getBoolAttr('alignmentAsPriors')
fillRandomSubset = hasAlign and self._getBoolAttr(
'fillRandomSubset')
writeSetOfParticles(
imgSet,
imgStar,
self._getExtraPath(),
alignType=alignType,
postprocessImageRow=self._postprocessParticleRow,
fillRandomSubset=fillRandomSubset)
if alignToPrior:
self._copyAlignAsPriors(imgStar, alignType)
if self.doCtfManualGroups:
self._splitInCTFGroups(imgStar)
self._convertVol(em.ImageHandler(), self.inputVolumes.get())
else:
noOfLevRuns = self._getLevRuns(self._level)
lastCls = None
prevStar = self._getFileName('outputData', lev=self._level - 1)
mdData = md.MetaData(prevStar)
print('how many run levels? %d' % noOfLevRuns)
for row in md.iterRows(mdData, sortByLabel=md.RLN_PARTICLE_CLASS):
clsPart = row.getValue(md.RLN_PARTICLE_CLASS)
if clsPart != lastCls:
makePath(self._getRunPath(self._level, clsPart))
if lastCls is not None:
print("writing %s" % fn)
mdInput.write(fn)
paths = self._getRunPath(self._level, clsPart)
makePath(paths)
print("Path: %s and newRlev: %d" % (paths, clsPart))
lastCls = clsPart
mdInput = md.MetaData()
fn = self._getFileName('input_star',
lev=self._level,
rLev=clsPart)
objId = mdInput.addObject()
row.writeToMd(mdInput, objId)
print("writing %s and ending the loop" % fn)
mdInput.write(fn)
def convertInputStep(self):
writeSetOfParticles(self.inputParticles.get(),self.imgsFn)
def convertInputStep(self):
writeSetOfParticles(self.inputParticles.get(),self.imgsFn,alignType=constants.ALIGN_NONE)
def convertInputStep(self, outputFn):
""" Create a metadata with the images and geometrical information. """
writeSetOfParticles(self.inputParticles.get(), outputFn, self._getPath())
def convertInputStep(self, inputParticlesId):
writeSetOfParticles(self.directionalClasses.get(),self._getExtraPath("directionalClasses.xmd"))
def convertInputStep(self, outputFn):
""" Create a metadata with the images and geometrical information. """
writeSetOfParticles(self.inputParticles.get(), outputFn)
return [outputFn]
def convertInputStep(self, inputParticlesId):
writeSetOfParticles(self.inputParticles.get(),self.imgsFn)
self.runJob('xmipp_metadata_utilities','-i %s --fill image1 constant noImage'%self.imgsFn,numberOfMpi=1)
self.runJob('xmipp_metadata_utilities','-i %s --operate modify_values "image1=image"'%self.imgsFn,numberOfMpi=1)
self.runJob('xmipp_metadata_utilities','-i %s --operate rename_column "itemId particleId"'%self.imgsFn,numberOfMpi=1)
