def read_em(filename, binning=None):
"""Read the whole EM file: the header as well as the data.
@param filename: filename
@type filename: str
@param binning: binning factor in x, y, z (default: 1)
@type binning: 3-dim array
@return: [data, header]
"""
from pytom_volume import read
# read the header
header = read_em_header(filename)
# read the data
if binning:
v = read(filename, 0, 0, 0, 0, 0, 0, 0, 0, 0, binning[0], binning[1],
binning[2])
else:
v = read(filename)
if binning:
dim = header.get_dim()
header.set_dim(dim[0] / binning[0], dim[1] / binning[1],
dim[2] / binning[2])
# files are always casted as float irrespective of original datatype
# => ensure header is correct
header.set_1st4bytes(datatype=type(1.), machinetype=None)
return v, header
def retrieve_res_vols(self, name_prefix):
"""For master node, retrieve the even/odd sub-averages and do the cleaning.
@param name_prefix: name prefix output densities
@type name_prefix: C{str}
"""
from pytom_volume import read
even_pre = read(name_prefix + 'even' + '-PreWedge.em')
even_wedge = read(name_prefix + 'even' + '-WedgeSumUnscaled.em')
odd_pre = read(name_prefix + 'odd' + '-PreWedge.em')
odd_wedge = read(name_prefix + 'odd' + '-WedgeSumUnscaled.em')
# delete the volumes from disk
import os
try:
os.remove(name_prefix + 'even' + '-PreWedge.em')
os.remove(name_prefix + 'even' + '-WedgeSumUnscaled.em')
os.remove(name_prefix + 'odd' + '-PreWedge.em')
os.remove(name_prefix + 'odd' + '-WedgeSumUnscaled.em')
os.remove(name_prefix + 'even' + '.em')
os.remove(name_prefix + 'odd' + '.em')
except:
pass
return (even_pre, even_wedge, odd_pre, odd_wedge)
def readRotationsFromEMFile(self, filename, inputIsInRadians=True):
"""
readRotationsFromEMFile: Reads rotations from EM file and optionally converts them from radians to degrees
@param filename: Name of EM file
@param inputIsInRadians:
@type inputIsInRadians: bool
"""
self._angleList = []
if not filename == '':
import pytom_volume
from pytom.angles.angle import rad2deg
try:
angs = pytom_volume.read(filename)
except RuntimeError:
from pytom.tools.files import checkFileExists, getPytomPath
if not checkFileExists(filename):
filename = getPytomPath(
) + '/angles/angleLists/' + filename
angs = pytom_volume.read(filename)
for i in range(angs.sizeY()):
phi = angs.getV(0, i, 0)
psi = angs.getV(1, i, 0)
the = angs.getV(2, i, 0)
if inputIsInRadians:
phi = phi * rad2deg
psi = psi * rad2deg
the = the * rad2deg
self._angleList.append([phi, psi, the])
def readProxy(fileName,
subregion1=0,
subregion2=0,
subregion3=0,
subregion4=0,
subregion5=0,
subregion6=0,
sampling1=0,
sampling2=0,
sampling3=0,
binning1=0,
binning2=0,
binning3=0):
"""
readProxy: Proxy function to easily replace pytom_volume calls with read \
function below
"""
return read(fileName,
subregion=[
subregion1, subregion2, subregion3, subregion4, subregion5,
subregion6
],
sampling=[sampling1, sampling2, sampling3],
binning=[binning1, binning2, binning3])
def em2markerfile(filename, tiltangles):
vol = read(filename)
mf = copy.deepcopy(vol2npy(vol))
(d, angles, num) = mf.shape
# print mf.shape
locX, locY = 1, 2
mark_frames = -1 * numpy.ones((len(tiltangles), num, 2))
# print mf[0,:,1:3].shape,self.coordinates[:,0,:].shape
markers = []
for i in range(num):
for j in range(angles):
m = -1
for n, angle in enumerate(tiltangles):
if abs(mf[0, j, i] - angle) < 1:
m = n
break
if m == -1: continue
mark_frames[m, i, 0] = mf[locX, j, i]
mark_frames[m, i, 1] = mf[locY, j, i]
return mark_frames
def getVolume(self, subregion=[0,0,0,0,0,0], sampling=[0,0,0], binning=[0,0,0]):
"""
getVolume: Get the volume according to the given parameters.\
Note the subregion, sampling and binning parameters are not the same as \
those attributes in the class.
@param subregion: subregion [startX, startY, startZ, sizeX, sizeY, sizeZ]
@type subregion: list
@param sampling: sampling [factorX, factorY, factorZ]
@type sampling: list
@param binning: binning [factorX, factorY, factorZ]
@type binning: list
@rtype: L{pytom_volume.vol}
"""
from pytom_volume import read
from pytom.tools.files import checkFileExists
if not checkFileExists(self._filename):
raise Exception('File ' + self._filename + ' does not exist!')
return read(self._filename, subregion[0], subregion[1], subregion[2],
subregion[3], subregion[4], subregion[5],
sampling[0], sampling[1], sampling[2],
binning[0], binning[1], binning[2])
def em2mrc(filename, target):
from pytom_volume import read
from pytom.tools.files import checkFileExists, checkDirExists
import os
if not checkFileExists(filename):
raise RuntimeError('EM file not found! ', filename)
if not checkDirExists(target):
raise RuntimeError('Destination directory not found! ', target)
emfile = read(filename)
splitName = filename.split(os.sep)
filename = splitName[len(splitName) - 1]
ff = filename[0:len(filename) - 3]
try:
ff = ff.split('_')
print(ff[-1])
ff = [f'sorted_{int(ff[-1])-1:02d}']
print(ff)
except Exception as e:
print('\n\n\n')
print(e)
pass
ff = '_'.join(ff)
newFilename = target + os.sep + ff + '.mrc'
emfile.write(newFilename, 'mrc')
def frm_proxy(p, ref, freq, offset, binning, mask):
from pytom_volume import read, pasteCenter, vol
from pytom.basic.transformations import resize
from pytom.basic.structures import Shift, Rotation
from sh_alignment.frm import frm_align
import time
v = p.getVolume(binning)
if mask.__class__ == str:
maskBin = read(mask, 0, 0, 0, 0, 0, 0, 0, 0, 0, binning, binning,
binning)
if v.sizeX() != maskBin.sizeX() or v.sizeY() != maskBin.sizeY(
) or v.sizeZ() != maskBin.sizeZ():
mask = vol(v.sizeX(), v.sizeY(), v.sizeZ())
mask.setAll(0)
pasteCenter(maskBin, mask)
else:
mask = maskBin
pos, angle, score = frm_align(v, p.getWedge(), ref.getVolume(), None,
[4, 64], freq, offset, mask)
return (Shift([
pos[0] - v.sizeX() // 2, pos[1] - v.sizeY() // 2,
pos[2] - v.sizeZ() // 2
]), Rotation(angle), score, p.getFilename())
def _run(self):
"""
run: Starts growing average alignment
"""
from pytom.basic.structures import Reference
from pytom_volume import read
from pytom_fftplan import fftShift
#create reference object - as self.reference and weighting on disk
reference = self._particleList[self._startParticleNumber]
referenceFile = reference.getFilename()
refVolume = read(referenceFile);
#parse filename
pos1 = referenceFile.rfind('/')
pos2 = referenceFile.rfind('.em')
r = referenceFile[pos1+1:pos2]
#self._reference = Reference(referenceFile,r + '-StartWeight.em')
self._reference = Reference(referenceFile)
wedgeInfo = reference.getWedgeInfo()
wedgeVolume = wedgeInfo.returnWedgeVolume(refVolume.sizeX(),refVolume.sizeY(),refVolume.sizeZ(),False)
#wedgeVolume.setAll(1);
wedgeVolume.write(r + '-StartWeight.em')
self._startGrowingAverageLoop()
def distance(p, ref, freq, mask, binning):
from pytom.basic.correlation import nxcc
from pytom_volume import vol, initSphere, read, pasteCenter
from pytom.basic.filter import lowpassFilter
from pytom.basic.transformations import resize
v = p.getTransformedVolume(binning)
w = p.getWedge()
r = ref.getVolume()
a = lowpassFilter(w.apply(v, p.getRotation().invert()), freq)[0]
b = lowpassFilter(w.apply(r, p.getRotation().invert()), freq)[0]
if not mask:
mask = vol(r)
initSphere(mask,
r.sizeX() // 2 - 3, 3, 0,
r.sizeX() // 2,
r.sizeY() // 2,
r.sizeZ() // 2)
else:
#THE MASK is binning (sampled every n-points). This does lead to a reduction of the smoothing of the edges.
maskBin = read(mask, 0, 0, 0, 0, 0, 0, 0, 0, 0, binning, binning,
binning)
if a.sizeX() != maskBin.sizeX() or a.sizeY() != maskBin.sizeY(
) or a.sizeZ() != maskBin.sizeZ():
mask = vol(a.sizeX(), a.sizeY(), a.sizeZ())
mask.setAll(0)
pasteCenter(maskBin, mask)
else:
mask = maskBin
s = nxcc(a, b, mask)
d2 = 2 * (1 - s)
return d2
def calculate_difference_map_proxy(r1, band1, r2, band2, mask, focus_mask, binning, iteration, sigma, threshold, outdir='./'):
from pytom_volume import read, vol, pasteCenter
from pytom.basic.structures import Particle, Mask
import os
from pytom.basic.transformations import resize
v1 = r1.getVolume()
v2 = r2.getVolume()
if mask:
maskBin = read(mask, 0,0,0,0,0,0,0,0,0, binning, binning, binning)
if v1.sizeX() != maskBin.sizeX() or v1.sizeY() != maskBin.sizeY() or v1.sizeZ() != maskBin.sizeZ():
mask = vol(v1.sizeX(), v1.sizeY(), v1.sizeZ())
mask.setAll(0)
pasteCenter(maskBin, mask)
else:
mask = maskBin
else:
mask = None
if focus_mask:
focusBin = read(focus_mask, 0,0,0,0,0,0,0,0,0, binning, binning, binning)
if v1.sizeX() != focusBin.sizeX() or v1.sizeY() != focusBin.sizeY() or v1.sizeZ() != focusBin.sizeZ():
focus_mask = vol(v1.sizeX(), v1.sizeY(), v1.sizeZ())
focus_mask.setAll(0)
pasteCenter(focusBin, focus_mask)
else:
focus_mask = focusBin
else:
focus_mask = None
if not focus_mask is None and not mask is None:
if mask.sizeX() != focus_mask.sizeX():
raise Exception('Focussed mask and alignment mask do not have the same dimensions. This cannot be correct.')
(dmap1, dmap2) = calculate_difference_map(v1, band1, v2, band2, mask, focus_mask, True, sigma, threshold)
fname1 = os.path.join(outdir, 'iter'+str(iteration)+'_dmap_'+str(r1.getClass())+'_'+str(r2.getClass())+'.em')
dmap1.write(fname1)
fname2 = os.path.join(outdir, 'iter'+str(iteration)+'_dmap_'+str(r2.getClass())+'_'+str(r1.getClass())+'.em')
dmap2.write(fname2)
dp1 = Particle(fname1)
dp1.setClass(r1.getClass())
dp2 = Particle(fname2)
dp2.setClass(r2.getClass())
return (dp1, dp2)
def retrieve_res_vols(self, name_prefix):
"""For master node, retrieve the sub-averages and do the cleaning.
"""
from pytom_volume import read
pre = read(name_prefix + '-PreWedge.em')
wedge = read(name_prefix + '-WedgeSumUnscaled.em')
# delete the volumes from disk
import os
try:
os.remove(name_prefix + '-PreWedge.em')
os.remove(name_prefix + '-WedgeSumUnscaled.em')
os.remove(name_prefix + '.em')
except:
pass
return (pre, wedge)
def fromFile(self, filename=None):
from pytom_volume import read
from pytom.tools.files import checkFileExists
filename = filename or self._filename
if checkFileExists(filename):
self._weight = read(filename)
else:
raise RuntimeError('PeakPrior: File ' + filename + ' not found')
def getVolume(self):
"""
getVolume: Get volume of the found particle
@rtype: L{pytom_volume.vol}
"""
from pytom_volume import read
from pytom.tools.files import checkFileExists
if not checkFileExists(self._filename):
raise Exception('File ' + self._filename + ' does not exist!')
return read(self.filename)
def mean0std1_Test(self):
import pytom_volume
from pytom.basic.normalise import mean0std1
v = pytom_volume.read('./testData/ribo.em')
m = mean0std1(v, True)
me = pytom_volume.mean(m)
var = pytom_volume.variance(m, False)
assert epsilon >= me >= -epsilon #mean value test
assert 1 + epsilon >= var >= 1 - epsilon
def mrc2em(filename, target):
from pytom_volume import read
from pytom.tools.files import checkFileExists, checkDirExists
import os
if not checkFileExists(filename):
raise RuntimeError('MRC file not found! ', filename)
if not checkDirExists(target):
raise RuntimeError('Destination directory not found! ', target)
emfile = read(filename)
newFilename = name_to_format(filename, target, "em")
emfile.write(newFilename, 'em')
def readMarkerfile(filename, num_tilt_images=0):
if filename.endswith('.em'):
from pytom.basic.files import read
from pytom_numpy import vol2npy
markerfile = read(filename)
markerdata = vol2npy(markerfile).copy()
return markerdata
elif filename.endswith('.txt'):
data = loadstar(filename)
datalen = data.shape[0]
num_tilt_images = (data[:, 0] == data[0, 0]).sum()
x, y = datalen // num_tilt_images, num_tilt_images
markerdata = data.reshape(x, y, 4)[:, :, 1:].transpose(2, 1, 0)
return markerdata
def create_TiltSeries(data, tiltAngles, outputfolder='./'):
from pytom.tompy.io import read, write
from pytom.tompy.transform import rotate_axis
import os
if data.__class__ == str:
data = read(data)
if not os.path.exists(outputfolder): os.mkdir(outputfolder)
for n, tiltAngle in enumerate(tiltAngles):
outname = os.path.join(outputfolder, 'sorted_{:03d}.mrc'.format(n))
write(outname,
rotate_axis(data, tiltAngle, axis='y').sum(axis=2),
tilt_angle=tiltAngle)
def run(parameters, verbose=False):
"""
run: Generate an image slice from a density file
"""
from pytom.tools.files import checkFileExists
if verbose:
print("Parsing image slice!")
splitParameters = parameters.split('&')
if splitParameters.__class__ == list:
if verbose:
print(splitParameters)
for i in range(len(splitParameters)):
parameter = splitParameters[i]
split = parameter.split('=')
keyword = split[0]
argument = split[1]
if verbose:
print('Keyword : ', keyword)
print('Arguments : ', argument)
if keyword == 'File':
from pytom_volume import read
from pytom.tools.toImage import volumeToPNG
if not checkFileExists(argument):
raise IOError('File not found!')
v = read(argument)
if argument[len(argument) - 3:len(argument)] == '.em':
pngFilename = argument[0:len(argument) - 3] + '.png'
elif argument[len(argument) - 4:len(argument)] in ['.mrc']:
pngFilename = argument[0:len(argument) - 4] + '.png'
elif argument[len(argument) - 5:len(argument)] in ['.ccp4']:
pngFilename = argument[0:len(argument) - 5] + '.png'
volumeToPNG(v, pngFilename)
return pngFilename
def mrc2em(filename, destination):
if not os.path.exists(filename):
raise RuntimeError('MRC file not found! ', filename)
if not os.path.exists(destination):
raise RuntimeError('Destination directory not found! ', destination)
emfile = read(filename)
splitName = filename.split(os.sep)
filename = splitName[len(splitName) - 1]
newFilename = destination + os.sep + filename[0:len(filename) - 4] + '.em'
try:
emfile.write(newFilename, 'em')
except:
pass
def read(file,
subregion=[0, 0, 0, 0, 0, 0],
sampling=[0, 0, 0],
binning=[0, 0, 0]):
"""
read: Reads a file
@param file: Path to file. Supports EM, MRC and CCP4 files
@type file: str
@param subregion: Specifies a subregion to be read. The first three
values specify the upper left coordinates within the large volume,
the last three the length of the subregion along each dimension.
@type subregion: List of 6 integers
@param sampling: Change read sampling. Read every second (2),
third (3) pixel along each dimension.
@type sampling: List of 3 integers
@param binning: Bin volume along each dimension. Note, 1 will do nothing,
2 will bin with a kernelsize of 2 pixels along each dimension, 3 will bin
with a kernelsize of 3 pixels along each dimension and so forth.
@type binning: List of 3 integers
@return: A volume object. L{pytom_volume.vol}
@author: Thomas Hrabe
"""
from pytom.tools.files import checkFileExists
from pytom_volume import read
if not file.__class__ == str:
raise TypeError('File parameter must be a string!')
if not checkFileExists(file):
raise IOError('File not found or path is wrong: ' + file)
print(subregion)
try:
f = read(file, subregion[0], subregion[1], subregion[2], subregion[3],
subregion[4], subregion[5], sampling[0], sampling[1],
sampling[2], binning[0], binning[1], binning[2])
return f
except RuntimeError as e:
#redundant to code above, but just in case it goes through
if "Wrong file format or file doesn't exist!" in e.message:
raise IOError('File not found or path is wrong: ' + file)
else:
raise
def convert_markerfile(filename, outname):
from pytom.tompy.io import read
import numpy as np
from pytom.basic.datatypes import HEADER_MARKERFILE, FMT_MARKERFILE as fmtMarkerfile
a = read(filename)
point, num_images, num_markers = a.shape
markerFile = np.ones((num_markers, num_images, 4)) * -1
for i in range(num_markers):
markerFile[i, :, 0] = i
markerFile[i, :, 1:4] = a[0:3, :, i].T
with open(outname, 'w') as outfile:
np.savetxt(outfile, [], header=HEADER_MARKERFILE)
for data_slice in markerFile:
np.savetxt(outfile, data_slice, fmt=fmtMarkerfile)
def mrc2ccp4(filename, target):
from pytom_volume import read
from pytom.tools.files import checkFileExists, checkDirExists
import os
if not checkFileExists(filename):
raise RuntimeError('MRC file not found! ', filename)
if not checkDirExists(target):
raise RuntimeError('Destination directory not found! ', target)
emfile = read(filename)
splitName = filename.split(os.sep)
filename = splitName[len(splitName) - 1]
newFilename = target + os.sep + filename[0:len(filename) - 3] + '.ccp4'
emfile.write(newFilename, 'ccp4')
def recenterVolume(volume, densityNegative=False):
from scipy.ndimage import center_of_mass
from pytom.tompy.io import read, write
from pytom.tompy.tools import paste_in_center
from pytom.gpu.initialize import xp
from pytom_numpy import vol2npy
import os
try:
a = vol2npy(volume).copy()
vol = True
except:
a = volume
vol = False
if densityNegative:
a *= -1
x, y, z = list(map(int, center_of_mass(a)))
cx, cy, cz = a.shape[0] // 2, a.shape[1] // 2, a.shape[2] // 2
sx = min(x, a.shape[0] - x)
sy = min(y, a.shape[0] - y)
sz = min(z, a.shape[0] - z)
ac = a[x - sx:x + sx, y - sy:y + sy, z - sz:z + sz]
b = xp.zeros_like(a)
b = paste_in_center(ac, b)
if densityNegative: b *= -1
if vol:
write('recenteredDBV21.em', b)
from pytom.basic.files import read
vol = read('recenteredDBV21.em')
os.system('rm recenteredDBV21.em')
return vol
else:
return b
def read(self, filename, boxCoords=[0, 0, 0], dims=[32, 32, 1]):
"""
read 2D image or part of it from image or volume file
@param filename: filename of image / vol
@type filename: L{str}
@param boxCoords: coordinates in file (lower bounds)
@type boxCoords: 2-dim or 3-dim list
@param dims: dimensions of subframe
@type dims: 2-dim or 3-dim list
"""
from pytom_volume import read
self.data = read(filename, int(boxCoords[0]), int(boxCoords[1]),
int(boxCoords[2]), int(dims[0]), int(dims[1]),
int(dims[2]), 0, 0, 0, 1, 1, 1)
if self.verbose:
print(("read file <" + filename + "> at position " +
str(boxCoords[0]) + ", " + str(boxCoords[1]) + ", " +
str(boxCoords[2])))
self.boxCoords = boxCoords
self.dims = dims
def multipleParticlesVolume(particleList, templateMap, dimX, dimY, dimZ):
from pytom_volume import read, vol
volumeMap = {}
keys = list(templateMap.keys())
for key in keys:
volume = vol(dimX, dimY, dimZ)
volume.setAll(0.0)
volumeMap[key] = volume
templateVolume = read(templateMap[key])
templateMap[key] = templateVolume
for i in range(len(particleList)):
p = particleList[i]
templateVolume = templateMap[p.getClassName()]
volume = volumeMap[p.getClassName()]
volume = particleVolume(particleList[i:i + 1], templateVolume, 0, 0, 0,
volume)
return volumeMap
def decomposeMatrix(matrixFile):
"""
decomposeMatrix: Will perform analysis on calculated matrix using scipy.linalg tools
@param matrixFile: Correlation matrix in em format
@type matrixFile: Either the matrix as volume or a string
@return: [eigenValues,eigenVectors] of the matrix
"""
from scipy import linalg
from numpy import matrix
if matrixFile.__class__ == str:
from pytom_volume import read
corrMatrix = read(matrixFile)
else:
corrMatrix = matrixFile
matStr = '' #copy all matrix values into string
try:
#try to use shortest path by converting from tom volume to numpy matrix
from pytom_numpy import vol2npy
mat = matrix(vol2npy(corrMatrix))
except ImportError:
#numpy did not work. copy each entry into string and proceed, takes long time
for x in range(corrMatrix.sizeX()):
for y in range(corrMatrix.sizeY()):
matStr = matStr + ' ' + str(corrMatrix.getV(x, y, 0))
if x < (corrMatrix.sizeX() - 1):
matStr = matStr + ';'
mat = matrix(matStr) #generate numpy.matrix from string
return linalg.eigh(mat) #determine values
def determineRotationCenter(particle, binning):
"""
determineRotationCenter:
@param particle: The particle
@type particle: Either L{pytom_volume.vol} or string specifying the particle file name
@param binning: Binning factor
@return: [centerX,centerY,centerZ]
@author: Thomas Hrabe
"""
if particle.__class__ == str:
from pytom_volume import read
particle = read(particle)
centerX = particle.sizeX() / 2.0 * (1.0 / float(binning))
centerY = particle.sizeY() / 2.0 * (1.0 / float(binning))
centerZ = particle.sizeZ() / 2.0 * (1.0 / float(binning))
#
#if binning > 1:
# centerX = centerX - 0.25*(binning-1)
# centerY = centerY - 0.25*(binning-1)
# centerZ = centerZ - 0.25*(binning-1)
return [centerX, centerY, centerZ]
from pytom_volume import read
from sh.frm import frm_align_vol
from pytom.tools.maths import rotation_distance, euclidianDistance
from pytom.tools.timing import Timing
from pytom.basic.structures import ParticleList
from pytom.basic.structures import Shift, Rotation
pl = ParticleList('.')
pl.fromXMLFile('/fs/home/ychen/4Chen/first100.xml')
r = read('/fs/home/ychen/4Chen/avg_first100.em')
for pp in pl:
v = read(pp.getFilename())
pos, ang = frm_align_vol(v, [-60.0, 60.0], r, [8, 32], 10, mask=30)
pp.setShift(
Shift([
pos[0] - v.sizeX() / 2, pos[1] - v.sizeY() / 2,
pos[2] - v.sizeZ() / 2
]))
pp.setRotation(Rotation(ang))
pl.average('average.em', True)
def calculate_averages(pl, binning, mask, outdir='./'):
"""
calcuate averages for particle lists
@param pl: particle list
@type pl: L{pytom.basic.structures.ParticleList}
@param binning: binning factor
@type binning: C{int}
last change: Jan 18 2020: error message for too few processes, FF
"""
import os
from pytom_volume import complexDiv, vol, pasteCenter
from pytom.basic.fourier import fft, ifft
from pytom.basic.correlation import FSC, determineResolution
from pytom_fftplan import fftShift
from pytom_volume import reducedToFull
pls = pl.copy().splitByClass()
res = {}
freqs = {}
wedgeSum = {}
for pp in pls:
# ignore the -1 class, which is used for storing the trash class
class_label = pp[0].getClass()
if class_label != '-1':
assert len(pp) > 3
if len(pp) >= 4 * mpi.size:
spp = mpi._split_seq(pp, mpi.size)
else: # not enough particle to do averaging on one node
spp = [None] * 2
spp[0] = pp[:len(pp) // 2]
spp[1] = pp[len(pp) // 2:]
args = list(
zip(spp, [True] * len(spp), [binning] * len(spp),
[False] * len(spp), [outdir] * len(spp)))
avgs = mpi.parfor(paverage, args)
even_a, even_w, odd_a, odd_w = None, None, None, None
even_avgs = avgs[1::2]
odd_avgs = avgs[::2]
for a, w in even_avgs:
if even_a is None:
even_a = a.getVolume()
even_w = w.getVolume()
else:
even_a += a.getVolume()
even_w += w.getVolume()
os.remove(a.getFilename())
os.remove(w.getFilename())
for a, w in odd_avgs:
if odd_a is None:
odd_a = a.getVolume()
odd_w = w.getVolume()
else:
odd_a += a.getVolume()
odd_w += w.getVolume()
os.remove(a.getFilename())
os.remove(w.getFilename())
# determine the resolution
# raise error message in case even_a == None - only one processor used
if even_a == None:
from pytom.basic.exceptions import ParameterError
raise ParameterError(
'cannot split odd / even. Likely you used only one processor - use: mpirun -np 2 (or higher!)?!'
)
if mask and mask.__class__ == str:
from pytom_volume import read, pasteCenter, vol
maskBin = read(mask, 0, 0, 0, 0, 0, 0, 0, 0, 0, binning,
binning, binning)
if even_a.sizeX() != maskBin.sizeX() or even_a.sizeY(
) != maskBin.sizeY() or even_a.sizeZ() != maskBin.sizeZ():
mask = vol(even_a.sizeX(), even_a.sizeY(), even_a.sizeZ())
mask.setAll(0)
pasteCenter(maskBin, mask)
else:
mask = maskBin
fsc = FSC(even_a, odd_a, int(even_a.sizeX() // 2), mask)
band = determineResolution(fsc, 0.5)[1]
aa = even_a + odd_a
ww = even_w + odd_w
fa = fft(aa)
r = complexDiv(fa, ww)
rr = ifft(r)
rr.shiftscale(0.0, 1. / (rr.sizeX() * rr.sizeY() * rr.sizeZ()))
res[class_label] = rr
freqs[class_label] = band
ww2 = reducedToFull(ww)
fftShift(ww2, True)
wedgeSum[class_label] = ww2
print('done')
return res, freqs, wedgeSum
