def filterlocal(ui, vi, m, falloff, myid, main_node, number_of_proc):
if myid == main_node:
nx = vi.get_xsize()
ny = vi.get_ysize()
nz = vi.get_zsize()
# Round all resolution numbers to two digits
for x in range(nx):
for y in range(ny):
for z in range(nz):
ui.set_value_at_fast(x, y, z, round(ui.get_value_at(x, y, z), 2))
dis = [nx, ny, nz]
else:
falloff = 0.0
radius = 0
dis = [0, 0, 0]
falloff = sp_utilities.bcast_number_to_all(falloff, main_node)
dis = sp_utilities.bcast_list_to_all(dis, myid, source_node=main_node)
if myid != main_node:
nx = int(dis[0])
ny = int(dis[1])
nz = int(dis[2])
vi = sp_utilities.model_blank(nx, ny, nz)
ui = sp_utilities.model_blank(nx, ny, nz)
sp_utilities.bcast_EMData_to_all(vi, myid, main_node)
sp_utilities.bcast_EMData_to_all(ui, myid, main_node)
sp_fundamentals.fftip(vi) # volume to be filtered
st = EMAN2_cppwrap.Util.infomask(ui, m, True)
filteredvol = sp_utilities.model_blank(nx, ny, nz)
cutoff = max(st[2] - 0.01, 0.0)
while cutoff < st[3]:
cutoff = round(cutoff + 0.01, 2)
# if(myid == main_node): print cutoff,st
pt = EMAN2_cppwrap.Util.infomask(
sp_morphology.threshold_outside(ui, cutoff - 0.00501, cutoff + 0.005),
m,
True,
) # Ideally, one would want to check only slices in question...
if pt[0] != 0.0:
# print cutoff,pt[0]
vovo = sp_fundamentals.fft(filt_tanl(vi, cutoff, falloff))
for z in range(myid, nz, number_of_proc):
for x in range(nx):
for y in range(ny):
if m.get_value_at(x, y, z) > 0.5:
if round(ui.get_value_at(x, y, z), 2) == cutoff:
filteredvol.set_value_at_fast(
x, y, z, vovo.get_value_at(x, y, z)
)
mpi.mpi_barrier(mpi.MPI_COMM_WORLD)
sp_utilities.reduce_EMData_to_root(filteredvol, myid, main_node, mpi.MPI_COMM_WORLD)
return filteredvol
def main():
arglist = []
for arg in sys.argv:
arglist.append(arg)
progname = optparse.os.path.basename(arglist[0])
usage = progname + """ inputvolume locresvolume maskfile outputfile --radius --falloff --MPI
Locally filer a volume based on local resolution volume (sxlocres.py) within area outlined by the maskfile
"""
parser = optparse.OptionParser(usage, version=sp_global_def.SPARXVERSION)
parser.add_option(
"--radius",
type="int",
default=-1,
help=
"if there is no maskfile, sphere with r=radius will be used, by default the radius is nx/2-1"
)
parser.add_option("--falloff",
type="float",
default=0.1,
help="falloff of tanl filter (default 0.1)")
parser.add_option("--MPI",
action="store_true",
default=False,
help="use MPI version")
(options, args) = parser.parse_args(arglist[1:])
if len(args) < 3 or len(args) > 4:
sp_global_def.sxprint("See usage " + usage)
sp_global_def.ERROR(
"Wrong number of parameters. Please see usage information above.")
return
if sp_global_def.CACHE_DISABLE:
pass #IMPORTIMPORTIMPORT from sp_utilities import disable_bdb_cache
sp_utilities.disable_bdb_cache()
if options.MPI:
number_of_proc = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD)
myid = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD)
main_node = 0
if (myid == main_node):
#print sys.argv
vi = sp_utilities.get_im(sys.argv[1])
ui = sp_utilities.get_im(sys.argv[2])
#print Util.infomask(ui, None, True)
radius = options.radius
nx = vi.get_xsize()
ny = vi.get_ysize()
nz = vi.get_zsize()
dis = [nx, ny, nz]
else:
falloff = 0.0
radius = 0
dis = [0, 0, 0]
vi = None
ui = None
dis = sp_utilities.bcast_list_to_all(dis, myid, source_node=main_node)
if (myid != main_node):
nx = int(dis[0])
ny = int(dis[1])
nz = int(dis[2])
radius = sp_utilities.bcast_number_to_all(radius, main_node)
if len(args) == 3:
if (radius == -1):
radius = min(nx, ny, nz) // 2 - 1
m = sp_utilities.model_circle(radius, nx, ny, nz)
outvol = args[2]
elif len(args) == 4:
if (myid == main_node):
m = sp_morphology.binarize(sp_utilities.get_im(args[2]), 0.5)
else:
m = sp_utilities.model_blank(nx, ny, nz)
outvol = args[3]
sp_utilities.bcast_EMData_to_all(m, myid, main_node)
pass #IMPORTIMPORTIMPORT from sp_filter import filterlocal
filteredvol = sp_filter.filterlocal(ui, vi, m, options.falloff, myid,
main_node, number_of_proc)
if (myid == 0):
filteredvol.write_image(outvol)
else:
vi = sp_utilities.get_im(args[0])
ui = sp_utilities.get_im(
args[1]
) # resolution volume, values are assumed to be from 0 to 0.5
nn = vi.get_xsize()
falloff = options.falloff
if len(args) == 3:
radius = options.radius
if (radius == -1):
radius = nn // 2 - 1
m = sp_utilities.model_circle(radius, nn, nn, nn)
outvol = args[2]
elif len(args) == 4:
m = sp_morphology.binarize(sp_utilities.get_im(args[2]), 0.5)
outvol = args[3]
sp_fundamentals.fftip(vi) # this is the volume to be filtered
# Round all resolution numbers to two digits
for x in range(nn):
for y in range(nn):
for z in range(nn):
ui.set_value_at_fast(x, y, z,
round(ui.get_value_at(x, y, z), 2))
st = EMAN2_cppwrap.Util.infomask(ui, m, True)
filteredvol = sp_utilities.model_blank(nn, nn, nn)
cutoff = max(st[2] - 0.01, 0.0)
while (cutoff < st[3]):
cutoff = round(cutoff + 0.01, 2)
pt = EMAN2_cppwrap.Util.infomask(
sp_morphology.threshold_outside(ui, cutoff - 0.00501,
cutoff + 0.005), m, True)
if (pt[0] != 0.0):
vovo = sp_fundamentals.fft(
sp_filter.filt_tanl(vi, cutoff, falloff))
for x in range(nn):
for y in range(nn):
for z in range(nn):
if (m.get_value_at(x, y, z) > 0.5):
if (round(ui.get_value_at(x, y, z),
2) == cutoff):
filteredvol.set_value_at_fast(
x, y, z, vovo.get_value_at(x, y, z))
sp_global_def.write_command(optparse.os.path.dirname(outvol))
filteredvol.write_image(outvol)
def filterlocal(ui, vi, m, falloff, myid, main_node, number_of_proc): from mpi import mpi_init, mpi_comm_size, mpi_comm_rank, MPI_COMM_WORLD from mpi import mpi_reduce, mpi_bcast, mpi_barrier, mpi_gatherv, mpi_send, mpi_recv from mpi import MPI_SUM, MPI_FLOAT, MPI_INT from sp_utilities import bcast_number_to_all, bcast_list_to_all, model_blank, bcast_EMData_to_all, reduce_EMData_to_root from sp_morphology import threshold_outside from sp_filter import filt_tanl from sp_fundamentals import fft, fftip if(myid == main_node): nx = vi.get_xsize() ny = vi.get_ysize() nz = vi.get_zsize() # Round all resolution numbers to two digits for x in range(nx): for y in range(ny): for z in range(nz): ui.set_value_at_fast( x,y,z, round(ui.get_value_at(x,y,z), 2) ) dis = [nx,ny,nz] else: falloff = 0.0 radius = 0 dis = [0,0,0] falloff = bcast_number_to_all(falloff, main_node) dis = bcast_list_to_all(dis, myid, source_node = main_node) if(myid != main_node): nx = int(dis[0]) ny = int(dis[1]) nz = int(dis[2]) vi = model_blank(nx,ny,nz) ui = model_blank(nx,ny,nz) bcast_EMData_to_all(vi, myid, main_node) bcast_EMData_to_all(ui, myid, main_node) fftip(vi) # volume to be filtered st = Util.infomask(ui, m, True) filteredvol = model_blank(nx,ny,nz) cutoff = max(st[2] - 0.01,0.0) while(cutoff < st[3] ): cutoff = round(cutoff + 0.01, 2) #if(myid == main_node): print cutoff,st pt = Util.infomask( threshold_outside(ui, cutoff - 0.00501, cutoff + 0.005), m, True) # Ideally, one would want to check only slices in question... if(pt[0] != 0.0): #print cutoff,pt[0] vovo = fft( filt_tanl(vi, cutoff, falloff) ) for z in range(myid, nz, number_of_proc): for x in range(nx): for y in range(ny): if(m.get_value_at(x,y,z) > 0.5): if(round(ui.get_value_at(x,y,z),2) == cutoff): filteredvol.set_value_at_fast(x,y,z,vovo.get_value_at(x,y,z)) mpi_barrier(MPI_COMM_WORLD) reduce_EMData_to_root(filteredvol, myid, main_node, MPI_COMM_WORLD) return filteredvol
def cml_open_proj(stack, ir, ou, lf, hf, dpsi=1):
from sp_projection import cml_sinogram
from sp_utilities import model_circle, get_params_proj, model_blank, get_im
from sp_fundamentals import fftip
from sp_filter import filt_tanh
# number of projections
if type(stack) == type(""): nprj = EMUtil.get_image_count(stack)
else: nprj = len(stack)
Prj = [] # list of projections
Ori = [
-1
] * 4 * nprj # orientation intial (phi, theta, psi, index) for each projection
for i in range(nprj):
image = get_im(stack, i)
# read initial angles if given
try:
Ori[4 * i], Ori[4 * i +
1], Ori[4 * i +
2], s2x, s2y = get_params_proj(image)
except:
pass
if (i == 0):
nx = image.get_xsize()
if (ou < 1): ou = nx // 2 - 1
diameter = int(2 * ou)
mask2D = model_circle(ou, nx, nx)
if ir > 0: mask2D -= model_circle(ir, nx, nx)
# normalize under the mask
[mean_a, sigma, imin, imax] = Util.infomask(image, mask2D, True)
image -= mean_a
Util.mul_scalar(image, 1.0 / sigma)
Util.mul_img(image, mask2D)
# sinogram
sino = cml_sinogram(image, diameter, dpsi)
# prepare the cut positions in order to filter (lf: low freq; hf: high freq)
ihf = min(int(2 * hf * diameter), diameter + (diameter + 1) % 2)
ihf = ihf + (ihf + 1) % 2 # index ihf must be odd to take the img part
ilf = max(int(2 * lf * diameter), 0)
ilf = ilf + ilf % 2 # index ilf must be even to fall in the real part
bdf = ihf - ilf + 1
# process lines
nxe = sino.get_xsize()
nye = sino.get_ysize()
prj = model_blank(bdf, 2 * nye)
pp = model_blank(nxe, 2 * nye)
for li in range(nye):
# get the line li
line = Util.window(sino, nxe, 1, 1, 0, li - nye // 2, 0)
# u2 (not improve the results)
#line = filt_tanh(line, ou / float(nx), ou / float(nx))
# normalize this line
[mean_l, sigma_l, imin, imax] = Util.infomask(line, None, True)
line = (line - mean_l) / sigma_l
# fft
fftip(line)
# filter (cut part of coef) and create mirror line
Util.cml_prepare_line(prj, line, ilf, ihf, li, nye)
# store the projection
Prj.append(prj)
return Prj, Ori