def _createOutputMovie(self, movie):
# Parse the alignment parameters and store the log files
alignedMovie = movie.clone()
n = movie.getNumberOfFrames()
first, last = self._getFrameRange(n, 'align')
framesRange = alignedMovie.getFramesRange()
framesRange.setFirstFrame(first)
framesRange.setLastFrame(last)
# Check if user selected to save movie, use the getAttributeValue
# function for allow the protocol to not define this flag
# and use False as default
if self.getAttributeValue('doSaveMovie', False):
# The subclass protocol is responsible of generating the output
# movie file in the extra path with the required name
extraMovieFn = self._getExtraPath(self._getOutputMovieName(movie))
alignedMovie.setFileName(extraMovieFn)
# When the output movies are saved, the shifts
# will be set to zero since they are aligned
totalFrames = last - first + 1
xshifts = [0] * totalFrames
yshifts = xshifts
# If we save the movies, we need to modify which are the index
# of the first frame in the stack, now is 1 since the stack is
# written only with the given frames
firstFrameIndex = 1
else:
xshifts, yshifts = self._getMovieShifts(movie)
firstFrameIndex = first
framesRange.setFirstFrameIndex(firstFrameIndex)
alignment = emobj.MovieAlignment(first=first,
last=last,
xshifts=xshifts,
yshifts=yshifts)
roiList = [
self.getAttributeValue(s, 0)
for s in ['cropOffsetX', 'cropOffsetY', 'cropDimX', 'cropDimY']
]
alignment.setRoi(roiList)
alignedMovie.setAlignment(alignment)
return alignedMovie
def processMovieStep(self, movieDict, hasAlignment):
movie = emobj.Movie()
movie.setAcquisition(emobj.Acquisition())
if hasAlignment:
movie.setAlignment(emobj.MovieAlignment())
movie.setAttributesFromDict(movieDict,
setBasic=True,
ignoreMissing=True)
movieFolder = self._getOutputMovieFolder(movie)
movieFn = movie.getFileName()
movieName = basename(movieFn)
movieDoneFn = self._getMovieDone(movie)
if self.isContinued() and os.path.exists(movieDoneFn):
self.info("Skipping movie: %s, seems to be done" % movieFn)
return
# Clean old finished files
pwutils.cleanPath(movieDoneFn)
if self._filterMovie(movie):
pwutils.makePath(movieFolder)
pwutils.createLink(movieFn, join(movieFolder, movieName))
if movieName.endswith('bz2'):
newMovieName = movieName.replace('.bz2', '')
# We assume that if compressed the name ends with .mrc.bz2
if not exists(newMovieName):
self.runJob('bzip2',
'-d -f %s' % movieName,
cwd=movieFolder)
elif movieName.endswith('tbz'):
newMovieName = movieName.replace('.tbz', '.mrc')
# We assume that if compressed the name ends with .tbz
if not exists(newMovieName):
self.runJob('tar', 'jxf %s' % movieName, cwd=movieFolder)
elif movieName.endswith('.txt'):
# Support a list of frame as a simple .txt file containing
# all the frames in a raw list, we could use a xmd as well,
# but a plain text was choose to simply its generation
movieTxt = os.path.join(movieFolder, movieName)
with open(movieTxt) as f:
movieOrigin = os.path.basename(os.readlink(movieFn))
newMovieName = movieName.replace('.txt', '.mrcs')
ih = emlib.image.ImageHandler()
for i, line in enumerate(f):
if line.strip():
inputFrame = os.path.join(movieOrigin,
line.strip())
ih.convert(
inputFrame,
(i + 1, os.path.join(movieFolder,
newMovieName)))
else:
newMovieName = movieName
convertExt = self._getConvertExtension(newMovieName)
correctGain = self._doCorrectGain()
if convertExt or correctGain:
inputMovieFn = os.path.join(movieFolder, newMovieName)
if inputMovieFn.endswith('.em'):
inputMovieFn += ":ems"
if convertExt:
newMovieName = pwutils.replaceExt(newMovieName, convertExt)
else:
newMovieName = '%s_corrected.%s' % os.path.splitext(
newMovieName)
outputMovieFn = os.path.join(movieFolder, newMovieName)
# If the protocols wants Scipion to apply the gain, then
# there is no reason to convert, since we can produce the
# output in the format expected by the program. In some cases,
# the alignment programs can directly deal with gain and dark
# correction images, so we don't need to apply it
if self._doCorrectGain():
self.info("Correcting gain and dark '%s' -> '%s'" %
(inputMovieFn, outputMovieFn))
gain, dark = self.getGainAndDark()
self.correctGain(inputMovieFn,
outputMovieFn,
gainFn=gain,
darkFn=dark)
else:
self.info("Converting movie '%s' -> '%s'" %
(inputMovieFn, outputMovieFn))
emlib.image.ImageHandler().convertStack(
inputMovieFn, outputMovieFn)
# Just store the original name in case it is needed in _processMovie
movie._originalFileName = pwobj.String(objDoStore=False)
movie._originalFileName.set(movie.getFileName())
# Now set the new filename (either linked or converted)
movie.setFileName(os.path.join(movieFolder, newMovieName))
self.info("Processing movie: %s" % movie.getFileName())
self._processMovie(movie)
if self._doMovieFolderCleanUp():
self._cleanMovieFolder(movieFolder)
# Mark this movie as finished
open(movieDoneFn, 'w').close()