def main():
usage = " "
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_pos_argument(
name="tomogram",
help="Specify the tomogram to be segmented.",
default="",
guitype='filebox',
browser="EMTomoTable(withmodal=True,multiselect=False)",
row=0,
col=0,
rowspan=1,
colspan=2,
mode="tomoseg")
#parser.add_argument("--load", type=str,help="Load previous contour segmentation.", default=None, guitype='filebox', browser="EMBrowserWidget(withmodal=True,multiselect=False)", row=1, col=0,rowspan=1, colspan=2, mode="tomoseg")
parser.add_argument("--nooptimize",
action="store_true",
help="do not optimize path",
default=False)
parser.add_argument(
"--ppid",
type=int,
help="Set the PID of the parent process, used for cross platform PPID",
default=-2)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
drawer = EMDrawWindow(app, options, datafile=args[0])
drawer.show()
app.execute()
E2end(logid)
def main():
usage = """This shows the alignment result from e2tomogram.py uing the information from a tomorecon_xx folder.
Example: e2tomo_showali.py --path <tomorecon_xx>
"""
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument(
"--path",
type=str,
help="path to tomorecon_xx directory to examine fiducial error.",
default="",
guitype='filebox',
browser="EMBrowserWidget(withmodal=True,multiselect=False)",
row=0,
col=0,
rowspan=1,
colspan=2,
mode="fiderr")
#parser.add_argument("--iteration", type=int,help="Refinement iteration number", default=2,guitype="intbox",row=1, col=0, rowspan=1, colspan=1,mode="fiderr")
parser.add_argument("--ppid", type=int, help="ppid", default=-2)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
drawer = EMDrawWindow(app, options)
drawer.show()
app.execute()
E2end(logid)
def main():
usage = "Electron Microscope simulation"
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument(
"--mode",
type=int,
help=
"operating mode. 0: imaging mode with all lens; 1:diffraction mode with all lens; 2: imaging mode with single lens and phase plate; else: imaging mode with one lens.",
default=0)
parser.add_argument("--cs",
type=float,
help="Cs of microscope.",
default=0.0)
parser.add_argument(
"--twod",
action="store_true",
help=
"Show twod image instead of 1D plot and beam propagation in the microscope.",
default=False)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
# app=QtGui.QApplication([""])
window = MainWindow(options.mode, options.cs, options.twod)
window.show()
window.raise_()
app.execute()
E2end(logid)
def main():
# an application
em_app = EMApp()
control1 = TestControl(em_app)
control2 = TestControl(em_app)
em_app.execute()
def main():
usage = " "
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument("--label",
type=str,
help="Load previous contour segmentation.",
default="tomobox")
parser.add_argument("--gpuid",
type=str,
help="Specify the gpu to use",
default="")
parser.add_argument("--mult",
type=float,
help="multiply data by factor. useful for vpp data...",
default=1)
#parser.add_argument("--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID",default=-2)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
test = EMImage2DWidget()
drawer = EMTomobox(app, options)
drawer.show()
app.execute()
E2end(logid)
def main():
global debug, logid
progname = os.path.basename(sys.argv[0])
usage = """%prog [options]
This program allows the user to play around with Fourier synthesis graphically
"""
parser = OptionParser(usage=usage, version=EMANVERSION)
# parser.add_option("--gui",action="store_true",help="Start the GUI for interactive fitting",default=False)
parser.add_option(
"--verbose",
"-v",
dest="verbose",
action="store",
metavar="n",
type="int",
default=0,
help=
"verbose level [0-9], higher number means higher level of verboseness")
(options, args) = parser.parse_args()
app = EMApp()
win = GUIFourierSynth(app)
win.show()
try:
win.raise_()
win.synthplot.raise_()
except:
pass
app.exec_()
def main():
progname = os.path.basename(sys.argv[0])
usage = """prog [options]
A simple CTF simulation program.
"""
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_argument("--apix",type=float,help="Angstroms per pixel for all images",default=1.0, guitype='floatbox', row=4, col=0, rowspan=1, colspan=1, mode="autofit['self.pm().getAPIX()']")
parser.add_argument("--voltage",type=float,help="Microscope voltage in KV",default=300.0, guitype='floatbox', row=4, col=1, rowspan=1, colspan=1, mode="autofit['self.pm().getVoltage()']")
parser.add_argument("--cs",type=float,help="Microscope Cs (spherical aberation)",default=4.1, guitype='floatbox', row=5, col=0, rowspan=1, colspan=1, mode="autofit['self.pm().getCS()']")
parser.add_argument("--ac",type=float,help="Amplitude contrast (percentage, default=10)",default=10, guitype='floatbox', row=5, col=1, rowspan=1, colspan=1, mode='autofit')
parser.add_argument("--samples",type=int,help="Number of samples in the plotted curve",default=256)
parser.add_argument("--apply",type=str,default=None,help="A 2-D image file which the CTF will be applied to in real-time")
parser.add_argument("--verbose", "-v", dest="verbose", action="store", metavar="n", type=int, default=0, help="verbose level [0-9], higher number means higher level of verboseness")
(options, args) = parser.parse_args()
from eman2_gui.emapplication import EMApp
app=EMApp()
gui=GUIctfsim(app,options.apix,options.voltage,options.cs,options.ac,options.samples,options.apply)
gui.show_guis()
gui.raise_()
app.exec_()
def main():
usage = "This is a GUI program that allows users inspect tomograms easily. Simply run without argument in a tomogram project directory."
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument("--ppid", type=int, help="", default=None)
parser.add_header(name="orblock1",
help='',
title="Click launch to evaluate reconstructed tomograms",
row=1,
col=0,
rowspan=1,
colspan=2,
mode="")
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
if not os.path.isdir("tomograms"): os.mkdir("tomograms")
#print("No tomograms found. You must perform at least one reconstruction or manually populate the 'tomograms' directory with at least one reconstruction.")
#sys.exit()
app = EMApp()
gui = TomoEvalGUI(options)
gui.show()
gui.raise_()
app.exec_()
E2end(logid)
def main():
progname = os.path.basename(sys.argv[0])
usage = """prog [classfile]
This program provides tools for evaluating particle data in various ways. For example it will allow you to select class-averages
containing bad (or good) particles and manipulate the project to in/exclude them. It will locate files with class-averages automatically,
but you can specify additional files at the command-line.
"""
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_header(name="runeval", help='Click Launch to launch the particle evaluation interface', title="### Click Launch to run e2evalparticles ###", row=0, col=0, rowspan=1, colspan=1)
parser.add_argument("--gui",action="store_true",help="Start the GUI for interactive use (default=True)",default=True)
parser.add_argument("--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID",default=-1)
parser.add_argument("--verbose", "-v", dest="verbose", action="store", metavar="n", type=int, default=0, help="verbose level [0-9], higner number means higher level of verboseness")
(options, args) = parser.parse_args()
#logid=E2init(sys.argv, options.ppid)
app = EMApp()
control=EMEvalPtclTool(args,verbose=options.verbose)
control.show()
control.raise_()
app.execute()
def main():
usage = " "
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
#parser.add_argument("--path", type=str,help="path", default="het_3d")
parser.add_argument("--noupdate",
action="store_true",
help="do not erase shapes",
default=False)
parser.add_argument("--fromedge",
action="store_true",
help="draw from edge",
default=False)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
img = EMData(args[0])
app = EMApp()
drawer = EMDrawWindow(app, options, datafile=img)
drawer.show()
drawer.raise_()
app.execute()
E2end(logid)
def main():
usage = " "
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
#parser.add_argument("--path", type=str,help="path", default="")
parser.add_header(name="orblock1",
help='',
title="Click launch to evaluate subtomogram averages",
row=1,
col=0,
rowspan=1,
colspan=2)
parser.add_argument(
"--ppid",
type=int,
help="Set the PID of the parent process, used for cross platform PPID",
default=-2)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
gui = SptEvalGUI(options)
gui.show()
gui.raise_()
app.exec_()
E2end(logid)
def main(): from eman2_gui.emapplication import EMApp em_app = EMApp() pref_task = EMPreferencesTask() pref_task.run_form() em_app.execute()
def main():
progname = os.path.basename(sys.argv[0])
usage = """prog [options] <image file>
Provides a GUI interface for applying a sequence of processors to an image, stack of images or a volume."""
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
# parser.add_argument("--boxsize","-B",type=int,help="Box size in pixels",default=64)
# parser.add_argument("--shrink",type=int,help="Shrink factor for full-frame view, default=0 (auto)",default=0)
parser.add_argument(
"--apix",
type=float,
help="Override the A/pix value stored in the file header",
default=0.0)
# parser.add_argument("--force2d",action="store_true",help="Display 3-D data as 2-D slices",default=False)
parser.add_argument(
"--ppid",
type=int,
help="Set the PID of the parent process, used for cross platform PPID",
default=-1)
parser.add_argument(
"--verbose",
"-v",
dest="verbose",
action="store",
metavar="n",
type=int,
default=0,
help=
"verbose level [0-9], higner number means higher level of verboseness")
(options, args) = parser.parse_args()
if len(args) != 1:
parser.error(
"You must specify a single data file on the command-line.")
if not file_exists(args[0]): parser.error("%s does not exist" % args[0])
# if options.boxsize < 2: parser.error("The boxsize you specified is too small")
# # The program will not run very rapidly at such large box sizes anyhow
# if options.boxsize > 2048: parser.error("The boxsize you specified is too large.\nCurrently there is a hard coded max which is 2048.\nPlease contact developers if this is a problem.")
# logid=E2init(sys.argv,options.ppid)
app = EMApp()
pix_init()
control = EMFilterTool(datafile=args[0],
apix=options.apix,
force2d=False,
verbose=options.verbose)
# control=EMFilterTool(datafile=args[0],apix=options.apix,force2d=options.force2d,verbose=options.verbose)
control.show()
try:
control.raise_()
except:
pass
app.execute()
def main(): global cur_data,data,imdisp # an application em_app = EMApp() widget=TestDisplay() widget.show() em_app.execute()
def main():
progname = os.path.basename(sys.argv[0])
usage = """%prog [options] <input ali>
This program will allow the user to select a specific feature within a tomogram and track it, boxing out the
feature from all slices. Generally best for uniform objects like vesicles."""
parser = OptionParser(usage=usage, version=EMANVERSION)
parser.add_option("--prefix",
type="string",
help="Output file prefix",
default=None)
parser.add_option("--tiltstep",
type="float",
help="Step between tilts in degrees, default=2",
default=2.0)
parser.add_option("--maxshift",
type="int",
help="Maximum shift in autoalign, default=8",
default=8)
parser.add_option(
"--seqali",
action="store_true",
default=False,
help=
"Average particles in previous slices for better alignments of near-spherical objects"
)
parser.add_option("--invert",
action="store_true",
default=False,
help="Inverts image data contrast on the fly")
#parser.add_option("--boxsize","-B",type="int",help="Box size in pixels",default=64)
#parser.add_option("--writeoutput",action="store_true",default=False,help="Uses coordinates stored in the tomoboxer database to write output")
#parser.add_option("--stack",action="store_true",default=False,help="Causes the output images to be written to a stack")
#parser.add_option("--force",action="store_true",default=False,help="Force overwrite output")
#parser.add_option("--normproc", help="Normalization processor to apply to particle images. Should be normalize, normalize.edgemean or None", default="normalize.edgemean")
#parser.add_option("--invertoutput",action="store_true",help="If writing output only, this will invert the pixel intensities of the boxed files",default=False)
#parser.add_option("--dbls",type="string",help="data base list storage, used by the workflow. You can ignore this argument.",default=None)
#parser.add_option("--outformat", help="Format of the output particles images, should be bdb,img, or hdf", default="bdb")
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
track = TrackerControl(app, options.maxshift, options.invert,
options.seqali, options.tiltstep)
track.set_image(args[0])
app.execute()
E2end(logid)
def main():
progname = os.path.basename(sys.argv[0])
usage = """prog [options]
WARNING: This program still under development.
This program is designed to work interactively with Gaussian mixture models, automating as much
as possible of the tasks associated with studying dynamics using GMMs. It requires either a
refine_XX folder or a set of particles with known orientations as a starting point."""
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
# parser.add_argument("--path",type=str,default=None,help="Path for the gmm_XX folder to work in, by default a new folder will be created")
parser.add_argument(
"--threads",
default=-1,
type=int,
help=
"Number of alignment threads to run in parallel on a single computer.")
parser.add_argument(
"--ppid",
type=int,
help="Set the PID of the parent process, used for cross platform PPID",
default=-1)
global options
(options, args) = parser.parse_args()
#if options.path==None:
#options.path=numbered_path("gmm",True)
# os.makedirs(options.path)
if options.threads < 1: options.threads = num_cpus()
#if not os.path.exists(options.path) :
#os.mkdir(options.path)
# parms=js_open_dict("{}/0_a2d_parms.json".format(options.path))
pid = E2init(argv)
app = EMApp()
emgmm = EMGMM(app, options)
emgmm.show()
emgmm.raise_()
QtWidgets.QMessageBox.warning(
None, "Warning",
"""This program is still experimental. While functional
many capabilities of the underlying e2gmm_refine program
are not yet available through this interface. Matching number
of gaussians to resolution/volume is key in obtaining good
distributions.""")
app.execute()
E2end(pid)
def main():
progname = os.path.basename(sys.argv[0])
usage = """prog [classfile]
THIS PROGRAM IS NOT YET COMPLETE
This program allows you to manually mark bad particles via a graphical interface.
"""
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_pos_argument(name="particles",help="List the file to process with e2ctf here.", default="", guitype='filebox', browser="EMCTFParticlesTable(withmodal=True,multiselect=True)", filecheck=False, row=0, col=0,rowspan=1, colspan=2, mode='autofit,tuning,genoutp,gensf')
parser.add_argument("--allparticles",action="store_true",help="Will process all particle stacks stored in the particles subdirectory (no list of files required)",default=False, guitype='boolbox',row=1, col=0, mode='autofit,tuning,genoutp,gensf')
parser.add_argument("--minptcl",type=int,help="Files with fewer than the specified number of particles will be skipped",default=0,guitype='intbox', row=2, col=0, mode='autofit,tuning,genoutp,gensf')
parser.add_argument("--minqual",type=int,help="Files with a quality value lower than specified will be skipped",default=0,guitype='intbox', row=2, col=1, mode='autofit,tuning,genoutp,gensf')
parser.add_argument("--gui",action="store_true",help="Start the GUI for interactive use (default=True)",default=True)
parser.add_argument("--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID",default=-1)
parser.add_argument("--verbose", "-v", dest="verbose", action="store", metavar="n", type=int, default=0, help="verbose level [0-9], higher number means higher level of verboseness")
(options, args) = parser.parse_args()
if options.allparticles:
args=["particles/"+i for i in os.listdir("particles") if "__" not in i and i[0]!="." and ".hed" not in i ]
args.sort()
if options.verbose : print("%d particle stacks identified"%len(args))
# remove any files that don't have enough particles from the list
if options.minptcl>0 :
args=[i for i in args if imcount(i)>=options.minptcl]
if options.verbose: print("{} stacks after minptcl filter".format(len(args)))
# remove files with quality too low
if options.minqual>0 :
outargs=[]
for i in args:
try:
if js_open_dict(info_name(i))["quality"]>=options.minqual : outargs.append(i)
except:
# traceback.print_exc()
print("Unknown quality for {}, including it".format(info_name(i)))
outargs.append(i)
args=outargs
if options.verbose: print("{} stacks after quality filter".format(len(args)))
#logid=E2init(sys.argv, options.ppid)
app = EMApp()
control=EMMarkPtclTool(args,verbose=options.verbose)
control.show()
app.execute()
def main():
usage=""" !!! Experimental program....
Cleaned and modified version of e2spt_boxer.py. Allow multiple type of features in one tomogram and save metadata in the new EMAN2 tomogram framework.
[prog] <tomogram>
"""
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
#parser.add_argument("--path", type=str,help="path", default=None)
parser.add_pos_argument(name="tomogram",help="Specify a tomogram from which you want to extract particles.", default="", guitype='filebox', browser="EMTomoBoxesTable(withmodal=True,multiselect=False)", row=0, col=0,rowspan=1, colspan=2, mode="box3d,box2d")
parser.add_argument("--box2d",action="store_true",help="Boxing 2D particls from tomograms.",default=False, guitype='boolbox', row=4, col=0, rowspan=1, colspan=1, mode='box2d[True]')
parser.add_argument("--box3d",action="store_true",help="Boxing 3D particls from tomograms (default).",default=False, guitype='boolbox', row=4, col=0, rowspan=1, colspan=1, mode='box3d[True]')
parser.add_header(name="instruction0", help='instruction', title="### Use '~' and '1' to go through slices along Z axis. ###", row=10, col=0, rowspan=1, colspan=2, mode="box3d,box2d")
parser.add_header(name="instruction1", help='instruction', title="### Hold Shift to delete particles ###", row=11, col=0, rowspan=1, colspan=2, mode="box3d,box2d")
#parser.add_argument("--mode", type=str,help="Boxing mode. choose from '2D' and '3D'. Default is '3D'", default="3D",guitype='combobox',choicelist="('2D', '3D')",row=1, col=0, rowspan=1, colspan=1,mode="boxing")
parser.add_argument("--ppid", type=int,help="ppid", default=-2)
(options, args) = parser.parse_args()
logid=E2init(sys.argv)
if len(args) == 0:
print("INPUT ERROR: You must specify a tomogram.")
sys.exit(1)
if options.box2d==True and options.box3d==False:
options.mode="2D"
else:
options.mode="3D"
img = args[0]
app = EMApp()
img=args[0]
imghdr = EMData(img,0,True)
options.apix = imghdr['apix_x']
box = 32
boxer=EMTomoBoxer(app,options,datafile=img)
boxer.show()
app.execute()
E2end(logid)
return
def main():
usage = " "
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
#parser.add_argument("--path", type=str,help="path", default="")
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
gui = TomoEvalGUI(options)
gui.show()
gui.raise_()
app.exec_()
E2end(logid)
def main():
progname = os.path.basename(sys.argv[0])
usage = """prog [options]
WARNING: This program still under development.
This program is designed to work interactively with Gaussian mixture models, automating as much
as possible of the tasks associated with studying dynamics using GMMs. It requires either a
refine_XX folder or a set of particles with known orientations as a starting point."""
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
# parser.add_argument("--path",type=str,default=None,help="Path for the gmm_XX folder to work in, by default a new folder will be created")
parser.add_argument(
"--threads",
default=-1,
type=int,
help=
"Number of alignment threads to run in parallel on a single computer. This is the only parallelism supported by e2spt_align at present."
)
parser.add_argument(
"--ppid",
type=int,
help="Set the PID of the parent process, used for cross platform PPID",
default=-1)
global options
(options, args) = parser.parse_args()
#if options.path==None:
#options.path=numbered_path("gmm",True)
# os.makedirs(options.path)
if options.threads < 1: options.threads = num_cpus()
#if not os.path.exists(options.path) :
#os.mkdir(options.path)
# parms=js_open_dict("{}/0_a2d_parms.json".format(options.path))
pid = E2init(argv)
app = EMApp()
emgmm = EMGMM(app, options)
emgmm.show()
emgmm.raise_()
app.execute()
E2end(pid)
def display_validation_plots(path,
radcut,
planethres,
plotdatalabels=False,
color='#00ff00',
plotzaxiscolor=False):
from eman2_gui.emimage2d import EMImage2DWidget
from eman2_gui.emapplication import EMApp
r = []
theta = []
datap = []
zaxis = []
try:
tpdb = js_open_dict("%s/perparticletilts.json" % path)
tplist = tpdb["particletilt_list"]
maxcolorval = max(tplist, key=lambda x: x[3])[3]
for tp in tplist:
if tp[3] > planethres: # if the out of plane threshold is too much
continue
if plotdatalabels: datap.append(tp[0])
r.append(tp[1])
theta.append(math.radians(tp[2]))
# Color the Z axis out of planeness
zaxis.append(computeRGBcolor(tp[3], 0, maxcolorval))
tpdb.close()
except:
print("Couldn't load tp from DB, not showing polar plot")
data = None
try:
data = EMData("%s/contour.hdf" % path)
except:
print("Couldn't open contour plot")
if not data and not (theta and r): return
app = EMApp()
if theta and r:
plot = EMValidationPlot()
plot.set_data((theta, r), 50, radcut, datap)
# Color by Z axis if desired
if plotzaxiscolor: plot.set_scattercolor([zaxis])
plot.set_datalabelscolor(color)
plot.show()
if data:
image = EMImage2DWidget(data)
image.show()
app.exec_()
def main():
global debug,logid
progname = os.path.basename(sys.argv[0])
usage = """prog [options] <single image file> ...
This program will allow you to evaluate an individual scanned micrograph or CCD frame, by looking at its
power spectrum in various ways."""
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_pos_argument(name="image",help="Image to process with e2evalimage.", default="", guitype='filebox', browser="EMBrowserWidget(withmodal=True,multiselect=True)", row=0, col=0,rowspan=1, colspan=2, mode="eval")
parser.add_header(name="evalimageheader", help='Options below this label are specific to e2evalimage', title="### e2evalimage options ###", default=None, row=1, col=0, rowspan=1, colspan=2, mode="eval")
parser.add_argument("--gui",action="store_true",help="This is a GUI-only program. This option is provided for self-consistency",default=True)
parser.add_argument("--apix",type=float,help="Angstroms per pixel for all images",default=None, guitype='floatbox', row=3, col=0, rowspan=1, colspan=1, mode="eval['self.pm().getAPIX()']")
parser.add_argument("--constbfactor",type=float,help="Set B-factor to fixed specified value, negative value autofits",default=-1.0, guitype='floatbox', row=8, col=0, rowspan=1, colspan=1, mode='eval[-1.0]')
parser.add_argument("--voltage",type=float,help="Microscope voltage in KV",default=None, guitype='floatbox', row=3, col=1, rowspan=1, colspan=1, mode="eval['self.pm().getVoltage()']")
parser.add_argument("--cs",type=float,help="Microscope Cs (spherical aberation)",default=None, guitype='floatbox', row=4, col=0, rowspan=1, colspan=1, mode="eval['self.pm().getCS()']")
parser.add_argument("--ac",type=float,help="Amplitude contrast (percentage, default=10)",default=10, guitype='floatbox', row=4, col=1, rowspan=1, colspan=1, mode="eval")
parser.add_argument("--phaseplate",action="store_true",help="Include phase/amplitude contrast in CTF estimation. For use with hole-less phase plates.",default=False, guitype='boolbox', row=3, col=2, rowspan=1, colspan=1, mode='filter[False]')
parser.add_argument("--astigmatism",action="store_true",help="Includes astigmatism in automatic fitting",default=False, guitype='boolbox', row=8, col=1, rowspan=1, colspan=1, mode='eval')
parser.add_argument("--box",type=int,help="Forced box size in grid mode. Overrides any previous setting. ",default=-1, guitype='intbox', row=5, col=0, rowspan=1, colspan=1, mode="eval")
parser.add_argument("--usefoldername",action="store_true",help="If you have the same image filename in multiple folders, and need to import into the same project, this will prepend the folder name on each image name",default=False,guitype='boolbox',row=5, col=1, rowspan=1, colspan=1, mode="eval")
parser.add_argument("--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID",default=-1)
parser.add_argument("--verbose", "-v", dest="verbose", action="store", metavar="n", type=int, default=0, help="verbose level [0-9], higner number means higher level of verboseness")
(options, args) = parser.parse_args()
logid=E2init(sys.argv,options.ppid)
from eman2_gui.emapplication import EMApp
app=EMApp()
gui=GUIEvalImage(args,options.voltage,options.apix,options.cs,options.ac,options.box,options.usefoldername,options.constbfactor,options.astigmatism,options.phaseplate)
gui.show()
try:
gui.wimage.raise_()
gui.wfft.raise_()
gui.wplot.raise_()
gui.raise_()
except: pass
# try: gui.raise_()
# except: pass
app.execute()
E2end(logid)
def main():
usage=" "
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_argument("--path", type=str,help="path", default=None)
parser.add_argument("--loadali2d", type=str,help="previous 2d alignment", default=None)
parser.add_argument("--loadali3d", type=str,help="previous 3d alignment", default=None)
#parser.add_argument("--inplace", action="store_true", default=False ,help="overwrite input.")
#parser.add_argument("--invert", action="store_true", default=False ,help="invert direction.")
(options, args) = parser.parse_args()
logid=E2init(sys.argv)
app = EMApp()
win=EMSptEval(app, options)
win.show()
app.execute()
E2end(logid)
def main():
usage=" "
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_argument("--jsout", type=str,help="json output", default=None)
parser.add_argument("--inplace", action="store_true", default=False ,help="overwrite input.")
parser.add_argument("--invert", action="store_true", default=False ,help="invert direction.")
parser.add_argument("--mode", type=str,help="choose from rad/line, default is line", default="line")
parser.add_argument("--vec", type=str,help="vector direction, default 0,0,1", default="0,0,1")
(options, args) = parser.parse_args()
logid=E2init(sys.argv)
app = EMApp()
win=EMSptEval(app,args[0], options)
win.show()
app.execute()
E2end(logid)
def main():
usage="""This shows the alignment result from e2tomogram.py uing the information from a tomorecon_xx folder.
Example: e2tomo_showali.py --path <tomorecon_xx> --iteration <iteration number>
"""
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_argument("--path", type=str,help="path to tomorecon_xx directory to examine fiducial error.", default="", guitype='filebox', browser="EMBrowserWidget(withmodal=True,multiselect=False)", row=0, col=0,rowspan=1, colspan=2, mode="fiderr")
parser.add_argument("--iteration", type=int,help="Refinement iteration number", default=2,guitype="intbox",row=1, col=0, rowspan=1, colspan=1,mode="fiderr")
parser.add_argument("--ppid", type=int,help="ppid", default=-2)
(options, args) = parser.parse_args()
logid=E2init(sys.argv)
fname=os.path.join(options.path, "ali_{:02d}.hdf".format(options.iteration))
pname=os.path.join(options.path, "landmarks_{:02d}.txt".format(options.iteration))
pks=np.loadtxt(pname)
imgs = EMData.read_images(fname)
img=EMData(imgs[0]["nx"],imgs[0]["ny"], len(imgs))
xfs=[]
for i,m in enumerate(imgs):
img.insert_clip(m, (0,0,i))
xfs.append(m["xform.projection"])
aname=os.path.join(options.path, "ptclali_{:02d}.hdf".format(options.iteration))
n=EMUtil.get_image_count(aname)
dirs=np.zeros((len(imgs),len(pks),2))
for i in range(n):
e=EMData(aname, i, True)
s=e["score"]
dirs[e["nid"], e["pid"]]=[s[1], -s[0]]
print(dirs)
app = EMApp()
drawer=EMDrawWindow(app,options,img, pks, xfs, dirs)
drawer.show()
app.execute()
E2end(logid)
def main():
progname = os.path.basename(sys.argv[0])
usage = """prog <projection file> <particles file>
Compare different similarity metrics for a given particle stack. Note that all particles and projections are
read into memory. Do not use it on large sets of particles !!!
"""
parser = EMArgumentParser(usage=usage,version=EMANVERSION)
parser.add_argument("--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID",default=-1)
(options, args) = parser.parse_args()
if len(args)<2 :
print("Error, please specify projection file and particles file")
sys.exit(1)
logid=E2init(sys.argv,options.ppid)
em_app = EMApp()
window = EM3DGLWidget() #TODO: see if this should be a subclass of EMSymViewerWidget instead
explorer = EMCmpExplorer(window)
window.set_model(explorer)
explorer.set_data(args[0],args[1])
em_app.show()
em_app.execute()
E2end(logid)
def main(): usage="[prog] <2D image file> " parser = EMArgumentParser(usage=usage,version=EMANVERSION) (options, args) = parser.parse_args() logid=E2init(sys.argv) filename=args[0] app = EMApp() img=EMData(filename) #print img[0]["mean"] w=EMBreakBrick(img,app) #w.set_data(img,filename) app.show_specific(w) app.exec_() E2end(logid)
def main():
usage = " "
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument("--midinput",
type=str,
help="middle layer input",
default=None)
parser.add_argument("--decoder",
type=str,
help="decoder input",
default=None)
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
win = EMSptEval(app, options)
win.show()
app.execute()
E2end(logid)
def main():
usage = """
Visualize particle motion in individual tilts. After a refinement with the new spt protocol, run
e2spt_evalsubtlt.py --path spt_xx --loadali2d spt_xx/aliptcls2d_yy.lst --loadali3d spt_xx/aliptcls3d_zz.lst
It will take a while to load all metadata, and plot the trajectory of each particle on each tilt image in each tomogram.
In the top panel, the blue curve represents the average score of all 2D particles in that tilt, and the red curve represents the average distance of the subtilt motion with respect to the alignment of the 3D particle. The quiver plot below shows the trajectory of each individual particle, colored by its alignment score.
"""
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument("--path", type=str, help="path", default=None)
parser.add_argument("--loadali2d",
type=str,
help="previous 2d alignment",
default=None)
parser.add_argument("--loadali3d",
type=str,
help="previous 3d alignment",
default=None)
parser.add_argument("--submean",
action="store_true",
default=False,
help="substract mean movement of the vector field")
parser.add_argument("--defocus",
action="store_true",
default=False,
help="plot defocus refinement result")
(options, args) = parser.parse_args()
logid = E2init(sys.argv)
app = EMApp()
win = EMSptEval(app, options)
win.show()
app.execute()
E2end(logid)
def main():
progname = os.path.basename(sys.argv[0])
usage = """e2pdbviewer.py <project directory>
A wrapper program to view a .pdb file on your computer. This is simply an PDB
specific interface to the more general EMScene3D viewer.
"""
parser = EMArgumentParser(usage=usage, version=EMANVERSION)
parser.add_argument("--pdbfiles",
type=str,
help="Specify one or mode pdb files you \
wish to view",
nargs='*',
required=False,
default=None)
parser.add_argument("--ppid",
type=int,
help="Set the PID of the parent \
process, used for cross platform PPID",
default=-1)
parser.add_argument("--verbose", "-v", dest="verbose", action="store", \
metavar="n", type=int, default=0, help="verbose level [0-9], higher \
number means higher level of verboseness" )
(options, args) = parser.parse_args()
logid = E2init(sys.argv, options.ppid)
app = EMApp()
viewer = EMScene3D()
if options.pdbfiles:
models = [EMDataItem3D(pdb_file=pdbf) for pdbf in options.pdbfiles]
viewer.addChildren(models)
viewer.show()
app.execute()
E2end(logid)
