def image_decimate(img, decimation=2, fit_to_fft = True, frequency_low=0, frequency_high=0):
"""
Window 2D image to FFT-friendly size, apply Butterworth low pass filter,
and decimate image by integer factor
"""
from filter import filt_btwl
from fundamentals import smallprime, window2d
from utilities import get_image
if type(img) == str: img=get_image(img)
nz = img.get_zsize()
if( nz > 1): ERROR("This command works only for 2-D images", "image_decimate", 1)
if decimation <= 1 : ERROR("Improper decimation ratio", "image_decimate", 1)
if(decimation == 1.0): return img.copy()
if frequency_low <= 0 :
frequency_low = 0.5/decimation-0.02
if frequency_low <= 0 : ERROR("Butterworth passband frequency is too low","image_decimation",1)
frequency_high = min(0.5/decimation + 0.02, 0.499)
if fit_to_fft:
nx = img.get_xsize()
ny = img.get_ysize()
nx_fft_m = smallprime(nx)
ny_fft_m = smallprime(ny)
e = Util.window(img, nx_fft_m, ny_fft_m, 1, 0,0,0)
e = filt_btwl(e, frequency_low, frequency_high)
else:
e = filt_btwl(img, frequency_low, frequency_high)
return Util.decimate(e, int(decimation), int(decimation), 1)
def image_decimate(img, decimation=2, fit_to_fft = True, frequency_low=0, frequency_high=0):
"""
Window 2D image to FFT-friendly size, apply Butterworth low pass filter,
and decimate image by integer factor
"""
from filter import filt_btwl
from fundamentals import smallprime, window2d
from utilities import get_image
if type(img) == str: img=get_image(img)
nz = img.get_zsize()
if( nz > 1): ERROR("This command works only for 2-D images", "image_decimate", 1)
if decimation <= 1 : ERROR("Improper decimation ratio", "image_decimate", 1)
if(decimation == 1.0): return img.copy()
if frequency_low <= 0 :
frequency_low = 0.5/decimation-0.02
if frequency_low <= 0 : ERROR("Butterworth pass-band frequency is too low","image_decimation",1)
frequency_high = min(0.5/decimation + 0.02, 0.499)
if fit_to_fft:
nx = img.get_xsize()
ny = img.get_ysize()
nx_fft_m = smallprime(nx)
ny_fft_m = smallprime(ny)
e = Util.window(img, nx_fft_m, ny_fft_m, 1, 0,0,0)
e = filt_btwl(e, frequency_low, frequency_high)
else:
e = filt_btwl(img, frequency_low, frequency_high)
return Util.decimate(e, int(decimation), int(decimation), 1)
def image_decimate_window_xform_ctf(img, decimation = 0.5, window_size = 0, CTF = False):
from filter import filt_btwl
from fundamentals import smallprime,window2d
from utilities import get_image,get_params_proj,set_params_proj,get_ctf, set_ctf
nx = img.get_xsize()
ny = img.get_ysize()
nz = img.get_zsize()
if( nz > 1): ERROR("This command works only for 2-D images", "image_decimate", 1)
if nx < window_size or ny < window_size: ERROR("Image size is less than window size", "image_decimate_window_xform_ctf", 1)
if CTF:
[defocus,cs,voltage,pixel_size,bfactor,ampconst,dfdiff,dfang] = get_ctf(img)
ctf_params =[defocus,cs,voltage,pixel_size*decimation,bfactor,ampconst,dfdiff,dfang]
[phi,theta, psi, tx, ty] = get_params_proj(img)
new_params = [phi, theta, psi, tx*decimation,ty*decimation]
if decimation ==1:
if window_size ==0: return img
else:
img = Util.window(img, window_size, window_size,1, 0, 0, 0)
if CTF: set_ctf(img,ctf_params)
set_params_proj(img,new_params)
return img
elif decimation < 1: # reduce image size
frequency_low = 0.5*decimation-0.02
if frequency_low <= 0 : ERROR("Butterworth passband frequency is too low","image_decimation",1)
frequency_high = min(0.5*decimation + 0.02, 0.499)
if window_size >0:img = Util.window(img, window_size, window_size, 1, 0, 0, 0)
decimated_image = Util.decimate(filt_btwl(img, frequency_low, frequency_high), int(1./decimation), int(1./decimation), 1)
else: #increase image size
if window_size ==0:
new_nx = int(nx*decimation+0.5)
new_ny = int(ny*decimation+0.5)
e, kb = prepi(Util.pad(img, new_nx, new_ny, 1, 0, 0, 0, "circumference"))
decimated_image = e.rot_scale_conv_new(0.0, 0.0, 0.0, kb, decimation)
else:
img = Util.window(img, window_size, window_size,1, 0, 0, 0)
new_nx = int(window_size*decimation+0.5)
new_ny = int(window_size*decimation+0.5)
e, kb = prepi(Util.pad(img, new_nx, new_ny, 1, 0, 0, 0, "circumference"))
decimated_image = e.rot_scale_conv_new(0.0, 0.0, 0.0, kb, decimation)
set_params_proj(decimated_image,new_params)
if CTF: set_ctf(decimated_image,ctf_params)
return decimated_image
def image_decimate_window_xform_ctf(img,decimation=2,window_size=0,CTF=False):
"""
Window 2D image to FFT-friendly size, apply Butterworth low pass filter,
and decimate image by integer factor
"""
from filter import filt_btwl
from fundamentals import smallprime,window2d
from utilities import get_image,get_params_proj,set_params_proj,get_ctf, set_ctf
if decimation ==1:
if window_size ==0:
return img
else:
[phi,theta,psi,tx,ty]=get_params_proj(img)
if CTF:[defocus,cs,voltage,pixel_size,bfactor,ampconst,dfdiff,dfang] = get_ctf(img)
new_params =[phi, theta, psi, tx/decimation,ty/decimation]
img = Util.window(img,window_size,window_size,1, 0, 0, 0)
set_params_proj(img,new_params)
if CTF:
ctf_params=[defocus,cs,voltage,pixel_size*decimation,bfactor,ampconst,dfdiff,dfang]
set_ctf(img,ctf_params)
return img
else:
nz= img.get_zsize()
if( nz > 1): ERROR("This command works only for 2-D images", "image_decimate", 1)
if decimation <= 1 : ERROR("Improper decimation ratio", "image_decimate", 1)
[phi,theta,psi,tx,ty]=get_params_proj(img)
new_params =[phi,theta,psi,tx/decimation,ty/decimation]
if CTF:[defocus,cs,voltage,pixel_size,bfactor,ampconst,dfdiff,dfang] = get_ctf(img)
frequency_low = 0.5/decimation-0.02
if frequency_low <= 0 : ERROR("Butterworth passband frequency is too low","image_decimation",1)
frequency_high = min(0.5/decimation + 0.02, 0.499)
if window_size >0:
img = Util.window(img, window_size, window_size,1, 0, 0, 0)
e = filt_btwl(img,frequency_low,frequency_high)
decimated_image = Util.decimate(e,int(decimation),int(decimation), 1)
set_params_proj(decimated_image,new_params)
if CTF:
ctf_params = [defocus,cs,voltage,pixel_size*decimation,bfactor,ampconst,dfdiff,dfang]
set_ctf(decimated_image,ctf_params)
return decimated_image
def do_volume_mrk02(ref_data):
"""
data - projections (scattered between cpus) or the volume. If volume, just do the volume processing
options - the same for all cpus
return - volume the same for all cpus
"""
from EMAN2 import Util
from mpi import mpi_comm_rank, mpi_comm_size, MPI_COMM_WORLD
from filter import filt_table
from reconstruction import recons3d_4nn_MPI, recons3d_4nn_ctf_MPI
from utilities import bcast_EMData_to_all, bcast_number_to_all, model_blank
from fundamentals import rops_table, fftip, fft
import types
# Retrieve the function specific input arguments from ref_data
data = ref_data[0]
Tracker = ref_data[1]
iter = ref_data[2]
mpi_comm = ref_data[3]
# # For DEBUG
# print "Type of data %s" % (type(data))
# print "Type of Tracker %s" % (type(Tracker))
# print "Type of iter %s" % (type(iter))
# print "Type of mpi_comm %s" % (type(mpi_comm))
if(mpi_comm == None): mpi_comm = MPI_COMM_WORLD
myid = mpi_comm_rank(mpi_comm)
nproc = mpi_comm_size(mpi_comm)
try: local_filter = Tracker["local_filter"]
except: local_filter = False
#=========================================================================
# volume reconstruction
if( type(data) == types.ListType ):
if Tracker["constants"]["CTF"]:
vol = recons3d_4nn_ctf_MPI(myid, data, Tracker["constants"]["snr"], \
symmetry=Tracker["constants"]["sym"], npad=Tracker["constants"]["npad"], mpi_comm=mpi_comm, smearstep = Tracker["smearstep"])
else:
vol = recons3d_4nn_MPI (myid, data,\
symmetry=Tracker["constants"]["sym"], npad=Tracker["constants"]["npad"], mpi_comm=mpi_comm)
else:
vol = data
if myid == 0:
from morphology import threshold
from filter import filt_tanl, filt_btwl
from utilities import model_circle, get_im
import types
nx = vol.get_xsize()
if(Tracker["constants"]["mask3D"] == None):
mask3D = model_circle(int(Tracker["constants"]["radius"]*float(nx)/float(Tracker["constants"]["nnxo"])+0.5), nx, nx, nx)
elif(Tracker["constants"]["mask3D"] == "auto"):
from utilities import adaptive_mask
mask3D = adaptive_mask(vol)
else:
if( type(Tracker["constants"]["mask3D"]) == types.StringType ): mask3D = get_im(Tracker["constants"]["mask3D"])
else: mask3D = (Tracker["constants"]["mask3D"]).copy()
nxm = mask3D.get_xsize()
if( nx != nxm):
from fundamentals import rot_shift3D
mask3D = Util.window(rot_shift3D(mask3D,scale=float(nx)/float(nxm)),nx,nx,nx)
nxm = mask3D.get_xsize()
assert(nx == nxm)
stat = Util.infomask(vol, mask3D, False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0/stat[1])
vol = threshold(vol)
Util.mul_img(vol, mask3D)
if( Tracker["PWadjustment"] ):
from utilities import read_text_file, write_text_file
rt = read_text_file( Tracker["PWadjustment"] )
fftip(vol)
ro = rops_table(vol)
# Here unless I am mistaken it is enough to take the beginning of the reference pw.
for i in xrange(1,len(ro)): ro[i] = (rt[i]/ro[i])**Tracker["upscale"]
#write_text_file(rops_table(filt_table( vol, ro),1),"foo.txt")
if Tracker["constants"]["sausage"]:
ny = vol.get_ysize()
y = float(ny)
from math import exp
for i in xrange(len(ro)): ro[i] *= \
(1.0+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.10)/0.025)**2)+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.215)/0.025)**2))
if local_filter:
# skip low-pass filtration
vol = fft( filt_table( vol, ro) )
else:
if( type(Tracker["lowpass"]) == types.ListType ):
vol = fft( filt_table( filt_table(vol, Tracker["lowpass"]), ro) )
else:
vol = fft( filt_table( filt_tanl(vol, Tracker["lowpass"], Tracker["falloff"]), ro) )
del ro
else:
if Tracker["constants"]["sausage"]:
ny = vol.get_ysize()
y = float(ny)
ro = [0.0]*(ny//2+2)
from math import exp
for i in xrange(len(ro)): ro[i] = \
(1.0+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.10)/0.025)**2)+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.215)/0.025)**2))
fftip(vol)
filt_table(vol, ro)
del ro
if not local_filter:
if( type(Tracker["lowpass"]) == types.ListType ):
vol = filt_table(vol, Tracker["lowpass"])
else:
vol = filt_tanl(vol, Tracker["lowpass"], Tracker["falloff"])
if Tracker["constants"]["sausage"]: vol = fft(vol)
if local_filter:
from morphology import binarize
if(myid == 0): nx = mask3D.get_xsize()
else: nx = 0
nx = bcast_number_to_all(nx, source_node = 0)
# only main processor needs the two input volumes
if(myid == 0):
mask = binarize(mask3D, 0.5)
locres = get_im(Tracker["local_filter"])
lx = locres.get_xsize()
if(lx != nx):
if(lx < nx):
from fundamentals import fdecimate, rot_shift3D
mask = Util.window(rot_shift3D(mask,scale=float(lx)/float(nx)),lx,lx,lx)
vol = fdecimate(vol, lx,lx,lx)
else: ERROR("local filter cannot be larger than input volume","user function",1)
stat = Util.infomask(vol, mask, False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0/stat[1])
else:
lx = 0
locres = model_blank(1,1,1)
vol = model_blank(1,1,1)
lx = bcast_number_to_all(lx, source_node = 0)
if( myid != 0 ): mask = model_blank(lx,lx,lx)
bcast_EMData_to_all(mask, myid, 0, comm=mpi_comm)
from filter import filterlocal
vol = filterlocal( locres, vol, mask, Tracker["falloff"], myid, 0, nproc)
if myid == 0:
if(lx < nx):
from fundamentals import fpol
vol = fpol(vol, nx,nx,nx)
vol = threshold(vol)
vol = filt_btwl(vol, 0.38, 0.5)# This will have to be corrected.
Util.mul_img(vol, mask3D)
del mask3D
# vol.write_image('toto%03d.hdf'%iter)
else:
vol = model_blank(nx,nx,nx)
else:
if myid == 0:
#from utilities import write_text_file
#write_text_file(rops_table(vol,1),"goo.txt")
stat = Util.infomask(vol, mask3D, False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0/stat[1])
vol = threshold(vol)
vol = filt_btwl(vol, 0.38, 0.5)# This will have to be corrected.
Util.mul_img(vol, mask3D)
del mask3D
# vol.write_image('toto%03d.hdf'%iter)
# broadcast volume
bcast_EMData_to_all(vol, myid, 0, comm=mpi_comm)
#=========================================================================
return vol
def dovolume( ref_data ):
from utilities import print_msg, read_text_row
from filter import fit_tanh, filt_tanl
from fundamentals import fshift
from morphology import threshold
# Prepare the reference in 3D alignment, this function corresponds to what do_volume does.
# Input: list ref_data
# 0 - mask
# 1 - center flag
# 2 - raw average
# 3 - fsc result
# Output: filtered, centered, and masked reference image
# apply filtration (FSC) to reference image:
global ref_ali2d_counter
ref_ali2d_counter += 1
fl = ref_data[2].cmp("dot",ref_data[2], {"negative":0, "mask":ref_data[0]} )
print_msg("do_volume user function Step = %5d GOAL = %10.3e\n"%(ref_ali2d_counter,fl))
stat = Util.infomask(ref_data[2], ref_data[0], False)
vol = ref_data[2] - stat[0]
Util.mul_scalar(vol, 1.0/stat[1])
vol = threshold(vol)
#Util.mul_img(vol, ref_data[0])
try:
aa = read_text_row("flaa.txt")[0]
fl = aa[0]
aa=aa[1]
except:
fl = 0.4
aa = 0.2
msg = "Tangent filter: cut-off frequency = %10.3f fall-off = %10.3f\n"%(fl, aa)
print_msg(msg)
from utilities import read_text_file
from fundamentals import rops_table, fftip, fft
from filter import filt_table, filt_btwl
fftip(vol)
try:
rt = read_text_file( "pwreference.txt" )
ro = rops_table(vol)
# Here unless I am mistaken it is enough to take the beginning of the reference pw.
for i in xrange(1,len(ro)): ro[i] = (rt[i]/ro[i])**0.5
vol = fft( filt_table( filt_tanl(vol, fl, aa), ro) )
msg = "Power spectrum adjusted\n"
print_msg(msg)
except:
vol = fft( filt_tanl(vol, fl, aa) )
stat = Util.infomask(vol, ref_data[0], False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0/stat[1])
vol = threshold(vol)
vol = filt_btwl(vol, 0.38, 0.5)
Util.mul_img(vol, ref_data[0])
if ref_data[1] == 1:
cs = volf.phase_cog()
msg = "Center x = %10.3f Center y = %10.3f Center z = %10.3f\n"%(cs[0], cs[1], cs[2])
print_msg(msg)
volf = fshift(volf, -cs[0], -cs[1], -cs[2])
else: cs = [0.0]*3
return vol, cs
def image_decimate_window_xform_ctf(img,
decimation=2,
window_size=0,
CTF=False):
"""
Window 2D image to FFT-friendly size, apply Butterworth low pass filter,
and decimate image by integer factor
"""
from filter import filt_btwl
from fundamentals import smallprime, window2d
from utilities import get_image, get_params_proj, set_params_proj, get_ctf, set_ctf
if decimation == 1:
if window_size == 0:
return img
else:
[phi, theta, psi, tx, ty] = get_params_proj(img)
if CTF:
[
defocus, cs, voltage, pixel_size, bfactor, ampconst,
dfdiff, dfang
] = get_ctf(img)
new_params = [phi, theta, psi, tx / decimation, ty / decimation]
img = Util.window(img, window_size, window_size, 1, 0, 0, 0)
set_params_proj(img, new_params)
if CTF:
ctf_params = [
defocus, cs, voltage, pixel_size * decimation, bfactor,
ampconst, dfdiff, dfang
]
set_ctf(img, ctf_params)
return img
else:
nz = img.get_zsize()
if (nz > 1):
ERROR("This command works only for 2-D images", "image_decimate",
1)
if decimation <= 1:
ERROR("Improper decimation ratio", "image_decimate", 1)
[phi, theta, psi, tx, ty] = get_params_proj(img)
new_params = [phi, theta, psi, tx / decimation, ty / decimation]
if CTF:
[
defocus, cs, voltage, pixel_size, bfactor, ampconst, dfdiff,
dfang
] = get_ctf(img)
frequency_low = 0.5 / decimation - 0.02
if frequency_low <= 0:
ERROR("Butterworth passband frequency is too low",
"image_decimation", 1)
frequency_high = min(0.5 / decimation + 0.02, 0.499)
if window_size > 0:
img = Util.window(img, window_size, window_size, 1, 0, 0, 0)
e = filt_btwl(img, frequency_low, frequency_high)
decimated_image = Util.decimate(e, int(decimation), int(decimation), 1)
set_params_proj(decimated_image, new_params)
if CTF:
ctf_params = [
defocus, cs, voltage, pixel_size * decimation, bfactor,
ampconst, dfdiff, dfang
]
set_ctf(decimated_image, ctf_params)
return decimated_image
def do_volume_mrk02(ref_data):
"""
data - projections (scattered between cpus) or the volume. If volume, just do the volume processing
options - the same for all cpus
return - volume the same for all cpus
"""
from EMAN2 import Util
from mpi import mpi_comm_rank, mpi_comm_size, MPI_COMM_WORLD
from filter import filt_table
from reconstruction import recons3d_4nn_MPI, recons3d_4nn_ctf_MPI
from utilities import bcast_EMData_to_all, bcast_number_to_all, model_blank
from fundamentals import rops_table, fftip, fft
import types
# Retrieve the function specific input arguments from ref_data
data = ref_data[0]
Tracker = ref_data[1]
iter = ref_data[2]
mpi_comm = ref_data[3]
# # For DEBUG
# print "Type of data %s" % (type(data))
# print "Type of Tracker %s" % (type(Tracker))
# print "Type of iter %s" % (type(iter))
# print "Type of mpi_comm %s" % (type(mpi_comm))
if (mpi_comm == None): mpi_comm = MPI_COMM_WORLD
myid = mpi_comm_rank(mpi_comm)
nproc = mpi_comm_size(mpi_comm)
try:
local_filter = Tracker["local_filter"]
except:
local_filter = False
#=========================================================================
# volume reconstruction
if (type(data) == types.ListType):
if Tracker["constants"]["CTF"]:
vol = recons3d_4nn_ctf_MPI(myid, data, Tracker["constants"]["snr"], \
symmetry=Tracker["constants"]["sym"], npad=Tracker["constants"]["npad"], mpi_comm=mpi_comm, smearstep = Tracker["smearstep"])
else:
vol = recons3d_4nn_MPI (myid, data,\
symmetry=Tracker["constants"]["sym"], npad=Tracker["constants"]["npad"], mpi_comm=mpi_comm)
else:
vol = data
if myid == 0:
from morphology import threshold
from filter import filt_tanl, filt_btwl
from utilities import model_circle, get_im
import types
nx = vol.get_xsize()
if (Tracker["constants"]["mask3D"] == None):
mask3D = model_circle(
int(Tracker["constants"]["radius"] * float(nx) /
float(Tracker["constants"]["nnxo"]) + 0.5), nx, nx, nx)
elif (Tracker["constants"]["mask3D"] == "auto"):
from utilities import adaptive_mask
mask3D = adaptive_mask(vol)
else:
if (type(Tracker["constants"]["mask3D"]) == types.StringType):
mask3D = get_im(Tracker["constants"]["mask3D"])
else:
mask3D = (Tracker["constants"]["mask3D"]).copy()
nxm = mask3D.get_xsize()
if (nx != nxm):
from fundamentals import rot_shift3D
mask3D = Util.window(
rot_shift3D(mask3D, scale=float(nx) / float(nxm)), nx, nx,
nx)
nxm = mask3D.get_xsize()
assert (nx == nxm)
stat = Util.infomask(vol, mask3D, False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0 / stat[1])
vol = threshold(vol)
Util.mul_img(vol, mask3D)
if (Tracker["PWadjustment"]):
from utilities import read_text_file, write_text_file
rt = read_text_file(Tracker["PWadjustment"])
fftip(vol)
ro = rops_table(vol)
# Here unless I am mistaken it is enough to take the beginning of the reference pw.
for i in xrange(1, len(ro)):
ro[i] = (rt[i] / ro[i])**Tracker["upscale"]
#write_text_file(rops_table(filt_table( vol, ro),1),"foo.txt")
if Tracker["constants"]["sausage"]:
ny = vol.get_ysize()
y = float(ny)
from math import exp
for i in xrange(len(ro)): ro[i] *= \
(1.0+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.10)/0.025)**2)+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.215)/0.025)**2))
if local_filter:
# skip low-pass filtration
vol = fft(filt_table(vol, ro))
else:
if (type(Tracker["lowpass"]) == types.ListType):
vol = fft(
filt_table(filt_table(vol, Tracker["lowpass"]), ro))
else:
vol = fft(
filt_table(
filt_tanl(vol, Tracker["lowpass"],
Tracker["falloff"]), ro))
del ro
else:
if Tracker["constants"]["sausage"]:
ny = vol.get_ysize()
y = float(ny)
ro = [0.0] * (ny // 2 + 2)
from math import exp
for i in xrange(len(ro)): ro[i] = \
(1.0+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.10)/0.025)**2)+1.0*exp(-(((i/y/Tracker["constants"]["pixel_size"])-0.215)/0.025)**2))
fftip(vol)
filt_table(vol, ro)
del ro
if not local_filter:
if (type(Tracker["lowpass"]) == types.ListType):
vol = filt_table(vol, Tracker["lowpass"])
else:
vol = filt_tanl(vol, Tracker["lowpass"],
Tracker["falloff"])
if Tracker["constants"]["sausage"]: vol = fft(vol)
if local_filter:
from morphology import binarize
if (myid == 0): nx = mask3D.get_xsize()
else: nx = 0
nx = bcast_number_to_all(nx, source_node=0)
# only main processor needs the two input volumes
if (myid == 0):
mask = binarize(mask3D, 0.5)
locres = get_im(Tracker["local_filter"])
lx = locres.get_xsize()
if (lx != nx):
if (lx < nx):
from fundamentals import fdecimate, rot_shift3D
mask = Util.window(
rot_shift3D(mask, scale=float(lx) / float(nx)), lx, lx,
lx)
vol = fdecimate(vol, lx, lx, lx)
else:
ERROR("local filter cannot be larger than input volume",
"user function", 1)
stat = Util.infomask(vol, mask, False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0 / stat[1])
else:
lx = 0
locres = model_blank(1, 1, 1)
vol = model_blank(1, 1, 1)
lx = bcast_number_to_all(lx, source_node=0)
if (myid != 0): mask = model_blank(lx, lx, lx)
bcast_EMData_to_all(mask, myid, 0, comm=mpi_comm)
from filter import filterlocal
vol = filterlocal(locres, vol, mask, Tracker["falloff"], myid, 0,
nproc)
if myid == 0:
if (lx < nx):
from fundamentals import fpol
vol = fpol(vol, nx, nx, nx)
vol = threshold(vol)
vol = filt_btwl(vol, 0.38, 0.5) # This will have to be corrected.
Util.mul_img(vol, mask3D)
del mask3D
# vol.write_image('toto%03d.hdf'%iter)
else:
vol = model_blank(nx, nx, nx)
else:
if myid == 0:
#from utilities import write_text_file
#write_text_file(rops_table(vol,1),"goo.txt")
stat = Util.infomask(vol, mask3D, False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0 / stat[1])
vol = threshold(vol)
vol = filt_btwl(vol, 0.38, 0.5) # This will have to be corrected.
Util.mul_img(vol, mask3D)
del mask3D
# vol.write_image('toto%03d.hdf'%iter)
# broadcast volume
bcast_EMData_to_all(vol, myid, 0, comm=mpi_comm)
#=========================================================================
return vol
def dovolume(ref_data):
from utilities import print_msg, read_text_row
from filter import fit_tanh, filt_tanl
from fundamentals import fshift
from morphology import threshold
# Prepare the reference in 3D alignment, this function corresponds to what do_volume does.
# Input: list ref_data
# 0 - mask
# 1 - center flag
# 2 - raw average
# 3 - fsc result
# Output: filtered, centered, and masked reference image
# apply filtration (FSC) to reference image:
global ref_ali2d_counter
ref_ali2d_counter += 1
fl = ref_data[2].cmp("dot", ref_data[2], {
"negative": 0,
"mask": ref_data[0]
})
print_msg("do_volume user function Step = %5d GOAL = %10.3e\n" %
(ref_ali2d_counter, fl))
stat = Util.infomask(ref_data[2], ref_data[0], False)
vol = ref_data[2] - stat[0]
Util.mul_scalar(vol, 1.0 / stat[1])
vol = threshold(vol)
#Util.mul_img(vol, ref_data[0])
try:
aa = read_text_row("flaa.txt")[0]
fl = aa[0]
aa = aa[1]
except:
fl = 0.4
aa = 0.2
msg = "Tangent filter: cut-off frequency = %10.3f fall-off = %10.3f\n" % (
fl, aa)
print_msg(msg)
from utilities import read_text_file
from fundamentals import rops_table, fftip, fft
from filter import filt_table, filt_btwl
fftip(vol)
try:
rt = read_text_file("pwreference.txt")
ro = rops_table(vol)
# Here unless I am mistaken it is enough to take the beginning of the reference pw.
for i in xrange(1, len(ro)):
ro[i] = (rt[i] / ro[i])**0.5
vol = fft(filt_table(filt_tanl(vol, fl, aa), ro))
msg = "Power spectrum adjusted\n"
print_msg(msg)
except:
vol = fft(filt_tanl(vol, fl, aa))
stat = Util.infomask(vol, ref_data[0], False)
vol -= stat[0]
Util.mul_scalar(vol, 1.0 / stat[1])
vol = threshold(vol)
vol = filt_btwl(vol, 0.38, 0.5)
Util.mul_img(vol, ref_data[0])
if ref_data[1] == 1:
cs = volf.phase_cog()
msg = "Center x = %10.3f Center y = %10.3f Center z = %10.3f\n" % (
cs[0], cs[1], cs[2])
print_msg(msg)
volf = fshift(volf, -cs[0], -cs[1], -cs[2])
else:
cs = [0.0] * 3
return vol, cs