def convertInputStep(self, particlesId, volId):
""" Write the input images as a Xmipp metadata file.
particlesId: is only need to detect changes in
input particles and cause restart from here.
"""
inputParticles = self.inputParticles.get()
inputVolume = self.inputVolume.get()
writeSetOfParticles(inputParticles, self._getExpParticlesFn())
img = ImageHandler()
img.convert(inputVolume, self._getInputVolFn())
if self._useSeveralClasses():
# Scale particles
Xdim = inputParticles.getXDim()
Ts = inputParticles.getSamplingRate()
newTs = self.targetResolution.get() * 0.4
newTs = max(Ts, newTs)
newXdim = Xdim * Ts / newTs
self.runJob("xmipp_image_resize",
"-i %s -o %s --save_metadata_stack %s --fourier %d" %
(self._getExpParticlesFn(),
self._getTmpPath('scaled_particles.stk'),
self._getTmpPath('scaled_particles.xmd'),
newXdim))
# Scale volume
Xdim = inputVolume.getXDim()
if Xdim != newXdim:
self.runJob("xmipp_image_resize", "-i %s --dim %d"
% (self._getInputVolFn(), newXdim), numberOfMpi=1)
def createOutputStep(self):
particles = self.inputParticles.get()
# Generate the SetOfAlignmet
alignedSet = self._createSetOfParticles()
alignedSet.copyInfo(particles)
inputMd = self._getPath('aligned_particles.xmd')
alignedSet.copyItems(particles,
updateItemCallback=self._updateItem,
itemDataIterator=iterMdRows(inputMd))
# Remove alignment 2D
alignedSet.setAlignment(ALIGN_NONE)
# Define the output average
avgFile = self._getExtraPath("average.xmp")
imgh = ImageHandler()
avgImage = imgh.computeAverage(alignedSet)
avgImage.write(avgFile)
avg = Particle()
avg.setLocation(1, avgFile)
avg.copyInfo(alignedSet)
self._defineOutputs(outputAverage=avg)
self._defineSourceRelation(self.inputParticles, avg)
self._defineOutputs(outputParticles=alignedSet)
self._defineSourceRelation(self.inputParticles, alignedSet)
class ImagePreviewDialog(PreviewDialog):
def _beforePreview(self):
self.dim = 256
self.previewLabel = ''
def _createPreview(self, frame):
""" Should be implemented by subclasses to
create the items preview.
"""
from pyworkflow.gui.matplotlib_image import ImagePreview
self.preview = ImagePreview(frame, self.dim, label=self.previewLabel)
self.preview.grid(row=0, column=0)
def _itemSelected(self, obj):
index = obj.getIndex()
filename = obj.getFileName()
if index:
filename = "%03d@%s" % (index, filename)
# self.image = xmipp.Image()
self.image = ImageHandler()._img
try:
self.image.readPreview(filename, self.dim)
if filename.endswith('.psd'):
self.image.convertPSD()
self.Z = self.image.getData()
except Exception, e:
from pyworkflow.gui.matplotlib_image import getPngData
self.Z = getPngData(findResource('no-image.png'))
dialog.showError("Input particles", "Error reading image <%s>" % filename, self)
self.preview.updateData(self.Z)
def importVolumesStep(self, pattern, samplingRate):
""" Copy images matching the filename pattern
Register other parameters.
"""
self.info("Using pattern: '%s'" % pattern)
# Create a Volume template object
vol = Volume()
vol.setSamplingRate(self.samplingRate.get())
copyOrLink = self.getCopyOrLink()
imgh = ImageHandler()
volSet = self._createSetOfVolumes()
volSet.setSamplingRate(self.samplingRate.get())
for fileName, fileId in self.iterFiles():
dst = self._getExtraPath(basename(fileName))
copyOrLink(fileName, dst)
x, y, z, n = imgh.getDimensions(dst)
# First case considers when reading mrc without volume flag
# Second one considers single volumes (not in stack)
if (z == 1 and n != 1) or (z !=1 and n == 1):
vol.setObjId(fileId)
vol.setLocation(dst)
volSet.append(vol)
else:
for index in range(1, n+1):
vol.cleanObjId()
vol.setLocation(index, dst)
volSet.append(vol)
if volSet.getSize() > 1:
self._defineOutputs(outputVolumes=volSet)
else:
self._defineOutputs(outputVolume=vol)
def _buildDendrogram(self, leftIndex, rightIndex, index, writeAverages=False, level=0):
""" This function is recursively called to create the dendogram graph(binary tree)
and also to write the average image files.
Params:
leftIndex, rightIndex: the indinxes within the list where to search.
index: the index of the class average.
writeImages: flag to select when to write averages.
From self:
self.dendroValues: the list with the heights of each node
self.dendroImages: image stack filename to read particles
self.dendroAverages: stack name where to write averages
It will search for the max in values list (between minIndex and maxIndex).
Nodes to the left of the max are left childs and the other right childs.
"""
maxValue = self.dendroValues[leftIndex]
maxIndex = 0
for i, v in enumerate(self.dendroValues[leftIndex+1:rightIndex]):
if v > maxValue:
maxValue = v
maxIndex = i+1
m = maxIndex + leftIndex
node = DendroNode(index, maxValue)
ih = ImageHandler()
particleNumber = self.dendroIndexes[m+1]
node.imageList = [particleNumber]
if writeAverages:
node.image = ih.read((particleNumber, self.dendroImages))
def addChildNode(left, right, index):
if right > left:
child = self._buildDendrogram(left, right, index, writeAverages, level+1)
node.addChild(child)
node.length += child.length
node.imageList += child.imageList
if writeAverages:
node.image += child.image
del child.image # Allow to free child image memory
if rightIndex > leftIndex + 1 and level < self.dendroMaxLevel:
addChildNode(leftIndex, m, 2*index)
addChildNode(m+1, rightIndex, 2*index+1)
node.avgCount = self.dendroAverageCount + 1
self.dendroAverageCount += 1
node.path = '%d@%s' % (node.avgCount, self.dendroAverages)
if writeAverages:
#TODO: node['image'] /= float(node['length'])
#node.image.inplaceDivide(float(node.length)) #FIXME: not working, noisy images
avgImage = node.image / float(node.length)
ih.write(avgImage, (node.avgCount, self.dendroAverages))
fn = self._getTmpPath('doc_class%03d.stk' % index)
doc = SpiderDocFile(fn, 'w+')
for i in node.imageList:
doc.writeValues(i)
doc.close()
return node
def test_readDM4(self):
""" Check we can read dm4 files (using EMAN)
"""
micFn = self.dsFormat.getFile('SuperRef_c3-adp-se-xyz-0228_001.dm4')
ih = ImageHandler()
# Check that we can read the dimensions of the dm4 file:
EXPECTED_SIZE = (7676, 7420, 1, 1)
self.assertEqual(ih.getDimensions(micFn), EXPECTED_SIZE)
# We could even convert to an mrc file:
outSuffix = pwutils.replaceBaseExt(micFn, 'mrc')
outFn = join('/tmp', outSuffix)
print "Converting: \n%s -> %s" % (micFn, outFn)
ih.convert(micFn, outFn)
self.assertTrue(os.path.exists(outFn))
self.assertTrue(pwutils.getFileSize(outFn) > 0)
# Check dimensions are still the same:
self.assertEqual(ih.getDimensions(outFn), EXPECTED_SIZE)
# Clean up tmp files
pwutils.cleanPath(outFn)
def _validateImages(self):
errors = []
ih = ImageHandler()
for imgFn, _ in self.iterFiles():
if isdir(imgFn):
errors.append("Folders can not be selected.")
errors.append(' %s' % imgFn)
else:
# Check if images are correct by reading the header of the
# imported files:
# Exceptions:
# - Compressed movies (bz2 or tbz extensions)
# - Importing in streaming, since files may be incomplete
# - Bad characters in path [':' ,'%', '#']
if (not self.dataStreaming and
not (imgFn.endswith('bz2') or
imgFn.endswith('tbz') or
ih.isImageFile(imgFn))):
if not errors: # if empty add the first line
errors.append("Error reading the following images:")
errors.append(' %s' % imgFn)
errors += ProtImportImages.validatePath(imgFn)
return errors
def prepareMask(self,maskObject,fnMask,TsMaskOut,XdimOut):
img=ImageHandler()
img.convert(maskObject, fnMask)
self.runJob('xmipp_image_resize',"-i %s --factor %f"%(fnMask,maskObject.getSamplingRate()/TsMaskOut),numberOfMpi=1)
maskXdim, _, _, _ =img.getDimensions((1,fnMask))
if XdimOut!=maskXdim:
self.runJob('xmipp_transform_window',"-i %s --size %d"%(fnMask,XdimOut),numberOfMpi=1)
self.runJob('xmipp_transform_threshold',"-i %s --select below 0.5 --substitute binarize"%fnMask,numberOfMpi=1)
def _particlesToEmx(emxData, partSet, micSet=None, **kwargs):
""" Write a SetOfMicrograph as expected in EMX format
Params:
micSet: input set of micrographs
filename: the EMX file where to store the micrographs information.
micSet: micrographs set associated with the particles
**kwargs: writeImages: if set to False, only coordinates are exported.
imagesStack: if passed all images will be output into a single
stack file.
imagesPrefix: used when not imagesStack is passed. A different
stack will be created per micrograph.
"""
writeImages = kwargs.get('writeImages', True)
imagesPrefix = kwargs.get('imagesPrefix', None)
micDict = {}
# Use singleMic for count all particles to be written to a single stack
imagesStack = kwargs.get('imagesStack', None)
singleMic = Micrograph()
singleMic.setFileName(imagesStack)
singleMic.counter = pwobj.Integer(0)
def _getMicKey(particle):
coord = particle.getCoordinate()
if coord is None or coord.getMicName() is None:
return '%05d' % particle.getMicId()
else:
return pwutils.removeExt(coord.getMicName())
def _getLocation(particle):
if imagesStack is not None:
mic = singleMic
else:
micKey = _getMicKey(particle)
if micKey not in micDict:
mic = Micrograph()
mic.setFileName(join(imagesPrefix, 'particles_%s.mrc' % micKey))
mic.counter = pwobj.Integer(0)
micDict[micKey] = mic
else:
mic = micDict[micKey]
# Count one more particle assigned to this micrograph
mic.counter.increment()
return (mic.counter.get(), mic.getFileName())
ih = ImageHandler()
partAlign = partSet.getAlignment()
for particle in partSet:
if writeImages:
newLoc = _getLocation(particle)
ih.convert(particle, newLoc)
localFn = basename(newLoc[1])
particle.setLocation(newLoc[0], localFn)
emxObj = _particleToEmx(emxData, particle, micSet, partAlign)
else:
emxObj = _coordinateToEmx(emxData, particle, micSet)
emxData.addObject(emxObj)
def _runBeforePreWhitening(self):
prot = self.form.protocol
# Convert input volumes
ih = ImageHandler()
ih.convert(prot.inputVolume.get(), join(self.workingDir, 'volume1.map'))
if prot.useSplitVolume:
ih.convert(prot.splitVolume.get(), join(self.workingDir, 'volume2.map'))
self.results = prot.runResmap(self.workingDir, wizardMode=True)
def projectInitialVolume(self):
fnOutputInitVolume=self._getTmpPath("initialVolume.vol")
img = ImageHandler()
img.convert(self.initialVolume.get(), fnOutputInitVolume)
self.runJob("xmipp_image_resize","-i %s --dim %d %d"%(fnOutputInitVolume,self.Xdim2,self.Xdim2))
fnGallery=self._getTmpPath('gallery_InitialVolume.stk')
fnOutputReducedClass = self._getExtraPath("reducedClasses.xmd")
self.runJob("xmipp_angular_project_library", "-i %s -o %s --sampling_rate %f --sym %s --method fourier 1 0.25 bspline --compute_neighbors --angular_distance -1 --experimental_images %s"\
%(fnOutputInitVolume,fnGallery,self.angularSampling.get(),self.symmetryGroup.get(),fnOutputReducedClass))
def importImagesStep(self, pattern, voltage, sphericalAberration, amplitudeContrast, magnification):
""" Copy images matching the filename pattern
Register other parameters.
"""
self.info("Using pattern: '%s'" % pattern)
createSetFunc = getattr(self, '_create' + self._outputClassName)
imgSet = createSetFunc()
imgSet.setIsPhaseFlipped(self.haveDataBeenPhaseFlipped.get())
acquisition = imgSet.getAcquisition()
self.fillAcquisition(acquisition)
# Call a function that should be implemented by each subclass
self.setSamplingRate(imgSet)
outFiles = [imgSet.getFileName()]
imgh = ImageHandler()
img = imgSet.ITEM_TYPE()
img.setAcquisition(acquisition)
n = 1
copyOrLink = self.getCopyOrLink()
for i, (fileName, fileId) in enumerate(self.iterFiles()):
dst = self._getExtraPath(basename(fileName))
copyOrLink(fileName, dst)
# Handle special case of Imagic images, copying also .img or .hed
self.handleImgHed(copyOrLink, fileName, dst)
if self._checkStacks:
_, _, _, n = imgh.getDimensions(dst)
if n > 1:
for index in range(1, n+1):
img.cleanObjId()
img.setMicId(fileId)
img.setFileName(dst)
img.setIndex(index)
imgSet.append(img)
else:
img.setObjId(fileId)
img.setFileName(dst)
self._fillMicName(img, fileName) # fill the micName if img is a Micrograph.
imgSet.append(img)
outFiles.append(dst)
sys.stdout.write("\rImported %d/%d" % (i+1, self.numberOfFiles))
sys.stdout.flush()
print "\n"
args = {}
outputSet = self._getOutputName()
args[outputSet] = imgSet
self._defineOutputs(**args)
return outFiles
def _beforePreWhitening(protocol, dir):
from pyworkflow.em.convert import ImageHandler
# Convert input volumes
ih = ImageHandler()
inputVolume = protocol.inputVolume.get()
path = join(dir, 'volume1.map')
print path
ih.convert(inputVolume, path)
if protocol.useSplitVolume:
ih.convert(protocol.splitVolume.get(), join(dir, 'volume2.map'))
return protocol.runResmap(dir, wizardMode=True)
def createMaskStep(self):
""" Create a circular mask in Imagic format. """
inputParticles = self.inputParticles.get()
radius = self.radius.get()
if self.maskType.get() == 0:
if radius < 0: # usually -1
radiusMask = inputParticles.getDim()[0] / 2 # use half of input dim
else:
radiusMask = radius
outMask = self._getTmpPath('mask.img')
ih = ImageHandler()
ih.createCircularMask(radiusMask, inputParticles.getFirstItem(), outMask)
def testExistLocation(self):
volFn = self.dataset.getFile('volumes/volume_1_iter_002.mrc')
ih = ImageHandler()
# Test the volume filename exists
self.assertTrue(ih.existsLocation(volFn))
# Test missing filename
self.assertFalse(ih.existsLocation(volFn.replace('.mrc', '_fake.mrc')))
# Test the :mrc is append when used as volume
newFn = ih.getVolFileName(volFn)
self.assertEqual(newFn, volFn + ":mrc")
# Test that the new filename still exists even with the :mrc suffix
self.assertTrue(ih.existsLocation(newFn))
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):
""" Write the input images as a Xmipp metadata file.
particlesId: is only need to detect changes in
input particles and cause restart from here.
"""
writeSetOfParticles(self.inputParticles.get(),
self._getPath('input_particles.xmd'))
if self.doWiener.get():
params = ' -i %s' % self._getPath('input_particles.xmd')
params += ' -o %s' % self._getExtraPath('corrected_ctf_particles.stk')
params += ' --save_metadata_stack %s' % self._getExtraPath('corrected_ctf_particles.xmd')
params += ' --pad %s' % self.padding_factor.get()
params += ' --wc %s' % self.wiener_constant.get()
params += ' --sampling_rate %s' % self.inputParticles.get().getSamplingRate()
if self.inputParticles.get().isPhaseFlipped():
params += ' --phase_flipped '
if self.correctEnvelope:
params += ' --correct_envelope '
nproc = self.numberOfMpi.get()
nT=self.numberOfThreads.get()
self.runJob('xmipp_ctf_correct_wiener2d',
params)
newTs, newXdim = self._getModifiedSizeAndSampling()
if self.doWiener.get():
params = ' -i %s' % self._getExtraPath('corrected_ctf_particles.xmd')
else :
params = ' -i %s' % self._getPath('input_particles.xmd')
params += ' -o %s' % self._getExtraPath('scaled_particles.stk')
params += ' --save_metadata_stack %s' % self._getExtraPath('scaled_particles.xmd')
params += ' --fourier %d' % newXdim
self.runJob('xmipp_image_resize',params)
from pyworkflow.em.convert import ImageHandler
img = ImageHandler()
img.convert(self.inputVolumes.get(), self._getExtraPath("volume.vol"))
Xdim = self.inputVolumes.get().getDim()[0]
if Xdim!=newXdim:
self.runJob("xmipp_image_resize","-i %s --dim %d"%\
(self._getExtraPath("volume.vol"),
newXdim), numberOfMpi=1)
def _beforePreview(self):
ImagePreviewDialog._beforePreview(self)
self.lastObj = None
self.rightPreviewLabel = "Filtered"
self.message = "Computing filtered image..."
self.previewLabel = "Image"
self.rightImage = ImageHandler()._img
def buildDendrogram(self, writeAverages=False):
""" Parse Spider docfile with the information to build the dendogram.
Params:
dendroFile: docfile with a row per image.
Each row contains the image id and the height.
"""
dendroFile = self._getFileName('dendroDoc')
# Dendrofile is a docfile with at least 3 data colums (class, height, id)
doc = SpiderDocFile(dendroFile)
values = []
indexes = []
for c, h, _ in doc.iterValues():
indexes.append(c)
values.append(h)
doc.close()
self.dendroValues = values
self.dendroIndexes = indexes
self.dendroImages = self._getFileName('particles')
self.dendroAverages = self._getFileName('averages')
self.dendroAverageCount = 0 # Write only the number of needed averages
self.dendroMaxLevel = 10 # FIXME: remove hard coding if working the levels
self.ih = ImageHandler()
return self._buildDendrogram(0, len(values)-1, 1, writeAverages)
def _beforePreview(self):
ImagePreviewDialog._beforePreview(self)
self.lastObj = None
self.rightPreviewLabel = "PSD"
self.message = "Computing PSD..."
self.previewLabel = "Micrograph"
self.rightImage = ImageHandler()._img
def _beforePreview(self):
ImagePreviewDialog._beforePreview(self)
self.lastObj = None
self.rightPreviewLabel = "Filtered particle"
self.message = "Filtering particle..."
self.previewLabel = "Particle"
self.rightImage = ImageHandler()._img
def _insertAllSteps(self):
self._params = {}
# diameter must be passed in Armstrongs and therefore should be converted
self._params['diam'] = self.diameter.get() * self.getInputMicrographs().getSamplingRate()
# self._params['num-slices'] = self.numberSizes.get()
# self._params['size-range'] = self.sizeRange.get()
self._params['apix'] = self.inputMicrographs.get().getSamplingRate()
self._params['thresh'] = self.threshold.get()
# self._params['max-thresh'] = self.maxThreshold.get()
# self._params['max-area'] = self.maxArea.get()
# self._params['max-peaks'] = self.maxPeaks.get()
args = ""
for par, val in self._params.iteritems():
args += " --%s=%s" % (par, str(val))
if self.invert:
args += " --invert"
args += " " + self.extraParams.get('')
deps = [] # Store all steps ids, final step createOutput depends on all of them
ih = ImageHandler()
for mic in self.inputMicrographs.get():
# Create micrograph folder
micName = mic.getFileName()
micDir = self._getTmpPath(removeBaseExt(micName))
makePath(micDir)
# If needed convert micrograph to mrc format, otherwise link it
if getExt(micName) != ".mrc":
fnMicBase = replaceBaseExt(micName, 'mrc')
inputMic = join(micDir, fnMicBase)
ih.convert(mic.getLocation(), inputMic)
else:
inputMic = join(micDir, basename(micName))
createLink(micName, inputMic)
# Insert step to execute program
stepId = self._insertFunctionStep('executeDogpickerStep', inputMic, args)
deps.append(stepId)
self._insertFinalSteps(deps)
def prepareReferences(self,fnDir,TsCurrent,targetResolution):
print "Preparing references to sampling rate=",TsCurrent
fnMask=''
newXdim=self.readInfoField(fnDir,"size",xmipp.MDL_XSIZE)
if self.nextMask.hasValue():
fnMask=join(fnDir,"mask.vol")
self.prepareMask(self.nextMask.get(), fnMask, TsCurrent, newXdim)
fnReferenceVol=join(fnDir,"volumeRef.vol")
img=ImageHandler()
img.convert(self.inputVolume.get(), fnReferenceVol)
Xdim=self.inputVolume.get().getDim()[0]
if Xdim!=newXdim:
self.runJob("xmipp_image_resize","-i %s --fourier %d"%(fnReferenceVol,newXdim),numberOfMpi=1)
if fnMask!='':
self.runJob('xmipp_image_operate','-i %s --mult %s'%(fnReferenceVol,fnMask),numberOfMpi=1)
def _beforePreview(self):
imgLocation = self.protocolParent.inputImage.get().getLocation()
self.dim = ImageHandler().getDimensions(imgLocation)[0]
self.lastObj = None
self.rightPreviewLabel = "Final mask"
self.message = "Generating mask..."
self.ih = ImageHandler()
self.rightImage = self.ih.createImage()
def writeSetOfImages(imgSet, stackFn, selFn):
""" This function will write a SetOfMicrographs as a Spider stack and selfile.
Params:
imgSet: the SetOfMicrograph instance.
stackFn: the filename where to write the stack.
selFn: the filename of the Spider selection file.
"""
ih = ImageHandler()
doc = SpiderDocFile(selFn, 'w+')
for i, img in enumerate(imgSet):
ih.convert(img, (i+1, stackFn))
doc.writeValues(i+1)
doc.close()
convertEndian(stackFn, imgSet.getSize())
def generateSplittedVolumes(self):
inputParticles = self.directionalClasses.get()
Xdim = inputParticles.getDimensions()[0]
fnMask = ""
if self.mask.hasValue():
fnMask = self._getExtraPath("mask.vol")
img=ImageHandler()
img.convert(self.mask.get(), fnMask)
self.runJob('xmipp_image_resize',"-i %s --dim %d"%(fnMask,Xdim),numberOfMpi=1)
self.runJob('xmipp_transform_threshold',"-i %s --select below 0.5 --substitute binarize"%fnMask,numberOfMpi=1)
args="-i %s --oroot %s --Nrec %d --Nsamples %d --sym %s --alpha %f"%\
(self._getExtraPath("directionalClasses.xmd"),self._getExtraPath("split"),self.Nrec.get(),self.Nsamples.get(),
self.symmetryGroup.get(), self.alpha.get())
if fnMask!="":
args+=" --mask binary_file %s"%fnMask
self.runJob("xmipp_classify_first_split",args)
def test_convertMovie(self):
"""Check movie conversion"""
movFn = self.dsFormat.getFile('qbeta/qbeta.mrc') + ":mrcs"
ih = ImageHandler()
# Check that we can read the dimensions of the dm4 file:
EXPECTED_SIZE = (4096, 4096, 1, 7)
EXPECTED_DT = ImageHandler.DT_USHORT
self.assertEqual(ih.getDimensions(movFn), EXPECTED_SIZE)
self.assertEqual(ih.getDataType(movFn), EXPECTED_DT)
outFn = join('/tmp/qbeta_converted.mrcs')
ih.convertStack(movFn, outFn, 2, 6)
self.assertTrue(os.path.exists(outFn))
self.assertTrue(pwutils.getFileSize(outFn) > 0)
self.assertEqual(ih.getDimensions(outFn), (4096, 4096, 1, 5))
self.assertEqual(ih.getDataType(outFn), EXPECTED_DT)
if pwutils.envVarOn('SCIPION_DEBUG_NOCLEAN'):
print "Not cleaning output movie: ", outFn
else:
pwutils.cleanPath(outFn)
def _validateImages(self):
errors = []
ih = ImageHandler()
for imgFn, _ in self.iterFiles():
if isdir(imgFn):
errors.append("Folders can not be selected.")
errors.append(' %s' % imgFn)
else:
# try to read the header of the imported images
# except for the special case of compressed movies (bz2 extension)
if not (imgFn.endswith('bz2') or imgFn.endswith('tbz') or ih.isImageFile(imgFn)):
if not errors: # if empty add the first line
errors.append("Error reading the following images:")
errors.append(' %s' % imgFn)
return errors
def test_convertMicrographs(self):
""" Convert micrograhs to different formats.
EMAN2 required for .img
"""
micFn = self.dataset.getFile('micrographs/BPV_1386.mrc')
outSuffix = pwutils.replaceBaseExt(micFn, 'img')
ih = ImageHandler()
outFn = join('/tmp', outSuffix)
print "Converting: \n%s -> %s" % (micFn, outFn)
ih.convert(micFn, outFn)
self.assertTrue(os.path.exists(outFn))
self.assertTrue(pwutils.getFileSize(outFn) > 0)
pwutils.cleanPath(outFn)
pwutils.cleanPath(outFn.replace('.img', '.hed'))
def test_coordinate1(self):
"""
Download a micrograph and a set of coordinates in the EMX interchange standard.
Convert both files to your package format.
Extract the particles from the micrograph with a box size of 128 pixels. (Remember that coordinates refer to particle centers.)
Upload the extracted images to the web as a 2D CCP4 stack (standard exchange format).
Three galleries of images will be displayed: the gold standard, the one just uploaded and the differences between them. The test has been sucessful if the gold standard and the images updated are identical.
As extra check, the Web Site will make a pixel by pixel comparison between images belonging to both galleries. A green tick will appear if both images are identical and a red cross if any pair of pixels differ more than 10**-2.
"""
#download data
self.url = "Coordinates/Test1/"
micFn = self.downloadFile("micrograph.mrc")
emxFn = self.downloadFile("coordinates.emx")
particle_even = self.downloadFile("particle_even.mrcs")
protEmxImport = self.newProtocol(
ProtImportParticles,
objLabel='from emx (coordinatesTest1)',
importFrom=ProtImportParticles.IMPORT_FROM_EMX,
emxFile=emxFn,
alignType=3,
voltage=100,
magnification=10000,
samplingRate=2.0)
self.launchProtocol(protEmxImport)
outputMics = getattr(protEmxImport, 'outputMicrographs', None)
outputCoords = getattr(protEmxImport, 'outputCoordinates', None)
self.assertIsNotNone(outputMics)
self.assertIsNotNone(outputCoords)
coordsGolds = [(539, 414), (509, 192), (711, 158), (634, 349),
(403, 157), (347, 437), (728, 389)]
for coord, coordGold in izip(outputCoords, coordsGolds):
self.assertEquals(coord.getPosition(), coordGold)
protExtract = self.newProtocol(XmippProtExtractParticles,
boxSize=128,
downsampleType=0,
doRemoveDust=False,
doNormalize=False,
doFlip=False,
downFactor=1)
protExtract.inputCoordinates.set(protEmxImport.outputCoordinates)
protExtract.inputMicrographs.set(protEmxImport.outputMicrographs)
self.launchProtocol(protExtract)
#export as emx
protEmxExport = self.newProtocol(ProtEmxExport)
protEmxExport.inputSet.set(protExtract.outputParticles)
self.launchProtocol(protEmxExport)
stackFn = os.path.join(protEmxExport._getPath('emxData'), "data.mrc")
self.assertTrue(ImageHandler().compareData(particle_even,
stackFn,
tolerance=0.01))
def _processMovie(self, movie):
allFramesSum = self._getPath('all_frames_sum.mrc')
ih = ImageHandler()
sumImg = ih.createImage()
img = ih.createImage()
n = movie.getNumberOfFrames()
fn = movie.getFileName()
sumImg.read((1, fn))
for frame in range(2, n + 1):
img.read((frame, fn))
sumImg.inplaceAdd(img)
if os.path.exists(allFramesSum):
img.read(allFramesSum)
sumImg.inplaceAdd(img)
sumImg.write(allFramesSum)
def test_coordinate2(self):
"""
as test_coordinate1 but with a 129 box
"""
#download data
self.url = "Coordinates/Test2/"
micFn = self.downloadFile("micrograph.mrc")
emxFn = self.downloadFile("coordinates.emx")
particle_odd = self.downloadFile("particle_odd.mrcs")
protEmxImport = self.newProtocol(
ProtImportParticles,
objLabel='from emx (coordinatesTest2)',
importFrom=ProtImportParticles.IMPORT_FROM_EMX,
emxFile=emxFn,
alignType=3,
voltage=100,
magnification=10000,
samplingRate=2.0)
self.launchProtocol(protEmxImport)
outputMics = getattr(protEmxImport, 'outputMicrographs', None)
outputCoords = getattr(protEmxImport, 'outputCoordinates', None)
self.assertIsNotNone(outputMics)
self.assertIsNotNone(outputCoords)
coordsGolds = [(539, 414), (509, 192), (711, 158), (634, 349),
(403, 157), (347, 437), (728, 389)]
for coord, coordGold in izip(outputCoords, coordsGolds):
self.assertEquals(coord.getPosition(), coordGold)
protExtract = self.newProtocol(XmippProtExtractParticles,
boxSize=129,
downsampleType=0,
doRemoveDust=False,
doNormalize=False,
doInvert=False,
doFlip=False,
doSort=False)
protExtract.inputCoordinates.set(protEmxImport.outputCoordinates)
protExtract.inputMicrographs.set(protEmxImport.outputMicrographs)
self.launchProtocol(protExtract)
#export as emx
protEmxExport = self.newProtocol(ProtEmxExport)
protEmxExport.inputSet.set(protExtract.outputParticles)
self.launchProtocol(protEmxExport)
stackFn = os.path.join(protEmxExport._getPath('emxData'), "data.mrc")
# this assert does not work is a compare the stack as a block
for num in range(1, 8):
self.assertTrue(ImageHandler().compareData("%d@" % num +
particle_odd,
"%d@" % num + stackFn,
tolerance=0.01))
def test_orientation1(self):
"""
This test requires:
Download a stack of 2D images (particles) and a set of transformation matrices in the EMX interchange standard.
Convert both files to your package format.
Apply the transformation matrix to the stack of images.
Compute an average image of the whole stack
Upload the average image as a 2D CCP4 image (standard exchange format).
Two images will be displayed: the gold standard and the one just uploaded. The test has been successful if the gold standard and the image updated are identical.
Note: test data created using a subunit of GroEL (PDB id 1SS8)
"""
#download data
self.url = "Orientation/Test1/"
imgFn = self.downloadFile("images.mrc")
emxFn = self.downloadFile("images.emx")
average = self.downloadFile("average.mrc")
protEmxImport = self.newProtocol(
ProtImportParticles,
objLabel='from emx (orientation1)',
importFrom=ProtImportParticles.IMPORT_FROM_EMX,
emxFile=emxFn,
alignType=0, #2D align
voltage=100,
magnification=10000,
samplingRate=2.46)
self.launchProtocol(protEmxImport)
outputParticles = getattr(protEmxImport, 'outputParticles', None)
#apply alignment
protApply = self.newProtocol(XmippProtApplyAlignment)
protApply.inputParticles.set(protEmxImport.outputParticles)
self.launchProtocol(protApply)
# We check that protocol generates output
self.assertIsNotNone(
protApply.outputParticles,
"There was a problem generating output particles")
# Check that output particles do not have alignment information
self.assertFalse(
protApply.outputParticles.hasAlignment(),
"Output particles should not have alignment information")
average = getattr(protApply, 'outputAverage', None)
outputParticles = getattr(protApply, 'outputParticles', None)
#export as emx
protEmxExport = self.newProtocol(ProtEmxExport)
protEmxExport.inputSet.set(outputParticles)
self.launchProtocol(protEmxExport)
#TODO: upload result to emx web site. Now it is down
stackFn = os.path.join(protEmxExport._getPath('emxData'), "data.mrc")
firstImg = outputParticles.getFirstItem()
self.assertTrue(ImageHandler().compareData(firstImg.getFileName(),
stackFn,
tolerance=0.01))
class BsoftFilterDialog(DownsampleDialog):
def _beforePreview(self):
ImagePreviewDialog._beforePreview(self)
self.lastObj = None
self.rightPreviewLabel = "Filtered particle"
self.message = "Filtering particle..."
self.previewLabel = "Particle"
self.rightImage = ImageHandler()._img
def _createControls(self, frame):
pass #FIXME
# self.freqFrame = ttk.LabelFrame(frame, text="Frequencies", padding="5 5 5 5")
# self.freqFrame.grid(row=0, column=0)
# if self.protocolParent.filterType <= FILTER_SPACE_REAL:
# self.radiusSlider = self.addFreqSlider('Radius', self.protocolParent.filterRadius.get(), col=0)
# else:
# self.lfSlider = self.addFreqSlider('Low freq', self.protocolParent.lowFreq.get(), col=0)
# self.hfSlider = self.addFreqSlider('High freq', self.protocolParent.highFreq.get(), col=1)
# if self.protocolParent.filterType == FILTER_FERMI:
# self.tempSlider = self.addFreqSlider('Temperature', self.protocolParent.temperature.get(), col=2)
# radiusButton = tk.Button(self.freqFrame, text='Preview', command=self._doPreview)
# radiusButton.grid(row=0, column=3, padx=5, pady=5)
def _doPreview(self, e=None):
if self.lastObj is None:
dialog.showError("Empty selection", "Select an item first before preview", self)
else:
self._computeRightPreview()
def updateFilteredImage(self):
self.rightPreview.updateData(self.rightImage.getData())
def _computeRightPreview(self):
""" This function should compute the right preview
using the self.lastObj that was selected
"""
from pyworkflow.em.packages.xmipp3 import locationToXmipp
# Copy image to filter to Tmp project folder
inputPath = os.path.join("Tmp", "bsoft_filter_input.spi")
outputPath = os.path.join("Tmp", "bsoft_filter_output.spi")
cleanPath(inputPath, outputPath)
ih = ImageHandler()
ih.convert(self.lastObj.getLocation(), inputPath)
self.protocolParent.runFilter(inputPath, outputPath)
# Get output image and update filtered image
img = ih._img
img.read(outputPath)
self.rightImage = img
self.updateFilteredImage()
def importMicrographs(self, pattern, suffix, voltage, sphericalAberration,
amplitudeContrast):
""" Copy images matching the filename pattern
Register other parameters.
"""
filePaths = glob(expandPattern(pattern))
#imgSet = SetOfMicrographs(filename=self.micsPairsSqlite, prefix=suffix)
imgSet = self._createSetOfMicrographs(suffix=suffix)
acquisition = imgSet.getAcquisition()
# Setting Acquisition properties
acquisition.setVoltage(voltage)
acquisition.setSphericalAberration(sphericalAberration)
acquisition.setAmplitudeContrast(amplitudeContrast)
# Call a function that should be implemented by each subclass
self._setOtherPars(imgSet)
outFiles = [imgSet.getFileName()]
imgh = ImageHandler()
img = imgSet.ITEM_TYPE()
n = 1
size = len(filePaths)
filePaths.sort()
for i, fn in enumerate(filePaths):
# ext = os.path.splitext(basename(f))[1]
dst = self._getExtraPath(basename(fn))
if self.copyToProj:
copyFile(fn, dst)
else:
createLink(fn, dst)
if n > 1:
for index in range(1, n + 1):
img.cleanObjId()
img.setFileName(dst)
img.setIndex(index)
imgSet.append(img)
else:
img.cleanObjId()
img.setFileName(dst)
imgSet.append(img)
outFiles.append(dst)
sys.stdout.write("\rImported %d/%d" % (i + 1, size))
sys.stdout.flush()
print "\n"
imgSet.write()
return imgSet
def _itemSelected(self, obj):
index = obj.getIndex()
filename = obj.getFileName()
if index:
filename = "%03d@%s" % (index, filename)
# self.image = xmipp.Image()
self.image = ImageHandler()._img
try:
self.image.readPreview(filename, self.dim)
if filename.endswith('.psd'):
self.image.convertPSD()
self.Z = self.image.getData()
except Exception, e:
from pyworkflow.gui.matplotlib_image import getPngData
self.Z = getPngData(findResource('no-image.png'))
dialog.showError("Input particles",
"Error reading image <%s>" % filename, self)
def convertInputStep(self, micsId, refsId, runType):
# runType is passed as parameter to force a re-execute of this step
# if there is a change in the type
self._ih = ImageHandler() # used to convert micrographs
# Match ctf information against the micrographs
self.ctfDict = {}
if self.ctfRelations.get() is not None:
for ctf in self.ctfRelations.get():
self.ctfDict[ctf.getMicrograph().getMicName()] = ctf.clone()
micStar = self._getPath('input_micrographs.star')
writeSetOfMicrographs(self.getMicrographList(),
micStar,
alignType=ALIGN_NONE,
preprocessImageRow=self._preprocessMicrographRow)
if self.useInputReferences():
writeReferences(self.getInputReferences(),
self._getPath('input_references'),
useBasename=True)
def _computeRightPreview(self):
""" This function should compute the right preview
using the self.lastObj that was selected
"""
from pyworkflow.em.packages.xmipp3 import locationToXmipp
# Copy image to filter to Tmp project folder
inputPath = os.path.join("Tmp", "bsoft_filter_input.spi")
outputPath = os.path.join("Tmp", "bsoft_filter_output.spi")
cleanPath(inputPath, outputPath)
ih = ImageHandler()
ih.convert(self.lastObj.getLocation(), inputPath)
self.protocolParent.runFilter(inputPath, outputPath)
# Get output image and update filtered image
img = ih._img
img.read(outputPath)
self.rightImage = img
self.updateFilteredImage()
def prepareReferences(self, fnDir, TsCurrent, targetResolution):
print "Preparing references to sampling rate=", TsCurrent
fnMask = ''
newXdim = self.readInfoField(fnDir, "size", xmipp.MDL_XSIZE)
if self.nextMask.hasValue():
fnMask = join(fnDir, "mask.vol")
self.prepareMask(self.nextMask.get(), fnMask, TsCurrent, newXdim)
fnReferenceVol = join(fnDir, "volumeRef.vol")
img = ImageHandler()
img.convert(self.inputVolume.get(), fnReferenceVol)
Xdim = self.inputVolume.get().getDim()[0]
if Xdim != newXdim:
self.runJob("xmipp_image_resize",
"-i %s --fourier %d" % (fnReferenceVol, newXdim),
numberOfMpi=1)
if fnMask != '':
self.runJob('xmipp_image_operate',
'-i %s --mult %s' % (fnReferenceVol, fnMask),
numberOfMpi=1)
def _runBeforePreWhitening(self):
prot = self.form.protocol
# Convert input volumes
ih = ImageHandler()
if prot.useSplitVolume:
ih.convert(prot.volumeHalf1.get(),
join(self.workingDir, 'volume1.map'))
ih.convert(prot.volumeHalf2.get(),
join(self.workingDir, 'volume2.map'))
else:
ih.convert(prot.inputVolume.get(),
join(self.workingDir, 'volume1.map'))
self.results = prot.runResmap(self.workingDir, wizardMode=True)
def test_readDM4(self):
""" Check we can read dm4 files (using EMAN)
"""
micFn = self.dsFormat.getFile('SuperRef_c3-adp-se-xyz-0228_001.dm4')
ih = ImageHandler()
# Check that we can read the dimensions of the dm4 file:
EXPECTED_SIZE = (7676, 7420, 1, 1)
self.assertEqual(ih.getDimensions(micFn), EXPECTED_SIZE)
# We could even convert to an mrc file:
outSuffix = pwutils.replaceBaseExt(micFn, 'mrc')
outFn = join('/tmp', outSuffix)
print "Converting: \n%s -> %s" % (micFn, outFn)
ih.convert(micFn, outFn)
self.assertTrue(os.path.exists(outFn))
self.assertTrue(pwutils.getFileSize(outFn) > 0)
# Check dimensions are still the same:
self.assertEqual(ih.getDimensions(outFn), EXPECTED_SIZE)
# Clean up tmp files
pwutils.cleanPath(outFn)
def _pickMicrograph(self, mic, radius):
micFn = mic.getFileName()
micDir = self._getMicDir(micFn)
fnMicBase = pwutils.replaceBaseExt(micFn, 'mrc')
fnMicCfg = pwutils.replaceBaseExt(micFn, 'cfg')
fnMicFull = os.path.join(micDir, fnMicBase)
fnPosBase = self._getMicPosFn(micFn)
# Convert micrographs to mrc (uint8) as required by ETHAN program
ih = ImageHandler()
ih.convert(micFn, fnMicFull, md.DT_UCHAR)
# Create a configuration file to be used by ETHAN with the parameters
# selected by the user
self.writeConfigFile(os.path.join(micDir, fnMicCfg))
# Run ethan program with the required arguments
program = self.getProgram()
args = "%s %s %s %s" % (radius, fnMicBase, fnPosBase, fnMicCfg)
self.runJob(program, args, cwd=micDir)
# Clean temporary micrograph
pwutils.cleanPath(fnMicFull)
def generateSplittedVolumes(self):
inputParticles = self.directionalClasses.get()
Xdim = inputParticles.getDimensions()[0]
fnMask = ""
if self.mask.hasValue():
fnMask = self._getExtraPath("mask.vol")
img = ImageHandler()
img.convert(self.mask.get(), fnMask)
self.runJob('xmipp_image_resize',
"-i %s --dim %d" % (fnMask, Xdim),
numberOfMpi=1)
self.runJob('xmipp_transform_threshold',
"-i %s --select below 0.5 --substitute binarize" %
fnMask,
numberOfMpi=1)
args="-i %s --oroot %s --Nrec %d --Nsamples %d --sym %s --alpha %f"%\
(self._getExtraPath("directionalClasses.xmd"),self._getExtraPath("split"),self.Nrec.get(),self.Nsamples.get(),
self.symmetryGroup.get(), self.alpha.get())
if fnMask != "":
args += " --mask binary_file %s" % fnMask
self.runJob("xmipp_classify_first_split", args)
def _validate(self):
from pyworkflow.em.convert import ImageHandler
ci = self.getImportClass()
if ci is None:
errors = ProtImportMicBase._validate(self)
for micFn, _ in self.iterFiles():
imgh = ImageHandler()
if imgh.isImageFile(micFn):
_, _, z, n = imgh.getDimensions(micFn)
if n > 1 or z > 1:
errors.append(
"The protocol not support micrographs stored in stacks. "
"If you want to obtain your micrographs individually, "
"you can run the following command:\n"
"scipion run scipion_directory/scripts/split_stacks.py --files *your files* --ext *extension*"
)
# JMRT: only check the first image, for large dataset
# even reading the header can take a while
break
return errors
else:
return ci.validateMicrographs()
def test_convert(self):
""" Run an Import particles protocol. """
protImport = self.newProtocol(ProtImportParticles, filesPath=self.particlesFn, samplingRate=3.5)
self.launchProtocol(protImport)
# check that input images have been imported (a better way to do this?)
if getattr(protImport, 'outputParticles', None) is None:
raise Exception('Import of images: %s, failed. outputParticles is None.' % self.particlesFn)
ih = ImageHandler()
stackFn = self.getOutputPath('stack.stk')
selFn = self.getOutputPath('stack_sel.stk')
print "stackFn: ", stackFn
writeSetOfImages(protImport.outputParticles, stackFn, selFn)
def createParticlesStep(self):
self.name = "particle"
time.sleep(self.creationInterval.get())
for idx, p in enumerate(self.inputParticles.get()):
if ((idx > self.counter - 1) and (idx < self.nDims)
and (idx <= self.counter - 1 + self.group)):
newP = p.clone()
ProtCreateStreamData.object = \
ImageHandler().read(newP.getLocation())
destFn = self._getExtraPath("%s_%05d" % (self.name, idx))
ProtCreateStreamData.object.write(destFn)
self.dictObj[destFn] = True
self._checkProcessedData()
def convertInputStep(self, micsId, refsId):
self._ih = ImageHandler() # used to convert micrographs
# Match ctf information against the micrographs
self.ctfDict = {}
if self.ctfRelations.get() is not None:
for ctf in self.ctfRelations.get():
self.ctfDict[ctf.getMicrograph().getMicName()] = ctf.clone()
micStar = self._getPath('input_micrographs.star')
writeSetOfMicrographs(self.getInputMicrographs(), micStar,
preprocessImageRow=self._preprocessMicrographRow,
postprocessImageRow=self._postprocessMicrographRow)
writeReferences(self.getInputReferences(), self._getPath('input_references'))
class ImagePreviewDialog(PreviewDialog):
def _beforePreview(self):
self.dim = 256
self.previewLabel = ''
def _createPreview(self, frame):
""" Should be implemented by subclasses to
create the items preview.
"""
from pyworkflow.gui.matplotlib_image import ImagePreview
self.preview = ImagePreview(frame, self.dim, label=self.previewLabel)
self.preview.grid(row=0, column=0)
def _itemSelected(self, obj):
index = obj.getIndex()
filename = ImageHandler.fixXmippVolumeFileName(obj)
if index:
filename = "%03d@%s" % (index, filename)
# self.image = xmipp.Image()
self.image = ImageHandler()._img
try:
self.image.readPreview(filename, self.dim)
if filename.endswith('.psd'):
self.image.convertPSD()
self.Z = self.image.getData()
except Exception, e:
from pyworkflow.gui.matplotlib_image import getPngData
self.Z = getPngData(findResource('no-image.png'))
dialog.showError("Input particles", "Error reading image <%s>"
% filename, self)
self.preview.updateData(self.Z)
def importMaskStep(self, path, samplingRate):
""" Copy mask from maskPath.
"""
self.info("Using mask path: '%s'" % path)
# Copy the image file into the project
dst = self._getExtraPath(basename(path))
pwutils.copyFile(path, dst)
# Retrive image dimensions
imgh = ImageHandler()
_, _, z, n = imgh.getDimensions(dst)
# Create a 2D or 3D Mask, consider the case of n>1
# as the case of some volume maps in mrc format
if z > 1 or n > 1:
mask = VolumeMask()
else:
mask = Mask()
mask.setFileName(dst)
mask.setSamplingRate(samplingRate)
self._defineOutputs(outputMask=mask)
def buildDendrogram(self, writeAverages=False):
""" Parse Spider docfile with the information to build the dendrogram.
Params:
writeAverages: whether to write class averages or not.
"""
dendroFile = self._getFileName('dendroDoc')
# Dendrofile is a docfile with at least 3 data colums (class, height, id)
doc = SpiderDocFile(dendroFile)
values = []
indexes = []
for _, h, i in doc.iterValues():
indexes.append(i)
values.append(h)
doc.close()
self.dendroValues = values
self.dendroIndexes = indexes
self.dendroImages = self._getFileName('particles')
self.dendroAverages = self._getFileName('averages')
self.dendroAverageCount = 0 # Write only the number of needed averages
self.dendroMaxLevel = 10 # FIXME: remove hard coding if working the levels
self.ih = ImageHandler()
return self._buildDendrogram(0, len(values)-1, 1, writeAverages)
def _pickMicrograph(self, mic, args):
# Prepare mic folder and convert if needed
micName = mic.getFileName()
micDir = self._getTmpPath(pwutils.removeBaseExt(micName))
pwutils.makePath(micDir)
ih = ImageHandler()
# If needed convert micrograph to mrc format, otherwise link it
if pwutils.getExt(micName) != ".mrc":
fnMicBase = pwutils.replaceBaseExt(micName, 'mrc')
inputMic = os.path.join(micDir, fnMicBase)
ih.convert(mic.getLocation(), inputMic)
else:
inputMic = os.path.join(micDir, os.path.basename(micName))
pwutils.createLink(micName, inputMic)
# Program to execute and it arguments
program = "ApDogPicker.py"
outputFile = self._getExtraPath(pwutils.replaceBaseExt(
inputMic, "txt"))
args += " --image=%s --outfile=%s" % (inputMic, outputFile)
self.runJob(program, args)
def convertInputStep(self, particlesId, volId):
""" Write the input images as a Xmipp metadata file.
particlesId: is only need to detect changes in
input particles and cause restart from here.
"""
inputParticles = self.inputParticles.get()
inputVolume = self.inputVolume.get()
writeSetOfParticles(inputParticles, self._getExpParticlesFn())
img = ImageHandler()
img.convert(inputVolume, self._getInputVolFn())
Xdim = inputParticles.getXDim()
Ts = inputParticles.getSamplingRate()
if self._useSeveralClasses():
# Scale particles
newTs = self.targetResolution.get() * 0.4
newTs = max(Ts, newTs)
newXdim = long(Xdim * Ts / newTs)
self.runJob("xmipp_image_resize",
"-i %s -o %s --save_metadata_stack %s --fourier %d" %
(self._getExpParticlesFn(),
self._getTmpPath('scaled_particles.stk'),
self._getTmpPath('scaled_particles.xmd'),
newXdim))
# Scale volume
Xdim = inputVolume.getXDim()
if Xdim != newXdim:
self.runJob("xmipp_image_resize", "-i %s --dim %d"
% (self._getInputVolFn(), newXdim), numberOfMpi=1)
Xdim=newXdim
Ts=newTs
self.writeInfoField(self._getExtraPath(),"sampling",xmippLib.MDL_SAMPLINGRATE,Ts)
self.writeInfoField(self._getExtraPath(),"size",xmippLib.MDL_XSIZE,long(Xdim))
def convertInputStep(self, volLocation1, volLocation2=None):
""" Convert input volume to .mrc as expected by ResMap.
Params:
volLocation1: a tuple containing index and filename of the input volume.
volLocation2: if not None, a tuple like volLocation1 for the split volume.
"""
ih = ImageHandler()
ih.convert(volLocation1, self._getPath('volume1.map'))
if volLocation2 is not None:
ih.convert(volLocation2, self._getPath('volume2.map'))
def _beforePreWhitening(protocol, workingDir):
from pyworkflow.em.convert import ImageHandler
# Convert input volumes
ih = ImageHandler()
projPath = protocol.getProject().getPath()
def convertVol(inputVol, outputFn):
index, path = inputVol.get().getLocation()
ih.convert((index, join(projPath, path)), join(workingDir, outputFn))
if protocol.useSplitVolume:
convertVol(protocol.volumeHalf1, 'volume1.map')
convertVol(protocol.volumeHalf2, 'volume2.map')
else:
convertVol(protocol.inputVolume, 'volume1.map')
return protocol.runResmap(workingDir, wizardMode=True)
def _beforePreWhitening(protocol, dir):
from pyworkflow.em.convert import ImageHandler
# Convert input volumes
ih = ImageHandler()
inputVolume = protocol.inputVolume.get()
path = join(dir, 'volume1.map')
print path
ih.convert(inputVolume, path)
if protocol.useSplitVolume:
ih.convert(protocol.splitVolume.get(), join(dir, 'volume2.map'))
return protocol.runResmap(dir, wizardMode=True)
def writeSetOfImages(imgSet, stackFn, selFn):
""" This function will write a SetOfMicrographs as a Spider stack and selfile.
Params:
imgSet: the SetOfMicrograph instance.
stackFn: the filename where to write the stack.
selFn: the filename of the Spider selection file.
"""
ih = ImageHandler()
doc = SpiderDocFile(selFn, 'w+')
for i in range(imgSet.getSize()):
doc.writeValues(i + 1)
imgSet.writeStack(stackFn, applyTransform=True)
doc.close()
convertEndian(stackFn, imgSet.getSize())
def testExistLocation(self):
volFn = self.dataset.getFile('volumes/volume_1_iter_002.mrc')
ih = ImageHandler()
# Test the volume filename exists
self.assertTrue(ih.existsLocation(volFn))
# Test missing filename
self.assertFalse(ih.existsLocation(volFn.replace('.mrc', '_fake.mrc')))
# Test the :mrc is append when used as volume
newFn = ih.getVolFileName(volFn)
self.assertEqual(newFn, volFn + ":mrc")
# Test that the new filename still exists even with the :mrc suffix
self.assertTrue(ih.existsLocation(newFn))
def convertInputStep(self, inputParticlesId):
fnDir=self._getExtraPath()
writeSetOfParticles(self.inputParticles.get(),self.imgsFn)
# Choose the target sampling rate
TsOrig=self.inputParticles.get().getSamplingRate()
TsCurrent=max(TsOrig,self.targetResolution.get()/3)
Xdim=self.inputParticles.get().getDimensions()[0]
newXdim=long(round(Xdim*TsOrig/TsCurrent))
if newXdim<40:
newXdim=long(40)
TsCurrent=Xdim*(TsOrig/newXdim)
print "Preparing images to sampling rate=",TsCurrent
self.writeInfoField(fnDir,"size",xmippLib.MDL_XSIZE,newXdim)
self.writeInfoField(fnDir,"sampling",xmippLib.MDL_SAMPLINGRATE,TsCurrent)
# Prepare particles
fnNewParticles=join(fnDir,"images.stk")
if newXdim!=Xdim:
self.runJob("xmipp_image_resize","-i %s -o %s --fourier %d"%(self.imgsFn,fnNewParticles,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,"images.xmd")),
numberOfMpi=1)
R=self.particleRadius.get()
if R<=0:
R=self.inputParticles.get().getDimensions()[0]/2
R=min(round(R*TsOrig/TsCurrent*1.1),newXdim/2)
self.runJob("xmipp_transform_mask","-i %s --mask circular -%d"%(fnNewParticles,R),numberOfMpi=self.numberOfMpi.get()*self.numberOfThreads.get())
# Prepare mask
imgHandler=ImageHandler()
if self.nextMask.hasValue():
self.convertInputVolume(imgHandler, self.nextMask.get(), getImageLocation(self.nextMask.get()), join(fnDir,"mask.vol"), TsCurrent, newXdim)
# Prepare references
i=0
for vol in self.inputVolumes.get():
fnVol=join(fnDir,"volume%03d.vol"%i)
self.convertInputVolume(imgHandler, vol, getImageLocation(vol), fnVol, TsCurrent, newXdim)
self.runJob("xmipp_image_operate","-i %s --mult 0 -o %s"%(fnVol,join(fnDir,"volume%03d_speed.vol"%i)),numberOfMpi=1)
i+=1
xmippLib.MetaData().write("best@"+self._getExtraPath("swarm.xmd")) # Empty write to guarantee this block is the first one
xmippLib.MetaData().write("bestByVolume@"+self._getExtraPath("swarm.xmd"),xmippLib.MD_APPEND) # Empty write to guarantee this block is the second one
def _loadPath(self, path):
self._tableName = None
# If path is a tuple, we will convert to the filename format
# as expected by Showj
if isinstance(path, tuple):
self._path = ImageHandler.locationToXmipp(path)
# Check if there is a table name with @ in path
# in that case split table name and path
# table names can never starts with a number
# this is considering an image inside an stack
elif isinstance(path, basestring):
if '@' in path and path[0] not in '0123456789':
self._tableName, self._path = path.split('@')
else:
self._path = path
else:
raise Exception("Invalid input path, "
"should be 'string' or 'tuple'")
