def filt_vols( vols, fscs, mask3D ):
from math import sqrt
from sp_filter import fit_tanh, filt_tanl, filt_table
from sp_fundamentals import rops_table
from sp_morphology import threshold
flmin = 1.0
flmax = -1.0
nvol = len(vols)
for i in range(nvol):
fl, aa = fit_tanh( fscs[i] )
if (fl < flmin):
flmin = fl
aamin = aa
if (fl > flmax):
flmax = fl
idmax = i
sxprint(" Filter tanl, parameters: ",flmin-0.05, " ", aamin)
volmax = vols[idmax]
volmax = filt_tanl( volmax, flmin-0.05, aamin )
pmax = rops_table( volmax )
for i in range(nvol):
ptab = rops_table( vols[i] )
for j in range( len(ptab) ):
ptab[j] = sqrt( pmax[j]/ptab[j] )
vols[i] = filt_table( vols[i], ptab )
#stat = Util.infomask( vols[i], mask3D, False )
#volf -= stat[0]
Util.mul_img( vols[i], mask3D )
#volf = threshold( volf )
return vols
def adjust_pw_to_model(image, pixel_size, roo):
c1 = -4.5
c2 = 15.0
c3 = 0.2
c4 = -1.0
c5 = old_div(1.0, 5.0)
c6 = 0.25 # six params are fitted to Yifan channel model
rot1 = sp_fundamentals.rops_table(image)
fil = [None] * len(rot1)
if roo is None: # adjusted to the analytic model, See Penczek Methods Enzymol 2010
pu = []
for ifreq in range(len(rot1)):
x = old_div(old_div(float(ifreq), float(len(rot1))), pixel_size)
v = numpy.exp(c1 + old_div(c2, (old_div(x, c3) + 1)**2)
) + numpy.exp(c4 - 0.5 *
(old_div((x - c5), c6**2)**2))
pu.append(v)
s = sum(pu)
for ifreq in range(len(rot1)):
fil[ifreq] = numpy.sqrt(old_div(pu[ifreq], (rot1[ifreq] * s)))
else: # adjusted to a given 1-d rotational averaged pw2
if roo[0] < 0.1 or roo[0] > 1.0:
s = sum(roo)
else:
s = 1.0
for ifreq in range(len(rot1)):
fil[ifreq] = numpy.sqrt(old_div(roo[ifreq], (rot1[ifreq] * s)))
return sp_filter.filt_table(image, fil)
def adjust_pw_to_model(image, pixel_size, roo):
pass #IMPORTIMPORTIMPORT from sp_fundamentals import rops_table
pass #IMPORTIMPORTIMPORT from sp_filter import filt_table
pass #IMPORTIMPORTIMPORT from math import exp, sqrt
c1 = -4.5
c2 = 15.0
c3 = 0.2
c4 = -1.0
c5 = 1. / 5.
c6 = 0.25 # six params are fitted to Yifan channel model
rot1 = sp_fundamentals.rops_table(image)
fil = [None] * len(rot1)
if roo is None: # adjusted to the analytic model, See Penczek Methods Enzymol 2010
pu = []
for ifreq in range(len(rot1)):
x = float(ifreq) / float(len(rot1)) / pixel_size
v = numpy.exp(c1 + c2 /
(x / c3 + 1)**2) + numpy.exp(c4 - 0.5 *
(((x - c5) / c6**2)**2))
pu.append(v)
s = sum(pu)
for ifreq in range(len(rot1)):
fil[ifreq] = numpy.sqrt(pu[ifreq] / (rot1[ifreq] * s))
else: # adjusted to a given 1-d rotational averaged pw2
if roo[0] < 0.1 or roo[0] > 1.: s = sum(roo)
else: s = 1.0
for ifreq in range(len(rot1)):
fil[ifreq] = numpy.sqrt(roo[ifreq] / (rot1[ifreq] * s))
return sp_filter.filt_table(image, fil)
def filt_matched(ima, SNR, Pref):
"""
Calculate Matched filter. The reference image is
assumed to be a Wiener average
See paper Alignment under noise by PRB et al
"""
from sp_filter import filt_from_fsc_bwt, filt_table
from math import sqrt
from EMAN2 import EMData
from sp_fundamentals import rops_table
ctf_2 = ima.get_attr('ctf_2')
PU = ima.get_attr('PU')
Pn1 = ima.get_attr('Pn1')
Pn2 = ima.get_attr('Pn2')
TE = ima.get_attr('TE')
HM = []
TMP1 = []
TMP2 = []
for j in range(len(Pref) - 1):
if (SNR[j] > .05):
thm = SNR[j] * (SNR[j] + 1.) * PU[j] / Pref[j]
sxprint(thm)
hm = sqrt(thm)
deno = (SNR[j] + 1) * (ctf_2[j] * Pn2[j] * TE[j]**2 +
Pn1[j]) + ctf_2[j] * PU[j] * TE[j]**2
xval = hm / deno
else:
hm = 0.0
xval = 0.0
HM.append(xval)
TMP1.append(Pref[j])
TMP2.append(hm)
img = filt_table(ima, HM)
res = []
res.append(img)
res.append(TMP1)
res.append(TMP2)
del HM
return res
def compare_projs(reconfile,
classavgstack,
inputanglesdoc,
outdir,
interpolation_method=1,
log=None,
verbose=False):
"""
Make comparison stack between class averages (even-numbered (starts from 0)) and re-projections (odd-numbered).
Arguments:
reconfile : Input volume from which to generate re-projections
classavgstack ; Input image stack
inputanglesdoc : Input Euler angles doc
outdir ; Output directory
interpolation_method : Interpolation method: nearest neighbor (nn, 0), trilinear (1, default), gridding (-1)
log : Logger object
verbose : (boolean) Whether to write additional information to screen
Returns:
compstack : Stack of comparisons between input image stack (even-numbered (starts from 0)) and input volume (odd-numbered)
"""
recondata = EMAN2.EMData(reconfile)
nx = recondata.get_xsize()
# Resample reference
reconprep = prep_vol(recondata,
npad=2,
interpolation_method=interpolation_method)
ccclist = []
# Here you need actual radius to compute proper ccc's, but if you do, you have to deal with translations, PAP
mask = model_circle(nx // 2 - 2, nx, nx)
mask.write_image(os.path.join(outdir, 'maskalign.hdf'))
compstack = os.path.join(outdir, 'comp-proj-reproj.hdf')
# Number of images may have changed
nimg1 = EMAN2.EMUtil.get_image_count(classavgstack)
angleslist = read_text_row(inputanglesdoc)
for imgnum in range(nimg1):
# Get class average
classimg = get_im(classavgstack, imgnum)
# Compute re-projection
prjimg = prgl(reconprep,
angleslist[imgnum],
interpolation_method=1,
return_real=False)
# Calculate 1D power spectra
rops_dst = rops_table(classimg * mask)
rops_src = rops_table(prjimg)
# Set power spectrum of reprojection to the data.
# Since data has an envelope, it would make more sense to set data to reconstruction,
# but to do it one would have to know the actual resolution of the data.
# you can check sxprocess.py --adjpw to see how this is done properly PAP
table = [0.0] * len(rops_dst) # initialize table
for j in range(len(rops_dst)):
table[j] = sqrt(rops_dst[j] / rops_src[j])
prjimg = fft(filt_table(
prjimg,
table)) # match FFT amplitudes of re-projection and class average
cccoeff = ccc(prjimg, classimg, mask)
#print imgnum, cccoeff
classimg.set_attr_dict({'cross-corr': cccoeff})
prjimg.set_attr_dict({'cross-corr': cccoeff})
montagestack = []
montagestack.append(prjimg)
montagestack.append(classimg)
comparison_pair = montage2(montagestack, ncol=2, marginwidth=1)
comparison_pair.write_image(compstack, imgnum)
ccclist.append(cccoeff)
del angleslist
meanccc = sum(ccclist) / nimg1
print_log_msg("Average CCC is %s\n" % meanccc, log, verbose)
nimg2 = EMAN2.EMUtil.get_image_count(compstack)
for imgnum in range(nimg2): # xrange will be deprecated in Python3
prjimg = get_im(compstack, imgnum)
meanccc1 = prjimg.get_attr_default('mean-cross-corr', -1.0)
prjimg.set_attr_dict({'mean-cross-corr': meanccc})
write_header(compstack, prjimg, imgnum)
return compstack
def recons3d_trl_struct_MPI(
myid,
main_node,
prjlist,
paramstructure,
refang,
rshifts_shrank,
delta,
upweighted=True,
mpi_comm=None,
CTF=True,
target_size=-1,
avgnorm=1.0,
norm_per_particle=None,
):
"""
recons3d_4nn_ctf - calculate CTF-corrected 3-D reconstruction from a set of projections using three Eulerian angles, two shifts, and CTF settings for each projeciton image
Input
list_of_prjlist: list of lists of projections to be included in the reconstruction
"""
if mpi_comm == None:
mpi_comm = mpi.MPI_COMM_WORLD
refvol = sp_utilities.model_blank(target_size)
refvol.set_attr("fudge", 1.0)
if CTF:
do_ctf = 1
else:
do_ctf = 0
fftvol = EMAN2_cppwrap.EMData()
weight = EMAN2_cppwrap.EMData()
params = {
"size": target_size,
"npad": 2,
"snr": 1.0,
"sign": 1,
"symmetry": "c1",
"refvol": refvol,
"fftvol": fftvol,
"weight": weight,
"do_ctf": do_ctf,
}
r = EMAN2_cppwrap.Reconstructors.get("nn4_ctfw", params)
r.setup()
if prjlist:
if norm_per_particle == None:
norm_per_particle = len(prjlist) * [1.0]
nnx = prjlist[0].get_xsize()
nny = prjlist[0].get_ysize()
nshifts = len(rshifts_shrank)
for im in range(len(prjlist)):
# parse projection structure, generate three lists:
# [ipsi+iang], [ishift], [probability]
# Number of orientations for a given image
numbor = len(paramstructure[im][2])
ipsiandiang = [
old_div(paramstructure[im][2][i][0], 1000)
for i in range(numbor)
]
allshifts = [
paramstructure[im][2][i][0] % 1000 for i in range(numbor)
]
probs = [paramstructure[im][2][i][1] for i in range(numbor)]
# Find unique projection directions
tdir = list(set(ipsiandiang))
bckgn = prjlist[im].get_attr("bckgnoise")
ct = prjlist[im].get_attr("ctf")
# For each unique projection direction:
data = [None] * nshifts
for ii in range(len(tdir)):
# Find the number of times given projection direction appears on the list, it is the number of different shifts associated with it.
lshifts = sp_utilities.findall(tdir[ii], ipsiandiang)
toprab = 0.0
for ki in range(len(lshifts)):
toprab += probs[lshifts[ki]]
recdata = EMAN2_cppwrap.EMData(nny, nny, 1, False)
recdata.set_attr("is_complex", 0)
for ki in range(len(lshifts)):
lpt = allshifts[lshifts[ki]]
if data[lpt] == None:
data[lpt] = sp_fundamentals.fshift(
prjlist[im], rshifts_shrank[lpt][0],
rshifts_shrank[lpt][1])
data[lpt].set_attr("is_complex", 0)
EMAN2_cppwrap.Util.add_img(
recdata,
EMAN2_cppwrap.Util.mult_scalar(
data[lpt], old_div(probs[lshifts[ki]], toprab)),
)
recdata.set_attr_dict({
"padffted": 1,
"is_fftpad": 1,
"is_fftodd": 0,
"is_complex_ri": 1,
"is_complex": 1,
})
if not upweighted:
recdata = sp_filter.filt_table(recdata, bckgn)
recdata.set_attr_dict({"bckgnoise": bckgn, "ctf": ct})
ipsi = tdir[ii] % 100000
iang = old_div(tdir[ii], 100000)
r.insert_slice(
recdata,
EMAN2_cppwrap.Transform({
"type":
"spider",
"phi":
refang[iang][0],
"theta":
refang[iang][1],
"psi":
refang[iang][2] + ipsi * delta,
}),
old_div(toprab * avgnorm, norm_per_particle[im]),
)
# clean stuff
del bckgn, recdata, tdir, ipsiandiang, allshifts, probs
sp_utilities.reduce_EMData_to_root(fftvol, myid, main_node, comm=mpi_comm)
sp_utilities.reduce_EMData_to_root(weight, myid, main_node, comm=mpi_comm)
if myid == main_node:
dummy = r.finish(True)
mpi.mpi_barrier(mpi_comm)
if myid == main_node:
return fftvol, weight, refvol
else:
return None, None, None