def _showOneColorslice(self, param=None):
"""
It shows a single colored slice of the 3DFSC
"""
imageFile = self.protocol._getExtraPath(OUTPUT_3DFSC)
img = ImageHandler().read(imageFile)
imgData = img.getData()
xplotter = XmippPlotter(x=1,
y=1,
mainTitle="3DFSC Slices "
"along %s-axis." % self._getAxis())
sliceNumber = self.sliceNumber.get()
if sliceNumber < 0:
x, _, _, _ = ImageHandler().getDimensions(imageFile)
sliceNumber = int(x / 2)
else:
sliceNumber -= 1
# sliceNumber has no sense to start in zero
a = xplotter.createSubPlot("Slice %s" % (sliceNumber + 1), '', '')
matrix = self.getSliceImage(imgData, sliceNumber, self._getAxis())
plot = xplotter.plotMatrix(a,
matrix,
0,
1,
cmap=self.getColorMap(),
interpolation="nearest")
xplotter.getColorBar(plot)
return [plt.show(xplotter)]
def _showVolumesChimera(self):
tmpFileNameCMD = self.protocol._getExtraPath("chimera.cxc")
f = open(tmpFileNameCMD, "w")
dim = self.protocol.inputVolumes.get().getDim()[0]
sampling = self.protocol.inputVolumes.get().getSamplingRate()
tmpFileName = os.path.abspath(self.protocol._getExtraPath("axis.bild"))
Chimera.createCoordinateAxisFile(dim,
bildFileName=tmpFileName,
sampling=sampling)
f.write("open %s\n" % tmpFileName)
f.write("cofr 0,0,0\n") # set center of coordinates
_inputVol = self.protocol.inputVolumes.get()
_outputVol = self.protocol.outputVolume
inputVolFileName = os.path.abspath(ImageHandler.removeFileType(
_inputVol.getFileName()))
# input vol origin coordinates
x_input, y_input, z_input = _inputVol.getShiftsFromOrigin()
f.write("open %s\n" % inputVolFileName)
f.write("volume #2 style mesh level 0.001 voxelSize %f origin "
"%0.2f,%0.2f,%0.2f\n"
% (_inputVol.getSamplingRate(), x_input, y_input, z_input))
outputVolFileName = os.path.abspath(ImageHandler.removeFileType(
_outputVol.getFileName()))
# output vol origin coordinates
x_output, y_output, z_output = _outputVol.getShiftsFromOrigin()
f.write("open %s\n" % outputVolFileName)
f.write("volume #3 style surface level 0.001 voxelSize %f origin "
"%0.2f,%0.2f,%0.2f\n"
% (_outputVol.getSamplingRate(), x_output, y_output, z_output))
cMap = ['red', 'yellow', 'green', 'cyan', 'blue']
d = {}
innerRadius = self.protocol.innerRadius.get()
d['outerRadius'] = self.protocol.outerRadius.get() * sampling
if innerRadius < 0:
innerRadius = 0
d['innerRadius'] = innerRadius * sampling
d['innerRadius'] = self.protocol.innerRadius.get() * sampling
d['symmetry'] = Chimera.getSymmetry(XMIPP_TO_SCIPION[self.protocol.symmetryGroup.get()])
if self.protocol.symmetryGroup >= XMIPP_I222:
f.write("shape icosahedron mesh true radius %(outerRadius)d "
"orientation %(symmetry)s\n" % d)
step = (d['outerRadius'] - d['innerRadius']) / float(len(cMap) - 1)
f.write("color radial #3 center 0,0,0 palette -")
counter = 0
s = ""
for color in cMap:
s += "%d,%s:" % (d['innerRadius'] + counter * step, color)
counter += 1
f.write(s[:-1] + '\n')
f.close()
return [ChimeraView(tmpFileNameCMD)]
def writeTiStack(inputTiList, outputStackFn, outputTltFn=None,
excludeList=None):
""" Write a given list of tilt images as a single stack
Params:
inputTiList: input list of tilted images.
outputStackFn: output path where to write the stack.
orderBy: column to sort by, by default tilt angle (ascending)
excludeList: a list of indexes of the images to skip (starting at 1)
Results:
A new stack file will be created and also a tlt file with tilt-angles
"""
excludeList = excludeList or []
ih = ImageHandler()
j = 0
f = open(outputTltFn, 'w') if outputStackFn else None
for i, ti in enumerate(inputTiList):
if i + 1 not in excludeList:
j += 1
ih.convert(ti, (j, outputStackFn))
if f:
f.write('%f\n' % ti.getTiltAngle())
if f:
f.close()
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)
# Prepare environment
from appion import Plugin
Plugin.getEnviron()
# Program to execute and it arguments
program = "python2"
outputFile = self._getExtraPath(pwutils.replaceBaseExt(
inputMic, "txt"))
args += " --image=%s --outfile=%s" % (inputMic, outputFile)
dogpicker = Plugin.getHome("ApDogPicker.py")
args = dogpicker + " " + args
self.runJob(program, args)
def importTomogramsStep(self, pattern, samplingRate):
""" Copy images matching the filename pattern
Register other parameters.
"""
self.info("Using pattern: '%s'" % pattern)
# Create a Volume template object
tomo = Tomogram()
tomo.setSamplingRate(samplingRate)
imgh = ImageHandler()
tomoSet = self._createSetOfTomograms()
tomoSet.setSamplingRate(samplingRate)
self._parseAcquisitionData()
for fileName, fileId in self.iterFiles():
x, y, z, n = imgh.getDimensions(fileName)
if fileName.endswith('.mrc') or fileName.endswith('.map'):
fileName += ':mrc'
if z == 1 and n != 1:
zDim = n
n = 1
else:
zDim = z
else:
zDim = z
origin = Transform()
if self.setOrigCoord.get():
origin.setShiftsTuple(self._getOrigCoord())
else:
origin.setShifts(x / -2. * samplingRate,
y / -2. * samplingRate,
zDim / -2. * samplingRate)
tomo.setOrigin(origin) # read origin from form
newFileName = _getUniqueFileName(self.getPattern(),
fileName.split(':')[0])
tsId = removeExt(newFileName)
tomo.setTsId(tsId)
if fileName.endswith(':mrc'):
fileName = fileName[:-4]
createAbsLink(fileName, abspath(self._getExtraPath(newFileName)))
tomo.setAcquisition(self._extractAcquisitionParameters(fileName))
if n == 1: # One volume per file
tomo.cleanObjId()
tomo.setFileName(self._getExtraPath(newFileName))
tomoSet.append(tomo)
else: # A stack of volumes per file (not common)
for index in range(1, n + 1):
tomo.cleanObjId()
tomo.setLocation(index, self._getExtraPath(newFileName))
tomoSet.append(tomo)
self._defineOutputs(outputTomograms=tomoSet)
def _show3DFSCcolorSlices(self, param=None):
"""
It opens 4 colores slices of the 3DFSC
"""
errors = []
if self.protocol.estimate3DFSC:
img = ImageHandler().read(
self.protocol._getExtraPath(OUTPUT_3DFSC))
imgData = img.getData()
xplotter = XmippPlotter(x=2,
y=2,
mainTitle="3DFSC Color Slices"
"along %s-axis." % self._getAxis())
# The slices to be shown are close to the center. Volume size is divided in
# 9 segments, the fouth central ones are selected i.e. 3,4,5,6
for i in range(3, 7):
sliceNumber = self.getSlice(i, imgData)
a = xplotter.createSubPlot("Slice %s" % (sliceNumber + 1), '',
'')
matrix = self.getSliceImage(imgData, sliceNumber,
self._getAxis())
plot = xplotter.plotMatrix(a,
matrix,
0,
1,
cmap=self.getColorMap(),
interpolation="nearest")
xplotter.getColorBar(plot)
return [xplotter]
else:
errors.append("The 3dFSC estimation of the 3dFSC was not selected"
"in the protocol form.")
return errors
def createOutputStep(self, tsObjId):
ts = self.inputSetOfTiltSeries.get()[tsObjId]
tsId = ts.getTsId()
extraPrefix = self._getExtraPath(tsId)
outputSetOfTomograms = self.getOutputSetOfTomograms()
newTomogram = Tomogram()
newTomogram.setLocation(os.path.join(extraPrefix, ts.getFirstItem().parseFileName(extension=".mrc")))
# Set tomogram origin
ih = ImageHandler()
xDim, yDim, zDim, _ = \
ih.getDimensions(os.path.join(extraPrefix, ts.getFirstItem().parseFileName(extension=".mrc")))
origin = Transform()
sr = self.inputSetOfTiltSeries.get().getSamplingRate()
origin.setShifts(xDim / -2. * sr,
yDim / -2. * sr,
zDim / -2 * sr)
newTomogram.setOrigin(origin)
# Set tomogram acquisition
acquisition = TomoAcquisition()
acquisition.setAngleMin(ts.getFirstItem().getTiltAngle())
acquisition.setAngleMax(ts[ts.getSize()].getTiltAngle())
acquisition.setStep(self.getAngleStepFromSeries(ts))
newTomogram.setAcquisition(acquisition)
outputSetOfTomograms.append(newTomogram)
outputSetOfTomograms.update(newTomogram)
outputSetOfTomograms.write()
self._store()
def getTomoSetFromStar(prot, starFile):
samplingRate = prot.pixelSize.get()
imgh = ImageHandler()
tomoTable = Table()
tomoTable.read(starFile)
tomoList = [row.get(TOMO_NAME, FILE_NOT_FOUND) for row in tomoTable]
prot.tomoList = List(tomoList)
tomoNamesUnique = list(set(tomoList))
# Create a Volume template object
tomo = Tomogram()
tomo.setSamplingRate(samplingRate)
for fileName in tomoNamesUnique:
x, y, z, n = imgh.getDimensions(fileName)
if fileName.endswith('.mrc') or fileName.endswith('.map'):
if z == 1 and n != 1:
zDim = n
n = 1
else:
zDim = z
else:
zDim = z
origin = Transform()
origin.setShifts(x / -2. * samplingRate,
y / -2. * samplingRate,
zDim / -2. * samplingRate)
tomo.setOrigin(origin) # read origin from form
for index in range(1, n + 1):
tomo.cleanObjId()
tomo.setLocation(index, fileName)
tomo.setAcquisition(TomoAcquisition(**prot.acquisitionParams))
prot.tomoSet.append(tomo)
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))
dst, cleaned = cleanFileName(dst)
pwutils.copyFile(path, dst)
# Retrieve 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(**{self._possibleOutputs.outputMask.name: mask})
def _prepareParams(self):
args = " --noguiSplit %(half1)s %(half2)s"
args += " --vxSize=%0.3f" % self.volumeHalf1.get().getSamplingRate()
args += " --pVal=%(pVal)f --maxRes=%(maxRes)f --minRes=%(minRes)f"
args += " --stepRes=%(stepRes)f"
if self.show2D:
args += " --vis2D"
if self.applyMask:
# convert mask to map/ccp4
ih = ImageHandler()
ih.convert(self.maskVolume.get().getLocation(),
self._getFileName('mask'))
args += " --maskVol=%s" % os.path.basename(
self._getFileName('mask'))
params = {
'half1': os.path.basename(self._getFileName('half1')),
'half2': os.path.basename(self._getFileName('half2')),
'pVal': self.pVal.get(),
'maxRes': self.maxRes.get(),
'minRes': self.minRes.get(),
'stepRes': self.stepRes.get()
}
if self.useGpu:
args += " --use_gpu=yes --set_gpu=%s" % self.gpuList.get()
args += ' --lib_krnl_gpu="%s"' % resmap.Plugin.getGpuLib()
if self.doBenchmarking:
args += ' --doBenchMarking'
return args % params
def applyAlignmentStep(self, tsObjId):
ts = self.inputSetOfTiltSeries.get()[tsObjId]
tsId = ts.getTsId()
extraPrefix = self._getExtraPath(tsId)
path.makePath(extraPrefix)
outputTsFileName = os.path.join(extraPrefix, "%s.mrc" % tsId)
ts.applyTransform(outputTsFileName)
outputInterpolatedSetOfTiltSeries = self.getOutputInterpolatedSetOfTiltSeries()
newTs = tomoObj.TiltSeries(tsId=tsId)
newTs.copyInfo(ts)
outputInterpolatedSetOfTiltSeries.append(newTs)
for index, tiltImage in enumerate(ts):
newTi = tomoObj.TiltImage()
newTi.copyInfo(tiltImage, copyId=True)
newTi.setLocation(index + 1, outputTsFileName)
newTs.append(newTi)
ih = ImageHandler()
x, y, z, _ = ih.getDimensions(newTs.getFirstItem().getFileName())
newTs.setDim((x, y, z))
newTs.write()
outputInterpolatedSetOfTiltSeries.update(newTs)
outputInterpolatedSetOfTiltSeries.updateDim()
outputInterpolatedSetOfTiltSeries.write()
self._store()
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
imgFn.endswith('eer') 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)
break # validate just first image
return errors
def convertStep(self, volFn, volDim, volSr, minDim, maxSr, nVoli):
Xdim = volDim
Ts = volSr
newTs = self.targetResolution.get() * 1.0 / 3.0
newTs = max(maxSr, newTs)
newXdim = Xdim * Ts / newTs
newRmax = self.Rmax.get() * Ts / newTs
self.newRmax = min(newRmax, self.Rmax.get())
fnOut = os.path.splitext(volFn)[0]
fnOut = self._getExtraPath(
os.path.basename(fnOut + self.OUTPUT_SUFFIX % nVoli))
ih = ImageHandler()
volFn = volFn if getExt(volFn) == '.vol' else volFn + ':mrc'
if Xdim != newXdim:
self.runJob("xmipp_image_resize",
"-i %s -o %s --dim %d" % (volFn, fnOut, newXdim))
else:
ih.convert(volFn, fnOut)
if newXdim > minDim:
self.runJob(
"xmipp_transform_window",
" -i %s -o %s --crop %d" % (fnOut, fnOut, (newXdim - minDim)))
def convertInputStep(self, inputParticles, inputVolume, targetResolution):
""" 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._getInputParticles()
convXmp.writeSetOfParticles(imgSet, self._getInputXmd())
newXdim =self._getNewDim()
ih = ImageHandler()
inputVol = self.inputVolume.get()
fn = ih.fixXmippVolumeFileName(inputVol)
img = ih.read(fn)
img.scale(newXdim, newXdim, newXdim)
img.write(self._getExtraPath("volume.vol"))
args = '-i %(parts)s -o %(scaledStk)s --save_metadata_stack '
args += '%(scaledXmd)s --dim %(xDim)d'
params = {"parts" : self._getInputXmd(),
"scaledStk": self._getExtraPath('scaled_particles.stk'),
"scaledXmd": self._getExtraPath('scaled_particles.xmd'),
"xDim": newXdim
}
self.runJob("xmipp_image_resize", args % params)
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=md.iterRows(inputMd, sortByLabel=md.MDL_ITEM_ID))
# 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)
def test_tomoProjectionOutputTiltSeriesDimension(self):
ih = ImageHandler()
outputDimensions = ih.getDimensions(
self.protTomoProjection.outputProjectedSetOfTiltSeries.
getFirstItem().getFirstItem().getFileName())
self.assertTrue(outputDimensions == (256, 256, 61, 1))
def maskVolume(self, volFn, maskFn, index, halfString):
ih = ImageHandler()
# Check if there is a mask if not then use a spherical mask
if maskFn is None:
# Compute sphere radius and make a spherical mask
maskFn = self._getFileName('mask', index + 1)
volSize = ih.getDimensions(volFn)[0]
radius = volSize / 2 - 1
emlib.createEmptyFile(maskFn, volSize, volSize, volSize)
program = "xmipp_transform_mask"
args = "-i %s --mask circular %d --create_mask %s " % (
maskFn, -1 * radius, maskFn)
self.runJob(program, args)
else:
putils.copyFile(maskFn, self._getFileName('mask', index + 1))
maskFn = self._getFileName('mask', index + 1)
# Read the volume if it is provided
if volFn.endswith(".mrc"):
volFn = volFn + ":mrc"
# Apply mask to the volume
volMasked = self._getFileName('volume', 'masked', index + 1,
halfString)
program = 'xmipp_image_operate'
args = '-i %s --mult %s -o %s' % (volFn, maskFn, volMasked)
self.runJob(program, args)
def _invertScaleVol(self, fn):
xdim = self._getInputParticles().getXDim()
outputFn = self._getOutputVolFn(fn)
ih = ImageHandler()
img = ih.read(fn)
img.scale(xdim, xdim, xdim)
img.write(outputFn)
def main():
# Get arguments.
args = get_parser().parse_args()
setObj = EMSet(filename=args.setFile)
firstItem = setObj.getFirstItem()
root = pwutils.findRootFrom(args.setFile, firstItem.getFileName())
print("ROOT: ", root)
if args.output_text:
with open(args.output, 'w') as f:
for movie in setObj:
f.write('%s\n' % movie.getFileName())
elif args.print:
for item in setObj:
print(item.getFileName())
elif args.copy:
for item in setObj:
fn = os.path.join(root, item.getFileName())
print('Copying %s to %s' % (fn, args.output))
pwutils.copyFile(fn, args.output)
elif args.check_dims:
from pwem.emlib.image import ImageHandler
ih = ImageHandler()
counter = {}
for item in setObj:
fn = os.path.join(root, item.getFileName())
dims = ih.getDimensions(fn)
counter[dims] = 1 if dims not in counter else counter[dims] + 1
print('%s: %s' % (os.path.basename(fn), dims))
pwutils.prettyDict(counter)
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 _convertVol(self, vol, index):
ih = ImageHandler()
fn = vol.getFileName()
if not fn.endswith('.mrc'):
newFn = self._getFileName('input_vol', volId=index)
ih.convert(fn, newFn)
return newFn
return fn
def getMinMax(self, imageFile):
img = ImageHandler().read(imageFile)
imgData = img.getData()
# Remove 0's
imgData = imgData[np.nonzero(imgData)]
min_res = round(np.amin(imgData) * 100) / 100
max_res = round(np.amax(imgData) * 100) / 100
return min_res, max_res
def _convertVolumes(self):
ih = ImageHandler()
makePath(self._getExtraPath('input'))
inputVols = self.inputVolumes.get()
for vol in inputVols:
map = ih.read(vol)
outputFn = self._getOutputFn(vol.getObjId())
map.write(outputFn)
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 getMinMax(self, imageFile):
img = ImageHandler().read(imageFile)
imgData = img.getData()
imgData = imgData[imgData != 0]
min_res = round(np.amin(imgData) * 100) / 100
max_res = round(np.amax(imgData) * 100) / 100
median_res = round(np.median(imgData) * 100) / 100
return min_res, max_res, median_res
def assignTransformationMatricesStep(self):
self.getOutputAssignedTransformSetOfTiltSeries()
inputSetOfTiltSeries = self.inputSetOfTiltSeries.get()
for ts in inputSetOfTiltSeries:
tsId = ts.getTsId()
tsFileName = ts.getFirstItem().parseFileName(extension='')
for tmFilePath, _ in self.iterFiles():
tmFileName = os.path.basename(os.path.splitext(tmFilePath)[0])
if tsFileName == tmFileName:
alignmentMatrix = utils.formatTransformationMatrix(
tmFilePath)
newTs = tomoObj.TiltSeries(tsId=tsId)
newTs.copyInfo(ts)
self.outputAssignedTransformSetOfTiltSeries.append(newTs)
for index, tiltImage in enumerate(ts):
newTi = tomoObj.TiltImage()
newTi.copyInfo(tiltImage, copyId=True)
newTi.setLocation(tiltImage.getLocation())
transform = data.Transform()
if tiltImage.hasTransform():
previousTransform = tiltImage.getTransform(
).getMatrix()
newTransform = alignmentMatrix[:, :, index]
previousTransformArray = np.array(
previousTransform)
newTransformArray = np.array(newTransform)
outputTransformMatrix = np.matmul(
previousTransformArray, newTransformArray)
transform.setMatrix(outputTransformMatrix)
newTi.setTransform(transform)
else:
transform.setMatrix(alignmentMatrix[:, :, index])
newTi.setTransform(transform)
newTs.append(newTi)
ih = ImageHandler()
x, y, z, _ = ih.getDimensions(
newTs.getFirstItem().getFileName())
newTs.setDim((x, y, z))
newTs.write(properties=False)
self.outputAssignedTransformSetOfTiltSeries.update(newTs)
self.outputAssignedTransformSetOfTiltSeries.updateDim()
self.outputAssignedTransformSetOfTiltSeries.write()
self._store()
def importSubTomogramsStep(self, pattern, samplingRate):
""" Copy images matching the filename pattern
Register other parameters.
"""
self.info("Using pattern: '%s'" % pattern)
# Create a Volume template object
subtomo = SubTomogram()
subtomo.setSamplingRate(samplingRate)
imgh = ImageHandler()
self.subtomoSet = self._createSetOfSubTomograms()
self.subtomoSet.setSamplingRate(samplingRate)
# if self.importCoordinates.get():
# self.coords = []
# for coord3D in self.importCoordinates.get().iterCoordinates():
# self.coords.append(coord3D.clone())
# self.subtomoSet.setCoordinates3D(self.importCoordinates)
self._parseAcquisitionData()
for fileName, fileId in self.iterFiles():
x, y, z, n = imgh.getDimensions(fileName)
if fileName.endswith('.map'):
fileName += ':mrc'
if fileName.endswith('.mrc') or fileName.endswith(':mrc'):
if z == 1 and n != 1:
zDim = n
n = 1
else:
zDim = z
else:
zDim = z
origin = Transform()
origin.setShifts(x / -2. * samplingRate, y / -2. * samplingRate,
zDim / -2. * samplingRate)
subtomo.setOrigin(origin) # read origin from form
newFileName = _getUniqueFileName(self.getPattern(), fileName)
# newFileName = abspath(self._getVolumeFileName(fileName))
if fileName.endswith(':mrc'):
fileName = fileName[:-4]
createAbsLink(fileName, self._getExtraPath(newFileName))
if n == 1:
self._addSubtomogram(subtomo, self._getExtraPath(fileName),
self._getExtraPath(newFileName))
else:
for index in range(1, n + 1):
self._addSubtomogram(subtomo,
self._getExtraPath(fileName),
self._getExtraPath(newFileName),
index=index)
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 convertInputStep(self, resetId):
""" Preprocess all volumes prior to clustering"""
inputCls = self.inputClasses.get()
ih = ImageHandler()
for i, class3D in enumerate(inputCls):
num = class3D.getObjId()
vol = class3D.getRepresentative()
newFn = self._getExtraPath('volume_id_%03d.mrc' % num)
ih.convert(vol, newFn)
def sharpeningAndMonoResStep(self):
last_Niters = -1
last_lambda_sharpening = 1e38
nextIter = True
while nextIter is True:
self.iteration = self.iteration + 1
# print("iteration")
print('\n====================\n'
'Iteration %s' % (self.iteration))
self.sharpenStep(self.iteration)
mtd = md.MetaData()
mtd.read(self._getFileName('METADATA_PARAMS_SHARPENING'))
lambda_sharpening = mtd.getValue(MDL_COST, 1)
Niters = mtd.getValue(MDL_ITER, 1)
# if (Niters == last_Niters):
# nextIter = False
# break
if (abs(lambda_sharpening - last_lambda_sharpening) <= 0.2):
nextIter = False
break
last_Niters = Niters
last_lambda_sharpening = lambda_sharpening
self.MonoResStep(self.iteration)
imageFile = self._getFileName('OUTPUT_RESOLUTION_FILE')
img = ImageHandler().read(imageFile)
imgData = img.getData()
max_res = np.amax(imgData)
min_res = 2 * self.inputVolume.get().getSamplingRate()
if (max_res - min_res < 0.75):
nextIter = False
break
os.rename(
self._getExtraPath('sharpenedMap_' + str(self.iteration) + '.mrc'),
self._getExtraPath('sharpenedMap_last.mrc'))
resFile = self.resolutionVolume.get().getFileName()
pathres = dirname(resFile)
if not exists(self._getFileName('OUTPUT_RESOLUTION_FILE')):
print(
'\n====================\n'
' WARNING---This is not the ideal case because resolution map has been imported.'
' The ideal case is to calculate it previously'
' in the same project using MonoRes.'
'\n====================\n')