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