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 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 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 transformFourierSpline(volume,z1,z2,x,shiftX,shiftY,shiftZ,twice=False): """ transformFourierSpline: Rotate and shift a volume in fourierspace @param volume: @param z1: @param z2: @param x: @param shiftX: Shift after rotation @param shiftY: Shift after rotation @param shiftZ: Shift after rotation @param twice: Zero pad volume into a twice sized volume and perform calculation there. @return: The transformed volume. @author: Yuxiang Chen and Thomas Hrabe """ from pytom.basic.fourier import fft, ifft, ftshift, iftshift from pytom_volume import vol, pasteCenter, subvolume, transformFourierSpline if z1 == 0 and z2 == 0 and x == 0: return vol(volume) if twice: # paste into a twice sized volume v = vol(volume.sizeX()*2, volume.sizeY()*2, volume.sizeZ()*2) pasteCenter(volume, v) else: v = volume fvol = fft(iftshift(v, inplace=False)) # these steps have to be done in python level because of the fft resF = transformFourierSpline(fvol,z1,z2,x,shiftX,shiftY,shiftZ) res = ftshift(ifft(resF),inplace=False) / v.numelem() # reverse it back if twice: # cut the center part back res = subvolume(res, (volume.sizeX()+1)/2, (volume.sizeY()+1)/2, (volume.sizeZ()+1)/2, volume.sizeX(), volume.sizeY(), volume.sizeZ()) return res
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
def extractPeaks(volume, reference, rotations, scoreFnc=None, mask=None, maskIsSphere=False, wedgeInfo=None, **kwargs): ''' Created on May 17, 2010 @param volume: target volume @type volume: L{pytom_volume.vol} @param reference: reference @type reference: L{pytom_volume.vol} @param rotations: rotation angle list @type rotations: L{pytom.angles.globalSampling.GlobalSampling} @param scoreFnc: score function that is used @type scoreFnc: L{pytom.basic.correlation} @param mask: mask volume @type mask: L{pytom_volume.vol} @param maskIsSphere: flag to indicate whether the mask is sphere or not @type maskIsSphere: boolean @param wedgeInfo: wedge information @type wedgeInfo: L{pytom.basic.structures.WedgeInfo} @return: both the score volume and the corresponding rotation index volume @rtype: L{pytom_volume.vol} @author: chen ''' # from pytom.tools.timing import timing # t = timing(); t.start() # parse the parameters nodeName = kwargs.get('nodeName', '') verbose = kwargs.get('verboseMode', True) if verbose not in [True, False]: verbose = True moreInfo = kwargs.get('moreInfo', False) if moreInfo not in [True, False]: moreInfo = False from pytom.basic.correlation import FLCF from pytom.basic.structures import WedgeInfo, Wedge from pytom_volume import vol, pasteCenter from pytom_volume import rotateSpline as rotate # for more accuracy from pytom_volume import updateResFromIdx from pytom.basic.files import write_em if scoreFnc == None: scoreFnc = FLCF # only FLCF needs mask if scoreFnc == FLCF: if mask.__class__ != vol: # construct a sphere mask by default from pytom_volume import initSphere mask = vol(reference.sizeX(), reference.sizeY(), reference.sizeZ()) mask.setAll(0) initSphere(mask, reference.sizeX() / 2, 0, 0, reference.sizeX() / 2, reference.sizeX() / 2, reference.sizeX() / 2) maskIsSphere = True # result volume which stores the score result = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) result.setAll(-1) # result orientation of the peak value (index) orientation = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) orientation.setAll(0) currentRotation = rotations.nextRotation() index = 0 if verbose == True: from pytom.tools.ProgressBar import FixedProgBar max = rotations.numberRotations() - 1 prog = FixedProgBar(0, max, nodeName) if moreInfo: sumV = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) sumV.setAll(0) sqrV = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) sqrV.setAll(0) else: sumV = None sqrV = None if wedgeInfo.__class__ == WedgeInfo or wedgeInfo.__class__ == Wedge: print('Applied wedge to volume') volume = wedgeInfo.apply(volume) while currentRotation != [None, None, None]: if verbose == True: prog.update(index) # rotate the reference ref = vol(reference.sizeX(), reference.sizeY(), reference.sizeZ()) rotate(reference, ref, currentRotation[0], currentRotation[1], currentRotation[2]) # apply wedge if wedgeInfo.__class__ == WedgeInfo or wedgeInfo.__class__ == Wedge: ref = wedgeInfo.apply(ref) # rotate the mask if it is asymmetric if scoreFnc == FLCF: if maskIsSphere == False: # if mask is not a sphere, then rotate it m = vol(mask.sizeX(), mask.sizeY(), mask.sizeZ()) rotate(mask, m, currentRotation[0], currentRotation[1], currentRotation[2]) else: m = mask # compute the score # if mask is sphere and it is the first run, compute the standard deviation of the volume under mask for late use if scoreFnc == FLCF and index == 0 and maskIsSphere == True: # compute standard deviation of the volume under mask maskV = m if volume.sizeX() != m.sizeX() or volume.sizeY() != m.sizeY( ) or volume.sizeZ() != m.sizeZ(): maskV = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) maskV.setAll(0) pasteCenter(m, maskV) from pytom_volume import sum p = sum(m) from pytom.basic.correlation import meanUnderMask, stdUnderMask meanV = meanUnderMask(volume, maskV, p) stdV = stdUnderMask(volume, maskV, p, meanV) # ref.write('template_cpu.em') if scoreFnc == FLCF: if maskIsSphere == True: score = scoreFnc(volume, ref, m, stdV, wedge=1) else: score = scoreFnc(volume, ref, m) else: # not FLCF, so doesn't need mask as parameter and perhaps the reference should have the same size _ref = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) _ref.setAll(0) pasteCenter(ref, _ref) score = scoreFnc(volume, _ref) # update the result volume and the orientation volume updateResFromIdx(result, score, orientation, index) if moreInfo: sumV = sumV + score sqrV = sqrV + score * score currentRotation = rotations.nextRotation() index = index + 1 # if moreInfo: # sumV = sumV/rotations.numberRotations() # sqrV = sqrV/rotations.numberRotations() # time = t.end(); print 'The overall execution time: %f' % time return [result, orientation, sumV, sqrV]
tempCentGPU = gu.zeros_like(voluGPU) paste_in_center_gpu(tempCentGPU, np.int32(spx), np.int32(spy), np.int32(spz), tempGPU, np.int32(sox), np.int32(soy), np.int32(soz), block=(10, 10, 10), grid=(8, 1, 1)) TCG = tempCentGPU.get() tempCentVOL = vol(voluVOL.sizeX(), voluVOL.sizeY(), voluVOL.sizeZ()) tempCentVOL.setAll(0) pasteCenter(tempVOL, tempCentVOL) TCV = vol2npy(tempCentVOL) print('\n center template results') for eval in (tempCentNDA, TCG, TCV): print((eval - TCV).mean(), eval.min(), eval.max()) #PASTE MASK IN CENTER maskCentNDA = np.zeros_like(voluNDA) maskCentNDA = paste_in_center(maskNDA, maskCentNDA) maskCentGPU = gu.zeros_like(voluGPU) paste_in_center_gpu(maskCentGPU, np.int32(spx), np.int32(spy), np.int32(spz),
def writeAlignedProjections(TiltSeries_, weighting=None, lowpassFilter=None, binning=None,verbose=False, write_images=True): """write weighted and aligned projections to disk1 @param TiltSeries_: Tilt Series @type TiltSeries_: reconstruction.TiltSeries @param weighting: weighting (<0: analytical weighting, >1 exact weighting (value corresponds to object diameter in pixel AFTER binning) @type weighting: float @param lowpassFilter: lowpass filter (in Nyquist) @type lowpassFilter: float @param binning: binning (default: 1 = no binning). binning=2: 2x2 pixels -> 1 pixel, binning=3: 3x3 pixels -> 1 pixel, etc. @author: FF """ import numpy from pytom_numpy import vol2npy from pytom.basic.files import read_em, write_em from pytom.basic.functions import taper_edges from pytom.basic.transformations import general_transform2d from pytom.basic.fourier import ifft, fft from pytom.basic.filter import filter as filterFunction, bandpassFilter from pytom.basic.filter import circleFilter, rampFilter, exactFilter, fourierFilterShift, rotateFilter from pytom_volume import complexRealMult, vol, pasteCenter import pytom_freqweight from pytom.basic.transformations import resize from pytom.gui.guiFunctions import fmtAR, headerAlignmentResults, datatypeAR import os from pytom.basic.files import EMHeader, read, read_em_header from pytom.tompy.io import read_size if binning: imdim = int(float(TiltSeries_._imdim)/float(binning)+.5) else: imdim = TiltSeries_._imdim imdimX = int(numpy.around(read_size(TiltSeries_._ProjectionList[0]._filename, 'x')/binning,0)) imdimY = int(numpy.around(read_size(TiltSeries_._ProjectionList[0]._filename, 'y')/binning,0)) imdim = int(max(imdimX, imdimY)) sliceWidth = imdim # pre-determine analytical weighting function and lowpass for speedup if (weighting != None) and (weighting < -0.001): w_func = fourierFilterShift(rampFilter(imdim, imdim)) print('start weighting') # design lowpass filter if lowpassFilter: if lowpassFilter > 1.: lowpassFilter = 1. print("Warning: lowpassFilter > 1 - set to 1 (=Nyquist)") # weighting filter: arguments: (angle, cutoff radius, dimx, dimy, lpf = pytom_freqweight.weight(0.0,lowpassFilter*imdim/2, imdim, imdim//2+1,1, lowpassFilter/5.*imdim) # lpf2 = pytom_freqweight.weight(0.0, lowpassFilter * imdimY / 2, imdimX, imdimY // 2 + 1, 1, # lowpassFilter / 5. * imdimY) #lpf = bandpassFilter(volume=vol(imdim, imdim,1),lowestFrequency=0,highestFrequency=int(lowpassFilter*imdim/2), # bpf=None,smooth=lowpassFilter/5.*imdim,fourierOnly=False)[1] tilt_angles = [] for projection in TiltSeries_._ProjectionList: tilt_angles.append( projection._tiltAngle ) tilt_angles = sorted(tilt_angles) #q = numpy.matrix(abs(numpy.arange(-imdim//2, imdim//2))) alignmentResults = numpy.zeros((len(TiltSeries_._ProjectionList)),dtype=datatypeAR) alignmentResults['TiltAngle'] = tilt_angles for (ii,projection) in enumerate(TiltSeries_._ProjectionList): alignmentResults['FileName'][ii] = os.path.join(os.getcwd(), projection._filename) transX = -projection._alignmentTransX / binning transY = -projection._alignmentTransY / binning rot = -(projection._alignmentRotation + 90.) mag = projection._alignmentMagnification alignmentResults['AlignmentTransX'][ii] = transX alignmentResults['AlignmentTransY'][ii] = transY alignmentResults['InPlaneRotation'][ii] = rot alignmentResults['Magnification'][ii] = mag if write_images: if projection._filename.split('.')[-1] == 'st': from pytom.basic.files import EMHeader, read header = EMHeader() header.set_dim(x=imdim, y=imdim, z=1) idx = projection._index if verbose: print("reading in projection %d" % idx) image = read(file=projection._filename, subregion=[0,0,idx-1,TiltSeries_._imdim,TiltSeries_._imdim,1], sampling=[0,0,0], binning=[0,0,0]) if not (binning == 1) or (binning == None): image = resize(volume=image, factor=1/float(binning))[0] else: # read projection files from pytom.basic.files import EMHeader, read, read_em_header image = read(projection._filename) image = resize(volume=image, factor=1 / float(binning))[0] if projection._filename[-3:] == '.em': header = read_em_header(projection._filename) else: header = EMHeader() header.set_dim(x=imdim, y=imdim, z=1) tiltAngle = projection._tiltAngle header.set_tiltangle(tiltAngle) # # 5 -- Optional Low Pass Filter # if lowpassFilter: # filtered = filterFunction( volume=image, filterObject=lpf2, fourierOnly=False) # image = filtered[0] # 1 -- normalize to contrast - subtract mean and norm to mean immean = vol2npy(image).mean() image = (image - immean)/immean # 2 -- smoothen borders to prevent high contrast oscillations image = taper_edges(image, imdim//30)[0] # transform projection according to tilt alignment if projection._filename.split('.')[-1] == 'st': newFilename = (TiltSeries_._alignedTiltSeriesName+"_"+str(projection.getIndex())+'.em') else: TiltSeries_._tiltSeriesFormat = 'mrc' newFilename = (TiltSeries_._alignedTiltSeriesName+"_"+str(projection.getIndex()) +'.'+TiltSeries_._tiltSeriesFormat) if verbose: tline = ("%30s" %newFilename) tline = tline + (" (tiltAngle=%6.2f)" % tiltAngle) tline = tline + (": transX=%6.1f" %transX) tline = tline + (", transY=%6.1f" %transY) tline = tline + (", rot=%6.2f" %rot) tline = tline + (", mag=%5.4f" %mag) print(tline) # 3 -- square if needed if imdimY != imdimX: print('Squared image to larger dimension') newImage = vol(imdim, imdim,1) newImage.setAll(0) pasteCenter(image, newImage) image = newImage # 4 -- Rotate image = general_transform2d(v=image, rot=rot, shift=[transX,transY], scale=mag, order=[2, 1, 0], crop=True) # 5 -- Optional Low Pass Filter if lowpassFilter: filtered = filterFunction( volume=image, filterObject=lpf, fourierOnly=False) image = filtered[0] # 6 -- smoothen once more to avoid edges image = taper_edges(image, imdim//30)[0] # 7 -- weighting if (weighting != None) and (weighting < 0): image = (ifft( complexRealMult( fft( image), w_func) ) / (image.sizeX()*image.sizeY()*image.sizeZ()) ) elif (weighting != None) and (weighting > 0): if weighting > 1.5: w_func = fourierFilterShift(rotateFilter(tilt_angles, tiltAngle, imdim, imdim, sliceWidth)) else: w_func = fourierFilterShift(exactFilter(tilt_angles, tiltAngle, imdim, imdim, sliceWidth)) image = (ifft( complexRealMult( fft( image), w_func) )/ (image.sizeX()*image.sizeY()*image.sizeZ()) ) header.set_tiltangle(tilt_angles[ii]) if newFilename.endswith ('.mrc'): data = copy.deepcopy(vol2npy(image)) mrcfile.new(newFilename,data.T.astype(float32),overwrite=True) else: write_em(filename=newFilename, data=image, header=header) if verbose: tline = ("%30s written ..." %newFilename) outname = os.path.join(os.path.dirname(TiltSeries_._alignedTiltSeriesName), 'alignmentResults.txt') numpy.savetxt(outname, alignmentResults, fmt=fmtAR, header=headerAlignmentResults) print('Alignment successful. See {} for results.'.format(outname))
def FLCF(volume, template, mask=None, stdV=None): ''' Created on Apr 13, 2010 FLCF: compute the fast local correlation function This functions works only when the mask is in the middle. @param volume: target volume @type volume: L{pytom_volume.vol} @param template: template to be searched. It can have smaller size then target volume. @type template: L{pytom_volume.vol} @param mask: template mask. If not given, a default sphere mask will be generated which has the same size with the given template. @type mask: L{pytom_volume.vol} @param stdV: standard deviation of the target volume under mask, which do not need to be calculated again when the mask is identical. @type stdV: L{pytom_volume.vol} @return: the local correlation function @rtype: L{pytom_volume.vol} @author: Yuxiang Chen ''' from pytom_volume import vol, pasteCenter from pytom.basic.fourier import fft, ifft, iftshift from pytom_volume import conjugate from pytom.basic.structures import Mask from pytom_volume import sum from pytom.basic.files import write_em if volume.__class__ != vol and template.__class__ != vol: raise RuntimeError('Wrong input type!') if volume.sizeX()<template.sizeX() or volume.sizeY()<template.sizeY() or volume.sizeZ()<template.sizeZ(): raise RuntimeError('Template size is bigger than the target volume') # generate the mask if mask.__class__ != vol: from pytom_volume import initSphere mask = vol(template.sizeX(), template.sizeY(), template.sizeZ()) mask.setAll(0) initSphere(mask, template.sizeX()/2,0,0,template.sizeX()/2, template.sizeY()/2, template.sizeZ()/2) else: if template.sizeX()!=mask.sizeX() and template.sizeY()!=mask.sizeY() and template.sizeZ()!=mask.sizeZ(): raise RuntimeError('Template and mask size are not consistent!') # calculate the non-zeros p = sum(mask) # normalize the template under mask meanT = meanValueUnderMask(template, mask, p) stdT = stdValueUnderMask(template, mask, meanT, p) temp = (template - meanT)/stdT temp = temp * mask # construct both the template and the mask which has the same size as target volume tempV = temp if volume.sizeX() != temp.sizeX() or volume.sizeY() != temp.sizeY() or volume.sizeZ() != temp.sizeZ(): tempV = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) tempV.setAll(0) pasteCenter(temp, tempV) maskV = mask if volume.sizeX() != mask.sizeX() or volume.sizeY() != mask.sizeY() or volume.sizeZ() != mask.sizeZ(): maskV = vol(volume.sizeX(), volume.sizeY(), volume.sizeZ()) maskV.setAll(0) pasteCenter(mask, maskV) # calculate the mean and std of volume if stdV.__class__ != vol: meanV = meanUnderMask(volume, maskV, p) stdV = stdUnderMask(volume, maskV, p, meanV) size = volume.numelem() fT = fft(tempV) conjugate(fT) result = iftshift(ifft(fT*fft(volume)))/stdV result.shiftscale(0,1/(size*p)) return result
mask2 = paste_in_center(mask, np.zeros_like(volume)) from pytom.tompy.correlation import meanVolUnderMask, stdVolUnderMask import pytom.basic.correlation as corr from pytom.basic.files import read as readd from pytom.basic.files import write_em from pytom_numpy import vol2npy, npy2vol from pytom_volume import pasteCenter, vol vv = readd('tomo.mrc', subregion=[0, 0, start, 464, 464, end - start]) mm = readd('mask.em') if vv.sizeX() != mm.sizeX() or vv.sizeY() != mm.sizeY() or vv.sizeZ( ) != mm.sizeZ(): maskV = vol(vv.sizeX(), vv.sizeY(), vv.sizeZ()) maskV.setAll(0) pasteCenter(mm, maskV) meanV = corr.meanUnderMask(vv, maskV, mask.sum()) stdVol = corr.stdUnderMask(vv, maskV, mask.sum(), meanV) write_em('stdV.em', stdVol) stdV = vol2npy(stdVol).copy() stdV = stdV.transpose(2, 1, 0).copy() assert stdV.shape == volume.shape #mask = paste_in_center(mask, np.zeros_like(volume)) start = driver.Event() end = driver.Event() start.record() scores, angles, plan = template_matching_gpu(volume,