def setup_nn4(image_size, npad=2, sym='c1', weighting=1, **extra):
''' Initalize a reconstruction object
:Parameters:
image_size : int
Size of the input image and output volume
npad : int, optional
Number of times to pad the input image, default: 2
sym : str, optional
Type of symmetry, default: 'c1'
weighting : int
Amount of weight to give projections
:Returns:
recon : tuple
Reconstructor, Fourier volume, Weight Volume, and numpy versions
'''
if EMAN2 is None:
raise ImportError, "EMAN2/Sparx library not available, setup_nn4 requires EMAN2/Sparx"
fftvol = EMAN2.EMData()
weight = EMAN2.EMData()
param = {
"size": image_size,
"npad": npad,
"symmetry": sym,
"weighting": weighting,
"fftvol": fftvol,
"weight": weight
}
r = EMAN2.Reconstructors.get("nn4", param)
r.setup()
return (r, fftvol, weight), em2numpy(fftvol), em2numpy(weight), image_size
def localali(im1, im2, psref, maxdx):
"""Takes an fft.amplitude() psref to use as a basis for optimal alignment. Exhaustive search +-maxdx pixels.
returns (dx,dy) required to bring im2 into alignment with im1"""
nx = im1["nx"]
mask = EMAN2.EMData(nx, nx, 1)
mask.to_one()
mask.process_inplace("mask.gaussian", {
"inner_radius": nx / 4,
"outer_radius": nx / 12
})
# EMAN2.display(mask)
maxdx = int(maxdx)
out = EMAN2.EMData(2 * maxdx + 1, 2 * maxdx + 1, 1)
for dx in xrange(-maxdx, maxdx + 1):
for dy in xrange(-maxdx, maxdx + 1):
av = im1 + im2.process("xform.translate.int",
{"trans": (dx, dy, 0)})
av.mult(
mask
) # to prevent edge effects and slightly smooth the powspec
avf = av.do_fft()
avf.ri2ap()
avf = avf.amplitude()
out[dx + maxdx, dy + maxdx] = avf.cmp("ccc", psref)
# print dx,dy,out[dx+20,dy+20]
ret = out.calc_max_location()
return (int(ret[0] - maxdx), int(ret[1] - maxdx)), out
def do_dataset(names):
'''
Supposing we have marked data laying in folder data,
in two subfolders 'good' and 'ice' and only this way.
For now way of keeping data is hardcoded.
#TODO:Make set creator more flexible.
So we got list of full paths to mrc files lying in both direcories.
Func assembles dataset,labels encoding dictionary
matching classifier labels to words 'good' and 'ice' and
returning it.
Args:
names - list of full paths to mrc files lying in a directories
as described above.
returns: dataset(list of feature vectors)
labels(list of labels)
encoding_dict dictionary via label:label_name.
'''
labels = [name.split('/')[-2] for name in names]
labels = np.array(labels)
ice_mask = labels == 'ice'
good_mask = labels == 'good'
names = np.array(names)
ice_names = names[ice_mask]
good_names = names[good_mask]
good_labels = [0] * len(good_names)
ice_labels = [1] * len(good_names)
encoding_dict = {0: 'good', 1: 'ice'}
goods = []
ices = []
for name in good_names:
img = EMAN2.EMData(name, 0)
img_np = EMAN2.EMNumPy.em2numpy(img)
sample = ft.preprocess_img(img_np)
goods.append(sample)
for name in ice_names:
img = EMAN2.EMData(name, 0)
img_np = EMAN2.EMNumPy.em2numpy(img)
sample = ft.preprocess_img(img_np)
ices.append(sample)
dataset = goods + ices
labels = good_labels + ice_labels
return dataset, labels, encoding_dict
def _build(self, index):
'''Build a single image in the file.'''
# print "...index:", index
header = {}
# Read the header
img = EMAN2.EMData()
img.read_image(self.workfile, 0, True)
h = img.get_attr_dict()
# Copy basic header information
header['nx'] = h['nx']
header['ny'] = h['ny']
header['nz'] = h['nz']
header['slices'] = []
if header['nz'] == 1:
# 2D Image
img2 = EMAN2.EMData()
img2.read_image(self.workfile, index, False)
img2.process_inplace("normalize")
if self.nimg > 1:
# ... stack of 2D images.
header['slices'].append(
self.build_slice(img2, index=index, fixed=[128, 512,
1024]))
else:
# regular old 2D image -- also generate power spectrum and tiles.
header['slices'].append(
self.build_slice(img2,
index=index,
tile=True,
pspec=True,
fixed=[128, 512, 1024]))
else:
# 3D Image -- read region for each Z slice
for i in range(header['nz']):
region = EMAN2.Region(0, 0, i, header['nx'], header['ny'], 1)
img2 = EMAN2.EMData()
img2.read_image(self.workfile, 0, False, region)
header['slices'].append(
self.build_slice(img2,
index=index,
nz=i,
fixed=[128, 512, 1024]))
return header
def convert(self, name, format, normalize=False):
import EMAN2
if format not in [
'tif', 'tiff', 'tif8', 'mrc', 'hdf', 'jpg', 'jpeg', 'png'
]:
raise ValueError, "Invalid format: %s" % format
depth = None
if format in ['tif8']:
depth = 8
format = 'tif'
bdo = self.db.binary.get(name)
img = EMAN2.EMData()
img.read_image(str(bdo.filepath))
if normalize:
img.process_inplace("normalize")
outfile = tempfile.NamedTemporaryFile(delete=False,
suffix='.%s' % format)
if depth == 8:
img['render_min'] = -1
img['render_max'] = 256
img.write_image(str(outfile.name), -1,
EMAN2.EMUtil.ImageType.IMAGE_UNKNOWN, False, None,
EMAN2.EMUtil.EMDataType.EM_UCHAR, False)
else:
img.write_image(str(outfile.name))
filename = os.path.splitext(bdo.filename)[0]
filename = '%s.%s' % (filename, format)
return filename, outfile.name
def preload_images(micrographs, img_buffer):
'''
Preloads IMG_BUFFER_SIZE number of images into the memory.
:param micrographs: list of all micrographs
:param img_buffer: deque as buffer for images
:return: None
'''
while True:
index = GUI.fileList.row(GUI.fileList.currentItem())
max_index = index + IMG_BUFFER_SIZE + 1
if max_index > len(micrographs):
max_index = len(micrographs)
should_be_inside = set(range(index + 1, max_index))
is_inside = set([tuble[1] for tuble in img_buffer])
load = should_be_inside - is_inside
if len(img_buffer) == 0:
load.add(index)
for index_to_load in load:
filename = str(micrographs[index_to_load])
image = EMAN2.EMData(filename)
fft_img = image.do_fft()
fft_img.set_value_at(0, 0, 0, 0)
fft_img.set_value_at(1, 0, 0, 0)
fft_img.process_inplace("xform.phaseorigin.tocorner")
fft_img.process_inplace("xform.fourierorigin.tocenter")
fft_img = fft_img.get_fft_amplitude()
img_buffer.append((filename, index_to_load, image, fft_img))
print("Put new image:", filename)
time.sleep(1)
'''
def numpy2em(im, e=None):
'''Convert NumPy array to an EMAN2 image object
This convenience method converts a numpy.ndarray object into an EMAN2.EMData
.. sourcecode:: py
>>> from core.image.eman2_utility import *
>>> ar = numpy.zeros((2,2))
>>> numpy2em(ar)
<libpyEMData2.EMData object at 0xdd61b0>
:Parameters:
img : numpy.ndarray
A numpy array
:Returns:
return_val : EMAN2.EMData
An EMAN2 image object
'''
if EMAN2 is None:
raise ImportError, "EMAN2/Sparx library not available, numpy2em requires EMAN2/Sparx"
try:
im = numpy.require(im, numpy.float32)
if e is None: e = EMAN2.EMData()
EMAN2.EMNumPy.numpy2em(im, e)
return e
except:
return EMAN2.EMNumPy.numpy2em(im)
def create_particle_stack(particle_stack, output_dir, particle_data):
"""
Create a mrcs particle stack based on the bdb/hdf input stack.
Arguments:
particle_stack - Particle stack name
output_dir - Output directory
particle_data - Particle_data array
Returns:
None
"""
print('|_Get particle ID and particle names')
ptcl_ids = [
int(entry.split('@')[0]) for entry in particle_data['_rlnImageName']
]
ptcl_names = [
entry.split('@')[1] for entry in particle_data['_rlnImageName']
]
print('|_Write images')
for particle_idx in range(particle_data.shape[0]):
if particle_idx % 10000 == 0:
print(particle_idx, ' of ', particle_data.shape[0])
emdata = EMAN2.EMData(particle_stack, particle_idx)
output_name = os.path.join(output_dir, ptcl_names[particle_idx])
try:
os.makedirs(os.path.dirname(output_name))
except OSError:
pass
emdata.write_image(output_name, -1)
def backproject_nn4_new(img, align=None, recon=None, **extra):
''' Add the given image and alignment or generator of image/alignment pairs
to the current reconstruction
:Parameters:
img : array or EMData
Image of projection to backproject into reconstruction
align : array, optional
Array of alignment parameters (not required if img is generator of images and alignments)
recon : tuple
Reconstructor, Fourier volume, Weight Volume, and numpy versions
extra : dict
Keyword arguments to be passed to setup_nn4 if recon is None
:Returns:
recon : tuple
Reconstructor, Fourier volume, Weight Volume, and numpy versions
'''
if EMAN2 is None:
raise ImportError, "EMAN2/Sparx library not available, backproject_nn4_new requires EMAN2/Sparx"
npad, sym, weighting = extra.get('npad', 2), extra.get('sym',
'c1'), extra.get(
'weighting', 1)
e = EMAN2.EMData()
if not hasattr(img, 'ndim'):
for i, val in img:
a = align[i]
'''
if a[4] != (i+1):
_logger.error("mismatch: %d != %d -- %s"%(a[4], i+1, str(align[:5])))
assert(a[4]==(i+1))
'''
xform_proj = EMAN2.Transform({
"type": "spider",
"phi": a[2],
"theta": a[1],
"psi": a[0]
})
if not is_em(val): val = numpy2em(val, e)
if recon is None:
recon = setup_nn4(val.get_xsize(), npad, sym, weighting)
recon[0][0].insert_slice(val, xform_proj)
else:
xform_proj = EMAN2.Transform({
"type": "spider",
"phi": align[2],
"theta": align[1],
"psi": align[0]
})
if not is_em(img): img = numpy2em(img)
if recon is None:
recon = setup_nn4(val.get_xsize(), npad, sym, weighting)
recon[0][0].insert_slice(img, xform_proj)
val1 = recon[1].copy()
val2 = recon[2].copy()
return val1, val2
def loadMicrographsFromItemList(self, image_index):
"""creates an EMImage-Widget"""
if self.current_image is None:
image_path = itemName[image_index]
self.current_image = EMAN2.EMData(image_path)
self.micrograph.set_data(
self.current_image
) # in project descriptopn as 'aaa' instead of 'micrograph'
def createComponents(self):
self.buttonLoad = QPushButton('Load')
self.buttonSave = QPushButton('Save')
self.buttonKeep = QPushButton('Keep (Right arrow key)')
self.buttonKeep.setStyleSheet('QPushButton {color: green;}')
self.buttonDiscard = QPushButton('Discard (Left arrow key)')
self.buttonDiscard.setStyleSheet('QPushButton {color: red;}')
self.fileList = QListWidget()
self.micrograph = emimage2d.EMImage2DWidget(image=EMAN2.EMData(
700, 700),
application=app,
parent=self)
self.powerSpectrum = emimage2d.EMImage2DWidget(image=EMAN2.EMData(
700, 700),
application=app,
parent=self)
self.all_items = []
def writeParticles():
line = sys.stdin.readline()
fnHdf = ""
while line:
objDict = json.loads(line)
index = int(objDict['_index'])
filename = str(objDict['_filename'])
imageData = eman.EMData()
imageData.read_image(filename, index)
if '_ctfModel._defocusU' in objDict:
ctf = eman.EMAN2Ctf()
defU = objDict['_ctfModel._defocusU']
defV = objDict['_ctfModel._defocusV']
ctf.from_dict({"defocus": (defU + defV) / 20000.0,
"dfang": objDict['_ctfModel._defocusAngle'],
"dfdiff": (defU - defV) / 10000.0,
"voltage": objDict['_acquisition._voltage'],
"cs": max(objDict['_acquisition._sphericalAberration'], 0.0001),
"ampcont": objDict['_acquisition._amplitudeContrast'] * 100.0,
"apix": objDict['_samplingRate']})
imageData.set_attr('ctf', ctf)
imageData.set_attr('apix_x', objDict['_samplingRate'])
imageData.set_attr('apix_y', objDict['_samplingRate'])
transformation = None
if '_angles' in objDict:
# TODO: convert to vector not matrix
angles = objDict['_angles']
shifts = objDict['_shifts']
transformation = eman.Transform({"type": "spider",
"phi": angles[0],
"theta": angles[1],
"psi": angles[2],
"tx": -shifts[0],
"ty": -shifts[1],
"tz": -shifts[2],
"mirror": 0, # TODO: test flip
"scale": 1.0})
if transformation is not None:
imageData.set_attr('xform.projection', transformation)
outputFile = str(objDict['hdfFn'])
if outputFile != fnHdf:
i = 0
fnHdf = outputFile
imageData.write_image(outputFile, i,
eman.EMUtil.ImageType.IMAGE_HDF, False)
i += 1
print("OK") # it is necessary to add newline
sys.stdout.flush()
line = sys.stdin.readline()
def emdata_header(self):
"""Get header information from EMAN2."""
if not EMAN2:
return
# EMAN2 only works with str filenames; no unicode.
img = EMAN2.EMData()
img.read_image(str(self.filename), 0, True)
header = img.get_attr_dict()
return header
def backproject_nn4_queue(qin,
qout,
shmem,
shape,
process_limit,
process_number,
align=None,
**extra):
''' Add the given image and alignment or generator of image/alignment pairs
to the current reconstruction
:Parameters:
img : array or EMData
Image of projection to backproject into reconstruction
align : array, optional
Array of alignment parameters (not required if img is generator of images and alignments)
recon : tuple
Reconstructor, Fourier volume, Weight Volume, and numpy versions
extra : dict
Keyword arguments to be passed to setup_nn4 if recon is None
:Returns:
recon : tuple
Reconstructor, Fourier volume, Weight Volume, and numpy versions
'''
if EMAN2 is None:
raise ImportError, "EMAN2/Sparx library not available, backproject_nn4_queue requires EMAN2/Sparx"
npad, sym, weighting = extra.get('npad', 2), extra.get('sym',
'c1'), extra.get(
'weighting', 1)
e = EMAN2.EMData()
recon = None
while True:
pos = qin.get()
if pos is None or pos[0] == -1:
if hasattr(qin, "task_done"): qin.task_done()
break
pos, idx = pos
a = align[idx]
img = shmem[pos].reshape(shape)
xform_proj = EMAN2.Transform({
"type": "spider",
"phi": a[2],
"theta": a[1],
"psi": a[0]
})
if not is_em(img): img = numpy2em(img, e)
if recon is None:
recon = setup_nn4(img.get_xsize(), npad, sym, weighting)
recon[0][0].insert_slice(img, xform_proj)
qout.put((process_number, idx))
return recon[0], recon[1], recon[2]
def read_particle(path, index, header_only=False):
"""
Reads single particle from stack.
:param path: Stack from path
:param index: Index of the particle in the stack
:param header_only: If true, only the header information will be read
:return: 2D particle image
"""
particle_image = EMAN2.EMData()
particle_image.read_image(path, index, header_only)
return particle_image
def stackToHDF(infile, outfile, apix, pinfo=None):
"""
convert stack to an hdf stack
pinfo contains CTF information from apFrealign.getPerParticleCTF
pinfo may also contain helical information
"""
from utilities import generate_ctf
a = EMAN2.EMData()
imn = EMAN2.EMUtil.get_image_count(infile)
if pinfo is not None:
if len(pinfo) != imn:
apDisplay.printError("insufficient particle info for stack")
# output must end with hdf
outf, ext = os.path.splitext(outfile)
if ext != '.hdf':
outstack = outf + ".hdf"
apDisplay.printMsg("Generating '%s' with %i particles" % (outstack, imn))
for i in xrange(imn):
a.read_image(infile, i)
a.set_attr_dict({'active': 1})
t2 = EMAN2.Transform({
"type": "spider",
"phi": 0,
"theta": 0,
"psi": 0
})
a.set_attr("xform.projection", t2)
a.set_attr("apix_x", apix)
if pinfo is not None:
pdata = pinfo[i + 1]
df1 = pdata['df1']
df2 = pdata['df2']
astig = pdata['angastig']
kv = pdata['kev']
cs = pdata['cs']
ampc = pdata['ampc'] * 100
# save CTF dict (bfactor is hard coded to 0.0)
df = (float(df1) + float(df2)) / 2
ctfgen = generate_ctf([df, cs, kv, apix, 0.0, ampc])
a.set_attr("ctf", ctfgen)
# if helical info is present
if pdata['hnum'] is not None:
a.set_attr("h_angle", pdata['hangle'])
a.write_image(outstack, i)
return outstack
def readstack(n):
"read the data for the nth particle. Return ref,ptclframes,psref"
ref=EMAN2.EMData("tmp2.hdf",n*33)
ptcls=EMAN2.EMData.read_images("tmp2.hdf",list(range(n*33+1,(n+1)*33)))
ctfim=ref.do_fft()
ctf=ref["ctf"]
ctf.compute_2d_complex(ctfim,EMAN2.Ctf.CtfType.CTF_POWEVAL)
ctfim.ri2ap()
ctfim=ctfim.amplitude()
# ctfim.process_inplace("normalize")
return ref,ptcls,ctfim
def check_output_format(input_var, filename):
out_data_3d = EMAN2.EMData(10, 10, 10)
out_data_3d += 1
try:
out_data_3d.write_image("test_" + filename)
except Exception as e:
msg = "The parameter '" + input_var + "' has a not valid extension or the file is not writable. Actual namefile is: '" + filename
sp_global_def.ERROR(msg, action=1)
return False
# i cannot just remove it because in case of multiple cpu use it could crash
try:
os.remove("test_" + filename)
except Exception as useless_e:
pass
return True
def preload_images(self, micrograph_list, img_buffer):
"""
Preloads IMG_BUFFER_SIZE number of images into the memory.
:param micrograph_list: list of all micrographs ######## mistake --> here it gets just a string not a list
:param img_buffer: deque as buffer for images
:return: None
"""
print("preload_images micrograph_list", micrograph_list)
offset = 0
last_index = -1
while True:
index = self.fileList.row(self.fileList.currentItem())
if last_index != -1:
if index - last_index == 1:
offset = offset - 1
elif index - last_index != 0:
offset = 0
if len(img_buffer) < IMG_BUFFER_SIZE and (
index + offset) < len(micrograph_list):
start = time.time()
print("in", index + offset)
print("micrograph_list", micrograph_list)
filename = str(micrograph_list[index + offset])
print("filename", filename)
image = EMAN2.EMData(filename)
fft_img = image.do_fft()
fft_img.set_value_at(0, 0, 0, 0)
fft_img.set_value_at(1, 0, 0, 0)
fft_img.process_inplace("xform.phaseorigin.tocorner")
fft_img.process_inplace("xform.fourierorigin.tocenter")
fft_img = fft_img.get_fft_amplitude()
img_buffer.append((filename, index + offset, image, fft_img))
end = time.time()
print("Put new image:", filename, "Current index", index,
"Image+offset:", index + offset, "offset", offset,
"time", end - start)
offset = offset + 1
else:
time.sleep(1)
last_index = index
def create_raw_hdf(self, outfile):
# This is a very expensive process and may take a while.
# This runs in the main thread :( Blocks the UI. Must fix.
files = self.find('RawImage')
if not files:
return
self.log("Creating raw HDF with %s frames: %s" % (len(files), outfile))
outfile = str(outfile)
# Sort the raw frames
files = sorted(files,
key=lambda x: int(x.split("_")[-1].split(".")[0]))
for f in files:
f = str(f)
self.log("Adding %s to raw HDF" % (os.path.basename(f)))
e = EMAN2.EMData()
e.read_image(f)
e['render_min'] = -1
e['render_max'] = 256 * 256
e.write_image(outfile, -1, EMAN2.EMUtil.ImageType.IMAGE_HDF, False,
None, EMAN2.EMUtil.EMDataType.EM_USHORT, False)
def import_particle_stack(particle_stack, output_dir):
"""
Import the particle stack.
Arguments:
particle_stack - Path to the particle stack
Returns:
Particle array
"""
particle_header = EMAN2.EMData()
particle_header.read_image(particle_stack, 0, True)
dtype_list, name_list = create_stack_dtype(particle_header.get_attr_dict())
header_dict = {}
for name in name_list:
header_dict[name] = np.array(
EMAN2.EMUtil.get_all_attributes(particle_stack, name))
stack_array, create_stack = create_stack_array(dtype_list, header_dict,
output_dir)
return stack_array, create_stack
def classify_by_names(names, model):
'''
With a given sklearn model and list of paths to mrc files
predicts label for each name
Args:
names - list of paths to mrc files
model - sklearn model instance.
(should predict classes not probabilities)
returns - dict like name:label
'''
samples = []
for name in names:
img = EMAN2.EMData(name, 0)
img_np = EMAN2.EMNumPy.em2numpy(img)
sample = ft.preprocess_img(img_np)
samples.append(sample)
preds = model.predict(samples)
names_preds_dict = {name: label for name, label in zip(names, preds)}
return names_preds_dict
def writeParticles():
line = sys.stdin.readline()
fnHdf = ""
while line:
#for line in sys.stdin:
objDict=json.loads(line)
###imgId, index, filename = line.split()
if '_index' in objDict.keys():
index = int(objDict['_index'])
if '_filename' in objDict.keys():
filename = str(objDict['_filename'])
else:
raise Exception('ERROR (e2converter): Cannot process a particle without filename')
imageData = eman.EMData()
imageData.read_image(filename, index)
ctf = None
if '_ctfModel._defocusU' in objDict.keys():
ctf = eman.EMAN2Ctf()
defU = objDict['_ctfModel._defocusU']
defV = objDict['_ctfModel._defocusV']
ctf.from_dict({"defocus": (defU + defV)/20000.0,
"dfang": objDict['_ctfModel._defocusAngle'],
"dfdiff": (defU - defV)/10000.0,
"voltage": objDict['_acquisition._voltage'],
"cs": objDict['_acquisition._sphericalAberration'],
"ampcont": objDict['_acquisition._amplitudeContrast'] * 100.0,
"apix": objDict['_samplingRate']})
imageData.set_attr('ctf', ctf)
transformation = None
if '_angles' in objDict.keys():
#TODO: convert to vector not matrix
angles = objDict['_angles']
shifts = objDict['_shifts']
transformation = eman.Transform({"type": "spider",
"phi": angles[0],
"theta": angles[1],
"psi": angles[2],
"tx": shifts[0],
"ty": shifts[1],
"tz": shifts[2],
"mirror": 0, ####TODO: test flip
"scale": 1.0})
if transformation is not None:
imageData.set_attr('xform.projection', transformation)
outputFile = str(objDict['hdfFn'])
if outputFile != fnHdf:
i = 0
fnHdf = outputFile
imageData.write_image(outputFile, i, eman.EMUtil.ImageType.IMAGE_HDF, False)
i += 1
print "OK"
sys.stdout.flush()
line = sys.stdin.readline()
print "DONE"
def mode_meridien(reconfile,
classavgstack,
classdocs,
partangles,
selectdoc,
maxshift,
outerrad,
outanglesdoc,
outaligndoc,
interpolation_method=1,
outliers=None,
goodclassparttemplate=None,
alignopt='apsh',
ringstep=1,
log=None,
verbose=False):
# Resample reference
recondata = EMAN2.EMData(reconfile)
idim = recondata['nx']
reconprep = prep_vol(recondata,
npad=2,
interpolation_method=interpolation_method)
# Initialize output angles
outangleslist = []
outalignlist = []
# Read class lists
classdoclist = glob.glob(classdocs)
partangleslist = read_text_row(partangles)
# Loop through class lists
for classdoc in classdoclist: # [classdoclist[32]]: #
# Strip out three-digit filenumber
classexample = os.path.splitext(classdoc)
classnum = int(classexample[0][-3:])
# Initial average
[avg_phi_init, avg_theta_init] = average_angles(partangleslist,
classdoc,
selectdoc=selectdoc)
# Look for outliers
if outliers:
[avg_phi_final, avg_theta_final] = average_angles(
partangleslist,
classdoc,
selectdoc=selectdoc,
init_angles=[avg_phi_init, avg_theta_init],
threshold=outliers,
goodpartdoc=goodclassparttemplate.format(classnum),
log=log,
verbose=verbose)
else:
[avg_phi_final, avg_theta_final] = [avg_phi_init, avg_theta_init]
# Compute re-projection
refprjreal = prgl(reconprep, [avg_phi_final, avg_theta_final, 0, 0, 0],
interpolation_method=1,
return_real=True)
# Align to class average
classavg = get_im(classavgstack, classnum)
# Alignment using self-correlation function
if alignopt == 'scf':
ang_align2d, sxs, sys, mirrorflag, peak = align2d_scf(classavg,
refprjreal,
maxshift,
maxshift,
ou=outerrad)
# Weird results
elif alignopt == 'align2d':
# Set search range
currshift = 0
txrng = tyrng = search_range(idim, outerrad, currshift, maxshift)
# Perform alignment
ang_align2d, sxs, sys, mirrorflag, peak = align2d(
classavg, refprjreal, txrng, tyrng, last_ring=outerrad)
# Direct3 (angles seemed to be quantized)
elif alignopt == 'direct3':
[[ang_align2d, sxs, sys, mirrorflag,
peak]] = align2d_direct3([classavg],
refprjreal,
maxshift,
maxshift,
ou=outerrad)
# APSH-like alignment (default)
else:
[[ang_align2d, sxs, sys, mirrorflag,
scale]] = apsh(refprjreal,
classavg,
outerradius=outerrad,
maxshift=maxshift,
ringstep=ringstep)
outalignlist.append([ang_align2d, sxs, sys, mirrorflag, 1])
msg = "Particle list %s: ang_align2d=%s sx=%s sy=%s mirror=%s\n" % (
classdoc, ang_align2d, sxs, sys, mirrorflag)
print_log_msg(msg, log, verbose)
# Check for mirroring
if mirrorflag == 1:
tempeulers = list(
compose_transform3(avg_phi_final, avg_theta_final, 0, 0, 0, 0,
1, 0, 180, 0, 0, 0, 0, 1))
combinedparams = list(
compose_transform3(tempeulers[0], tempeulers[1], tempeulers[2],
tempeulers[3], tempeulers[4], 0, 1, 0, 0,
-ang_align2d, 0, 0, 0, 1))
else:
combinedparams = list(
compose_transform3(avg_phi_final, avg_theta_final, 0, 0, 0, 0,
1, 0, 0, -ang_align2d, 0, 0, 0, 1))
# compose_transform3: returns phi,theta,psi, tx,ty,tz, scale
outangleslist.append(combinedparams)
# End class-loop
write_text_row(outangleslist, outanglesdoc)
write_text_row(outalignlist, outaligndoc)
print_log_msg(
'Wrote alignment parameters to %s and %s\n' %
(outanglesdoc, outaligndoc), log, verbose)
del recondata # Clean up
def main_proj_compare(classavgstack,
reconfile,
outdir,
options,
mode='viper',
prjmethod='trilinear',
classangles=None,
partangles=None,
selectdoc=None,
verbose=False,
displayYN=False):
"""
Main function overseeing various projection-comparison modes.
Arguments:
classavgstack : Input image stack
reconfile : Map of which to generate projections (an optionally perform alignment)
outdir : Output directory
mode : Mode, viper (pre-existing angles for each input image), projmatch (angles from internal projection-matching)
verbose : (boolean) Whether to write additional information to screen
options : (list) Command-line options, run 'sxproj_compare.py -h' for an exhaustive list
classangles : Angles and shifts for each input class average
partangles : Angles and shifts for each particle (mode meridien)
selectdoc : Selection file for included images
prjmethod : Interpolation method to use
displayYN : (boolean) Whether to automatically open montage
"""
# Expand path for outputs
refprojstack = os.path.join(outdir, 'refproj.hdf')
refanglesdoc = os.path.join(outdir, 'refangles.txt')
outaligndoc = os.path.join(outdir, 'docalign2d.txt')
# If not an input, will create an output, in modes projmatch
if classangles == None:
classangles = os.path.join(outdir, 'docangles.txt')
# You need either input angles (mode viper) or to calculate them on the fly (mode projmatch)
if mode == 'viper':
sp_global_def.ERROR(
"\nERROR!! Input alignment parameters not specified.",
__file__, 1)
sxprint('Type %s --help to see available options\n' %
os.path.basename(__file__))
exit()
# Check if inputs exist
check(classavgstack, verbose=verbose)
check(reconfile, verbose=verbose)
if verbose: sxprint('')
# Check that dimensions of images and volume agree (maybe rescale volume)
voldim = EMAN2.EMData(reconfile).get_xsize()
imgdim = EMAN2.EMData(classavgstack, 0).get_xsize()
if voldim != imgdim:
sp_global_def.ERROR(
"\nERROR!! Dimension of input volume doesn't match that of image stack: %s vs. %s"
% (voldim, imgdim), __file__, 1)
scale = float(
imgdim
) / voldim # only approximate, since full-sized particle radius is arbitrary
msg = 'The command to resize the volume will be of the form:\n'
msg += 'e2proc3d.py %s resized_vol.hdf --scale=%1.5f --clip=%s,%s,%s\n' % (
reconfile, scale, imgdim, imgdim, imgdim)
msg += 'Check the file in the ISAC directory named "README_shrink_ratio.txt" for confirmation.\n'
sxprint(msg)
exit()
# Here if you want to be fancy, there should be an option to chose the projection method,
# the mechanism can be copied from sxproject3d.py PAP
if prjmethod == 'trilinear':
method_num = 1
elif prjmethod == 'gridding':
method_num = -1
elif prjmethod == 'nn':
method_num = 0
else:
sp_global_def.ERROR(
"\nERROR!! Valid projection methods are: trilinear (default), gridding, and nn (nearest neighbor).",
__file__, 1)
sxprint('Usage:\n%s' % USAGE)
exit()
# Set output directory and log file name
log, verbose = prepare_outdir_log(outdir, verbose)
# In case class averages include discarded images, apply selection file
if mode == 'viper':
if selectdoc:
goodavgs, extension = os.path.splitext(
os.path.basename(classavgstack))
newclasses = os.path.join(outdir, goodavgs + "_kept" + extension)
# e2proc2d appends to existing files, so rename existing output
if os.path.exists(newclasses):
renamefile = newclasses + '.bak'
print_log_msg(
"Selected-classes stack %s exists, renaming to %s" %
(newclasses, renamefile), log, verbose)
print_log_msg("mv %s %s\n" % (newclasses, renamefile), log,
verbose)
os.rename(newclasses, renamefile)
print_log_msg(
'Creating subset of %s to %s based on selection list %s' %
(classavgstack, newclasses, selectdoc), log, verbose)
cmd = "e2proc2d.py %s %s --list=%s" % (classavgstack, newclasses,
selectdoc)
print_log_msg(cmd, log, verbose)
os.system(cmd)
sxprint('')
# Update class-averages
classavgstack = newclasses
# align de novo to reference map
if mode == 'projmatch':
# Generate reference projections
print_log_msg(
'Projecting %s to output %s using an increment of %s degrees using %s symmetry'
% (reconfile, refprojstack, options.delta, options.symmetry), log,
verbose)
cmd = 'sxproject3d.py %s %s --delta=%s --method=S --phiEqpsi=Minus --symmetry=%s' % (
reconfile, refprojstack, options.delta, options.symmetry)
if options.prjmethod == 'trilinear': cmd += ' --trilinear'
cmd += '\n'
print_log_msg(cmd, log, verbose)
project3d(reconfile,
refprojstack,
delta=options.delta,
symmetry=options.symmetry)
# Export projection angles
print_log_msg(
"Exporting projection angles from %s to %s" %
(refprojstack, refanglesdoc), log, verbose)
cmd = "sp_header.py %s --params=xform.projection --import=%s\n" % (
refprojstack, refanglesdoc)
print_log_msg(cmd, log, verbose)
header(refprojstack, 'xform.projection', fexport=refanglesdoc)
# Perform multi-reference alignment
if options.align == 'ali2d':
projdir = os.path.join(
outdir, 'Projdir') # used if input angles no provided
if os.path.isdir(projdir):
print_log_msg('Removing pre-existing directory %s' % projdir,
log, verbose)
print_log_msg('rm -r %s\n' % projdir, log, verbose)
shutil.rmtree(
projdir) # os.rmdir only removes empty directories
# Zero out alignment parameters in header
print_log_msg(
'Zeroing out alignment parameters in header of %s' %
classavgstack, log, verbose)
cmd = 'sxheader.py %s --params xform.align2d --zero\n' % classavgstack
print_log_msg(cmd, log, verbose)
header(classavgstack, 'xform.align2d', zero=True)
# Perform multi-reference alignment
msg = 'Aligning images in %s to projections %s with a radius of %s and a maximum allowed shift of %s' % (
classavgstack, refprojstack, options.matchrad,
options.matchshift)
print_log_msg(msg, log, verbose)
cmd = 'sxmref_ali2d.py %s %s %s --ou=%s --xr=%s --yr=%s\n' % (
classavgstack, refprojstack, projdir, options.matchrad,
options.matchshift, options.matchshift)
print_log_msg(cmd, log, verbose)
mref_ali2d(classavgstack,
refprojstack,
projdir,
ou=options.matchrad,
xrng=options.matchshift,
yrng=options.matchshift)
# Export alignment parameters
print_log_msg(
'Exporting angles from %s into %s' %
(classavgstack, classangles), log, verbose)
cmd = "sp_header.py %s --params=xform.align2d --export=%s\n" % (
classavgstack, classangles)
print_log_msg(cmd, log, verbose)
header(classavgstack, 'xform.align2d', fexport=classangles)
# By default, use AP SH
else:
apsh(refprojstack,
classavgstack,
outangles=classangles,
refanglesdoc=refanglesdoc,
outaligndoc=outaligndoc,
outerradius=options.matchrad,
maxshift=options.matchshift,
ringstep=options.matchstep,
log=log,
verbose=verbose)
# Diagnostic
alignlist = read_text_row(
classangles) # contain 2D alignment parameters
nimg1 = EMAN2.EMUtil.get_image_count(classavgstack)
assert len(alignlist) == nimg1, "MRK_DEBUG"
# Get alignment parameters from MERIDIEN
if mode == 'meridien':
continueTF = True # Will proceed unless some information is missing
if not partangles:
sp_global_def.ERROR(
"\nERROR!! Input alignment parameters not provided.", __file__,
1)
continueTF = False
if not continueTF:
sxprint('Type %s --help to see available options\n' %
os.path.basename(__file__))
exit()
if not options.classdocs or options.outliers:
classdir = os.path.join(outdir, 'Byclass')
if not os.path.isdir(classdir): os.makedirs(classdir)
if options.outliers:
goodclassparttemplate = os.path.join(
classdir, 'goodpartsclass{0:03d}.txt')
else:
goodclassparttemplate = None
if not options.classdocs:
classmap = os.path.join(classdir, 'classmap.txt')
classdoc = os.path.join(classdir, 'docclass{0:03d}.txt')
options.classdocs = os.path.join(classdir, 'docclass*.txt')
# Separate particles by class
vomq(classavgstack,
classmap,
classdoc,
log=log,
verbose=verbose)
mode_meridien(reconfile,
classavgstack,
options.classdocs,
partangles,
selectdoc,
options.refineshift,
options.refinerad,
classangles,
outaligndoc,
interpolation_method=method_num,
outliers=options.outliers,
goodclassparttemplate=goodclassparttemplate,
alignopt=options.align,
ringstep=options.refinestep,
log=log,
verbose=verbose)
# Import Euler angles
print_log_msg(
"Importing parameter information into %s from %s" %
(classavgstack, classangles), log, verbose)
cmd = "sp_header.py %s --params=xform.projection --import=%s\n" % (
classavgstack, classangles)
print_log_msg(cmd, log, verbose)
header(classavgstack, 'xform.projection', fimport=classangles)
# Make comparison stack between class averages (images 0,2,4,...) and re-projections (images 1,3,5,...)
compstack = compare_projs(reconfile,
classavgstack,
classangles,
outdir,
interpolation_method=method_num,
log=log,
verbose=verbose)
# Optionally pop up e2display
if displayYN:
sxprint('Opening montage')
cmd = "e2display.py %s\n" % compstack
sxprint(cmd)
os.system(cmd)
sxprint("Done!")
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 read_mrc_numpy_vol(path):
ve = E.EMData(str(path))
v = em2numpy(ve)
v = v.astype(N.float32)
del ve # to prevent memory leak
return v
def read_hdf_numpy_vol(path):
ve = E.EMData(str(path))
return em2numpy(ve)
for root, _, files in os.walk(stack_dir):
files = [fi for fi in files if fi.endswith(".hdf")]
print("Processing {} files in {}".format(len(files), root))
for hdf_file in files:
stack = os.path.join(root, hdf_file)
output = os.path.join(
output_dir,
os.path.splitext(os.path.basename(hdf_file))[0] + ".csv")
try:
count = EMAN2.EMUtil.get_image_count(stack)
except:
print("Skipping: {}".format(stack))
# Input is likely decimated coordinates, so try to undecimate
fout = open(output, 'w')
fin = open(stack, 'r')
for line in fin:
coords = numpy.asarray([int(v) for v in line.split()])
fout.write("\t".join(["%d" % int(c * 8)
for c in coords]) + "\n")
fout.close()
fin.close()
continue
fout = open(output, 'w')
for i in xrange(count):
aimg = EMAN2.EMData()
aimg.read_image(stack, i)
coords = numpy.asarray(aimg['ptcl_source_coord'])
fout.write("\t".join(["%d" % int(c * 8)
for c in coords]) + "\n")
fout.close()
norm = False
coords = numpy.asarray([[int(val) for val in line.split()]
for line in open(partcoords, 'r')])
#get_trans
#get_rotation_transform
for i in xrange(len(coords)):
print i + 1, len(coords)
x, y, z = coords[i]
x = round(x * cshrink)
y = round(y * cshrink)
z = round(z * cshrink)
r = EMAN2.Region((2 * x - boxsize) / 2, (2 * y - boxsize) / 2,
(2 * z - boxsize) / 2, boxsize, boxsize, boxsize)
e = EMAN2.EMData()
e.read_image(tomogram, 0, False, r)
if invert:
e = e * -1
if norm:
e.process_inplace('normalize', {})
e['origin_x'] = 0
e['origin_y'] = 0
e['origin_z'] = 0
e.write_image(output, i)
# norm, intervt, threshold
#ptcl.process_inplace("xform",{"transform":ptcl_parms[0]["xform.align3d"]})
