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 backproject_nn4(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 requires EMAN2/Sparx"
npad, sym, weighting = extra.get('npad', 2), extra.get('sym',
'c1'), extra.get(
'weighting', 1)
if not hasattr(img, 'ndim'):
for i, val in enumerate(img):
if isinstance(val, tuple): val, a = val
else: a = align[i]
xform_proj = EMAN2.Transform({
"type": "spider",
"phi": a[2],
"theta": a[1],
"psi": a[0]
})
if not is_em(val): val = numpy2em(val)
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)
return recon
def orients_one_unit(self, delta_deg):
sym = EMAN2.parsesym(self._symtype)
drad = np.pi * delta_deg / 180.0
# generate uniform orientations on the sphere
vecs = np.float32(Symmetry.calc_points(drad))
nvec = vecs.shape[0]
# convert unit vectors to azimuth and altitude
az = 180.0 * np.arctan2(vecs[:, 0], vecs[:, 2]) / np.pi + 180.0
alt = 180.0 * np.arcsin(vecs[:, 1]) / np.pi + 90.0
# zero out azimuth on poles
aloc = np.logical_or(alt == 0.0, alt == 180.0)
az[aloc] = 0.0
# select orientations inside the asymmetric unit, including mirrors (True)
isin = np.array([
sym.is_in_asym_unit(float(az[v]), float(alt[v]), True)
for v in range(nvec)
])
azin = az[isin]
altin = alt[isin]
ors = [
EMAN2.Transform({
"type": "eman",
"az": float(a),
"alt": float(al),
"phi": 0.0
}) for a, al in zip(azin, altin)
]
return ors
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 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 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 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 readParticles(inputParts, inputCls, inputClasses, outputTxt):
clsImgsEven = eman.EMData.read_images(inputCls+"_even.hdf")
clsImgsOdd = eman.EMData.read_images(inputCls+"_odd.hdf")
classesEven = eman.EMData.read_images(inputClasses+"_even.hdf")
classesOdd = eman.EMData.read_images(inputClasses+"_odd.hdf")
imgs = eman.EMData.read_images(inputParts)
clsClassListEven = clsImgsEven[0]
clsClassListOdd = clsImgsOdd[0]
clsClassList = {}
shiftXList = {}
shiftYList = {}
dAlphaList = {}
flipList = {}
for i in range(clsClassListEven.get_attr_dict()['ny']):
clsClassList[2*i] = clsClassListEven[0,i]
shiftXList[2*i] = clsImgsEven[2][0,i]
shiftYList[2*i] = clsImgsEven[3][0,i]
dAlphaList[2*i] = clsImgsEven[4][0,i]
flipList[2*i] = clsImgsEven[5][0,i]
for i in range(clsClassListOdd.get_attr_dict()['ny']):
clsClassList[2*i+1] = clsClassListOdd[0,i]
shiftXList[2*i+1] = clsImgsOdd[2][0,i]
shiftYList[2*i+1] = clsImgsOdd[3][0,i]
dAlphaList[2*i+1] = clsImgsOdd[4][0,i]
flipList[2*i+1] = clsImgsOdd[5][0,i]
f = open(outputTxt, 'w')
# index = 1
for index in range(len(imgs)):
classNum = clsClassList[index]
if index%2 == 0:
classes = classesEven
else:
classes = classesOdd
imgRotation = classes[int(classNum)].get_attr_dict().get('xform.projection', None)
if imgRotation is not None:
enable = 1
az = imgRotation.get_rotation("eman")['az']
alt = imgRotation.get_rotation("eman")['alt']
if flipList[index] == 1:
transform = eman.Transform({"type": "eman",
"az": az + 180,
"alt": 180 - alt,
"phi": dAlphaList[index]*-1,
"tx": shiftXList[index],
"ty": shiftYList[index]
})
else:
transform = eman.Transform({"type": "eman",
"az": az,
"alt": alt,
"phi": dAlphaList[index],
"tx": shiftXList[index],
"ty":shiftYList[index]
})
transform = transform.inverse()
rot = transform.get_rotation("spider")['psi']
tilt = transform.get_rotation("spider")['theta']
psi = transform.get_rotation("spider")['phi']
shiftX = transform.get_trans()[0]
shiftY = transform.get_trans()[1]
else:
enable = 0
rot = 0
tilt = 0
psi = 0
shiftX = 0
shiftY = 0
print >> f, index, enable, rot, tilt, psi, shiftX, shiftY
f.close()
def readParticles(inputParts, inputCls, inputClasses, outputTxt, alitype='3d'):
imgs = eman.EMUtil.get_image_count(inputParts)
clsClassDict = {}
shiftXList = {}
shiftYList = {}
dAlphaList = {}
flipList = {}
with open(outputTxt, 'wb') as f:
if alitype == '2d':
# reading 2d refinement results
clsImgs = eman.EMData.read_images(inputCls)
classes = eman.EMData.read_images(inputClasses)
clsClassList = clsImgs[0]
f.write('#index, enable, cls, rot, tilt, psi, shiftX, shiftY\n')
for i in range(clsClassList.get_attr_dict()['ny']):
clsClassDict[i] = clsClassList[0, i]
shiftXList[i] = clsImgs[2][0, i]
shiftYList[i] = clsImgs[3][0, i]
dAlphaList[i] = clsImgs[4][0, i]
flipList[i] = clsImgs[5][0, i]
# now convert eman orientation to scipion
for index in range(imgs):
classNum = clsClassDict[index]
imgRotation = classes[int(classNum)].get_attr_dict().get(
'xform.projection', None)
if imgRotation is not None:
enable = 1
transform = eman.Transform({
"type":
"2d",
"alpha":
dAlphaList[index],
"mirror":
True if flipList[index] else False,
"tx":
shiftXList[index],
"ty":
shiftYList[index],
})
if flipList[index]:
tilt = 180 - transform.get_rotation("spider")['theta']
psi = transform.get_rotation("spider")['phi'] * -1
else:
tilt = transform.get_rotation("spider")['theta']
psi = transform.get_rotation("spider")['phi']
rot = transform.get_rotation("spider")['psi']
shifts = transform.get_trans()
shiftX, shiftY = shifts[0], shifts[1]
f.write(('{} ' * 8 + '\n').format(index, enable,
int(classNum), rot, tilt,
psi, shiftX, shiftY))
else:
# disabled image
f.write(('{} ' * 2 + '\n').format(index, 0))
else:
# reading 3d refinement results
clsImgsEven = eman.EMData.read_images(inputCls + "_even.hdf")
clsImgsOdd = eman.EMData.read_images(inputCls + "_odd.hdf")
classesEven = eman.EMData.read_images(inputClasses + "_even.hdf")
classesOdd = eman.EMData.read_images(inputClasses + "_odd.hdf")
clsClassListEven = clsImgsEven[0]
clsClassListOdd = clsImgsOdd[0]
f.write('#index, enable, rot, tilt, psi, shiftX, shiftY\n')
for i in range(clsClassListEven.get_attr_dict()['ny']):
clsClassDict[2 * i] = clsClassListEven[0, i]
shiftXList[2 * i] = clsImgsEven[2][0, i]
shiftYList[2 * i] = clsImgsEven[3][0, i]
dAlphaList[2 * i] = clsImgsEven[4][0, i]
flipList[2 * i] = clsImgsEven[5][0, i]
for i in range(clsClassListOdd.get_attr_dict()['ny']):
clsClassDict[2 * i + 1] = clsClassListOdd[0, i]
shiftXList[2 * i + 1] = clsImgsOdd[2][0, i]
shiftYList[2 * i + 1] = clsImgsOdd[3][0, i]
dAlphaList[2 * i + 1] = clsImgsOdd[4][0, i]
flipList[2 * i + 1] = clsImgsOdd[5][0, i]
# now convert eman orientation to scipion
for index in range(imgs):
classNum = clsClassDict[index]
if index % 2 == 0:
classes = classesEven
else:
classes = classesOdd
imgRotation = classes[int(classNum)].get_attr_dict().get(
'xform.projection', None)
if imgRotation is not None:
enable = 1
az = imgRotation.get_rotation("eman")['az']
alt = imgRotation.get_rotation("eman")['alt']
transform = eman.Transform({
"type":
"eman",
"az":
az,
"alt":
alt,
"phi":
dAlphaList[index],
"mirror":
True if flipList[index] else False,
"tx":
shiftXList[index],
"ty":
shiftYList[index],
})
transform = transform.inverse()
if flipList[index]:
tilt = 180 - transform.get_rotation("spider")['theta']
psi = transform.get_rotation("spider")['phi'] * -1
else:
tilt = transform.get_rotation("spider")['theta']
psi = transform.get_rotation("spider")['phi']
rot = transform.get_rotation("spider")['psi']
shifts = transform.get_trans()
shiftX, shiftY = shifts[0], shifts[1]
f.write(('{} ' * 7 + '\n').format(index, enable, rot, tilt,
psi, shiftX, shiftY))
else:
# disabled image
f.write(('{} ' * 2 + '\n').format(index, 0))
