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,
