def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i",
"--input",
type=str,
nargs='+',
help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input, 'output': args.output}
# Create an EM project object
new_project = em.ProjectIntersect(name='EMIntersect')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Run the project
new_project.run(args_dict['input'])
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-flip", "--flip", type=str, help="Flip particle star file")
parser.add_argument("-noflip", "--noflip", type=str, help="No flip particle star file")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {'flip': args.flip,
'noflip': args.noflip,
'output': args.output}
# Check if the input file exists
if args_dict['flip'] is None or not os.path.isfile(args_dict['flip']):
parser.print_help()
sys.exit('Flip file does not exist!')
# Check if the input file exists
if args_dict['noflip'] is None or not os.path.isfile(args_dict['noflip']):
parser.print_help()
sys.exit('Noflip file does not exist!')
# Create an EM project object
new_project = em.ProjectFlip(name='EMParticleMergeFlip')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Prepare project
new_project.prepare_merge_project(args_dict['flip'], args_dict['noflip'])
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-cols",
"--columns",
type=str,
help="Columns to copy",
nargs='*',
default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'columns': args.columns
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Get the new column parameters
if args_dict['columns'] is not None:
new_column_parameters = util.parse_star_parameters(
args_dict['columns'])
else:
new_column_parameters = None
# Create an EM project object
new_project = em.Project(name='EMRenameColumns')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Add new columns
new_project.rename_columns(new_column_parameters)
# Write output files
new_project.write_output_files(write_ref_class_star=False)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-n",
"--numptcls",
type=int,
help="Number of ptcls in the subset",
default=100000)
parser.add_argument("-r",
"--randseed",
type=int,
help="Random seed",
default=1)
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'numptcls': args.numptcls,
'randseed': args.randseed,
'output': args.output
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMSubset')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Add new columns
new_project.pick_random_set(args_dict['numptcls'], args_dict['randseed'])
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-invert-angles", "--invertangles", action='store_true', help="Invert eular angles")
parser.add_argument("-invert-origin", "--invertorigin", action='store_true', help="Invert origins(shifts)")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'invertangles': args.invertangles,
'invertorigin': args.invertorigin,
'output': args.output}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Cistem(name='EMStar2Par')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Sort particles based on imagename
new_project.sort_images()
# Prepare project
new_project.prepare_project()
# If invert-origin
if args_dict['invertorigin']:
new_project.invert_origin()
# If invert-origin
if args_dict['invertangles']:
new_project.invert_angles()
# Convert to par
new_project.convert2par()
# Write output file
new_project.write_output_file()
# Write also star file
new_project.write_star_file()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
parser.add_argument("-ref", "--reference", type=str, help="Reference class star file")
parser.add_argument("-cols", "--columns", type=str, help="Columns to copy", nargs='+')
parser.add_argument("-comp", "--compare", type=str, help="Criteria to compare", choices=['img','mic'], default='img')
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'output': args.output,
'reference': args.reference,
'columns': args.columns,
'compare': args.compare
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Check if the reference file exists
if args_dict['reference'] is None and not os.path.isfile(args_dict['reference']):
parser.print_help()
sys.exit('Reference file file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMCopy')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
new_project.read_class_refs(args_dict['reference'])
print('Read class reference file {}'.format(args_dict['reference']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Add new columns
new_project.copy_from_ref(args_dict['columns'], args_dict['compare'])
# Write output files
new_project.write_output_files(write_ref_class_star=False)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-offsetrot",
"--offsetrot",
type=float,
help="Rotation offset",
default=0)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'offsetrot': args.offsetrot
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMApplyBarcode')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Add new columns
new_project.apply_barcode(args_dict['offsetrot'])
# Write output files
new_project.write_output_files(write_ref_class_star=False)
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
parser.add_argument("-batch", "--batch", type=int, help="Particle batch size", default=100)
parser.add_argument("-relion", "--relion", action='store_true', help="Use relion for flipping")
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'output': args.output,
'batch': args.batch,
'relion': args.relion
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.ProjectFlip()
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Determine pixel size from particle star file
new_project.read_particle_apix()
if args_dict['relion']:
new_project.prepare_project_relion()
new_project.flip_particles_relion()
else:
new_project.prepare_project()
new_project.flip_particles(batch_size=args_dict['batch'])
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, nargs='+', help="Star file(s)")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'output': args.output
}
# Check if the input file exists
if args_dict['input'] is None:
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMMergeStar')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particle_stars(args_dict['input'])
print('Read particle star files {}'.format(','.join(args_dict['input'])))
# Prepare input and output files
new_project.prepare_io_files_star()
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
parser.add_argument("-ref", "--reference", type=str, help="Reference class star file", default=None)
parser.add_argument("-newclassid", "--newclassid",
action='store_true', help="Create new class ids for the reference file")
parser.add_argument("-addcols", "--addcolumns",
type=str, help="Add new columns with same value for all particles", nargs='*', default=None)
parser.add_argument("-recenter", "--recenter", action='store_true', help="Recenter particles")
parser.add_argument("-offset", "--offset", nargs=2, type=float, default=[0, 0], help="Final offset")
parser.add_argument("-offsetcom", "--offsetcom", action='store_true', help="Set final offset from center-of-mass")
parser.add_argument("-apix", "--apix", type=float,
help="Micrograph pixel size", default=1.82)
parser.add_argument("-rotatepsi", "--rotatepsi", type=float, help="Rotate psi by angle", default=0)
parser.add_argument("-flipX", "--flipX", action='store_true', help='Modify star file for flip around X axis')
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'output': args.output,
'reference': args.reference,
'addcolumns': args.addcolumns,
'recenter': args.recenter,
'newclassid': args.newclassid,
'apix': args.apix,
'offset': args.offset,
'offsetcom': args.offsetcom,
'rotatepsi': args.rotatepsi,
'flipX': args.flipX
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Get the new column parameters
if not args_dict['addcolumns'] is None:
new_column_parameters = util.parse_star_parameters(args_dict['addcolumns'])
else:
new_column_parameters = None
# Create an EM project object
new_project = em.Project(name='EMTransform')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Set microgragraph pixel size
new_project.set_mic_apix(args_dict['apix'])
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Check if the input file exists
if args_dict['reference'] is not None and os.path.isfile(args_dict['reference']):
new_project.read_class_refs(args_dict['reference'], new_classids=args_dict['newclassid'])
print('Read class reference file {}'.format(args_dict['reference']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Perform reference based particle star transformation
new_project.transform_particles(final_offset=args_dict['offset'], com_offset=args_dict['offsetcom'], rotate_psi=args_dict['rotatepsi'])
# Add new columns
new_project.add_columns(new_column_parameters)
# Recenter
if args_dict['recenter']:
new_project.read_particle_apix()
new_project.recenter_particles()
if args_dict['flipX']:
new_project.flipX_particles()
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-Zflip",
"--Zflip",
action='store_true',
help="Z-Flip particles in star file")
parser.add_argument("-tilt90",
"--tilt90",
action='store_true',
help="Set tilt of particles to 90-degree side")
parser.add_argument("-aligntopriors",
"--aligntopriors",
type=str,
nargs='*',
default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'Zflip': args.Zflip,
'tilt90': args.tilt90,
'output': args.output,
'aligntopriors': args.aligntopriors
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMRotate')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Make tilt angle around 90 degree
if args_dict['tilt90']:
new_project.tilt90_particles()
# Z-flip particles
if args_dict['Zflip']:
new_project.Zflip_particles()
# Align to priors
if args_dict['aligntopriors'] is not None:
new_project.align_to_priors(args_dict['aligntopriors'])
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-half1', "--half1", type=str, help='Half map 1')
parser.add_argument('-half2', "--half2", type=str, help='Half map 2')
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument('-hp',
"--highpass",
type=float,
default=40,
help='highpass filter for FSC plots')
parser.add_argument('-whole',
"--whole",
type=str,
default=None,
help='Whole map')
parser.add_argument('-mask',
"--mask",
type=str,
default=None,
help='Mask for FSC calculation')
parser.add_argument('-apix',
"--apix",
type=float,
default=1.82,
help='Pixel size (Angstroms)')
parser.add_argument('-bfactor',
"--bfactor",
type=float,
default=None,
help='B-factor for global sharpening (Negative)')
args = parser.parse_args()
# Prepare args dict
args_dict = {
'half1': args.half1,
'half2': args.half2,
'whole': args.whole,
'highpass': args.highpass,
'mask': args.mask,
'apix': args.apix,
'bfactor': args.bfactor,
'output': args.output
}
# Create an EM project object
new_project = em.ProjectFsc(name='EMFsc')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Set parameters
new_project.set_params(args_dict['half1'], args_dict['half2'],
args_dict['whole'], args_dict['mask'],
args_dict['apix'], args_dict['bfactor'],
args_dict['highpass'])
# Prepare project
new_project.prepare_project()
# Prepare io files
new_project.prepare_io_files()
# Calculate cross correlations
new_project.calc_cc()
# Run the project
new_project.run_fsc()
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-batch",
"--batch",
type=int,
help="Particle batch size",
default=100)
parser.add_argument("-transform",
"--transform",
action='store_true',
help='Transform the images before writing the stacks')
parser.add_argument("-hp",
"--highpass",
type=float,
help="Highpass filter in Angstrom units",
default=None)
parser.add_argument("-lp",
"--lowpass",
type=float,
help="Lowpass filter in Angstrom units",
default=None)
parser.add_argument("-clip",
"--clip",
type=int,
help="Clip images to new box size",
default=None)
parser.add_argument("-origapix",
"--origapix",
type=float,
help="Original micrograph pixel size (A)",
default=1.82)
parser.add_argument(
"-recenter",
"--recenter",
action='store_true',
help=
"Recenter the images prior to clipping. Use with clip option only.",
default=None)
parser.add_argument(
"-diameter",
"--diameter",
type=int,
help=
"Particle diameter for normalization. If provided, perform normalization",
default=None)
parser.add_argument("-n",
"--numptcls",
type=int,
help="Number of particles to process",
default=None)
parser.add_argument(
"-copymics",
"--copymics",
action='store_true',
help="Copy micrographs instead of making particle stack",
default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'batch': args.batch,
'transform': args.transform,
'highpass': args.highpass,
'lowpass': args.lowpass,
'clip': args.clip,
'diameter': args.diameter,
'recenter': args.recenter,
'origapix': args.origapix,
'numptcls': args.numptcls,
'copymics': args.copymics
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.ProjectStack(name='EMStack')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Set particle number
new_project.set_particle_num(args_dict['numptcls'])
# Set original pixel
new_project.set_orig_apix(args_dict['origapix'])
# Read particle diameter
new_project.set_particle_diameter(args_dict['diameter'])
# Prepare project
new_project.prepare_project(args_dict['highpass'], args_dict['lowpass'],
args_dict['clip'])
# Copy micrographs
if args_dict['copymics']:
new_project.copy_micrographs()
else:
# Flip particles
new_project.create_stack(args_dict['batch'], args_dict['transform'],
args_dict['clip'], args_dict['recenter'])
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle cs file")
parser.add_argument("-ref",
"--reference",
type=str,
help="Template cs file",
default=None)
parser.add_argument("-pass",
"--passthrough",
type=str,
help="Passthrough cs file from cryosparc",
default=None)
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-orig",
"--original",
type=str,
help="Original star file",
default=None)
parser.add_argument("-micpath",
"--micpath",
type=str,
help="Micrographs path",
default="Micrographs")
parser.add_argument("-projpath",
"--projpath",
type=str,
help="Cryosparc project path",
default="")
parser.add_argument("-delclass",
"--delclass",
type=int,
nargs='+',
help="Classes to delete",
default=[])
parser.add_argument("-delstr",
"--delstr",
type=str,
help="String to delete from Micrograph name",
default='')
parser.add_argument("-restore-offsets",
"--restoreoffsets",
action='store_true',
help="Restore offsets from original star file")
parser.add_argument("-merge-orig",
"--mergeoriginal",
action='store_true',
help="Merge with original star file")
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'reference': args.reference,
'passthrough': args.passthrough,
'output': args.output,
'original': args.original,
'micpath': args.micpath,
'projpath': args.projpath,
'delclass': args.delclass,
'delstr': args.delstr,
'restoreoffsets': args.restoreoffsets,
'mergeoriginal': args.mergeoriginal
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMcsparc2star')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Set cs files
new_project.set_cs_files(blob_cs_file=args_dict['input'],
passthrough_cs_file=args_dict['passthrough'],
original_star_file=args_dict['original'],
ref_class_cs_file=args_dict['reference'])
# Read cs files
new_project.read_cs_files()
# Prepare input and output files
new_project.prepare_io_files_cs()
# Conert cs to star
new_project.convert_cs2star(args_dict['micpath'], args_dict['projpath'],
args_dict['delclass'], args_dict['delstr'],
args_dict['restoreoffsets'],
args_dict['mergeoriginal'])
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
parser.add_argument("-maxprob", "--maxprob", type=float, help="Maximum probability", default=None)
parser.add_argument("-maxclass", "--maxclass", type=int, help="Maximum number of classes assigned for a particle", default=None)
parser.add_argument("-tilt", "--tilt", type=float, nargs=2, help="Accepted range of tilt angles. [ min ,max]", default=[0, 360])
parser.add_argument("-dtilt", "--dtilt", type=float, nargs=2, help="Accepted range of diff-tilt angles. [ min ,max]", default=[0, 360])
parser.add_argument("-dpsi", "--dpsi", type=float, nargs=2, help="Accepted range of diff-psi angles. [ min ,max]", default=[0, 360])
parser.add_argument("-drot", "--drot", type=float, nargs=2, help="Accepted range of diff-rot angles. [ min ,max]", default=[0, 360])
parser.add_argument("-dalign", "--dalign", type=float, nargs=2, help="Accepted range of diff-align angles. [ min ,max]", default=[-1, 1])
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'output': args.output,
'maxprob': args.maxprob,
'maxclass': args.maxclass,
'tilt': args.tilt,
'dtilt': args.dtilt,
'dpsi': args.dpsi,
'drot': args.drot,
'dalign': args.dalign}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMFilter')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Determine pixel size from particle star file
new_project.read_particle_apix()
# Subtract class mrc from particle mrc
new_project.filter_ptcls(maxprob=args_dict['maxprob'],
maxclass=args_dict['maxclass'],
tilt_range=args_dict['tilt'],
dpsi_range=args_dict['dpsi'],
dtilt_range=args_dict['dtilt'],
drot_range=args_dict['drot'],
dalign_range=args_dict['dalign'])
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-refclass",
"--refclass",
type=str,
help="Class star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-diameter",
"--diameter",
type=float,
help="Particle diameter in Angstroms",
default=None)
parser.add_argument("-maskalign",
"--maskalign",
type=str,
help="Mask used for 2D classification",
default=None)
parser.add_argument("-refalign",
"--refalign",
type=str,
help="Reference mrc file used for alignment",
default=None)
parser.add_argument("-refnum",
"--refnum",
type=int,
help="Reference class number",
default=1)
parser.add_argument(
"-skip-rotate",
"--skiprotate",
action='store_true',
help="Skip rotation in alignment of class averages to reference")
parser.add_argument("-use-unmasked",
"--useunmasked",
action='store_true',
help="Use unmasked classes for alignment of classes")
parser.add_argument("-sigma-psi",
"--sigmapsi",
type=float,
help="Sigma-psi for alignment of classes",
default=-1)
parser.add_argument("-offset-range",
"--offsetrange",
type=int,
help="Offset range for alignment of classes",
default=20)
parser.add_argument("-skip-particles",
"--skipparticles",
action='store_true',
help="Skip particle alignment")
parser.add_argument("-final-offset",
"--finaloffset",
type=float,
nargs=2,
help="Final offset",
default=[0, 0])
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'refclass': args.refclass,
'output': args.output,
'diameter': args.diameter,
'maskalign': args.maskalign,
'refalign': args.refalign,
'refnum': args.refnum,
'skiprotate': args.skiprotate,
'useunmasked': args.useunmasked,
'sigmapsi': args.sigmapsi,
'skipparticles': args.skipparticles,
'offsetrange': args.offsetrange,
'finaloffset': args.finaloffset
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Check if the class reference file exists
if args_dict['refclass'] is None and not os.path.isfile(
args_dict['refclass']):
parser.print_help()
sys.exit('Class Reference file file does not exist!')
# Create an EM project object
new_project = em.ProjectAlign2D()
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
new_project.read_class_refs(args_dict['refclass'])
print('Read class reference file {}'.format(args_dict['refclass']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Determine pixel size from particle star file
new_project.read_particle_apix()
# Set particle diameter
new_project.set_particle_diameter(args_dict['diameter'])
# Set alignment mask
new_project.set_alignment_mask(args_dict['maskalign'])
# Set alignment reference
new_project.set_alignment_ref(args_dict['refalign'])
# Set alignment reference
new_project.set_ref_class_num(args_dict['refnum'])
# Prepare project files
new_project.prepare_project(use_unmasked_classes=args_dict['useunmasked'])
# Normalize class averages
new_project.normalize_class_refs()
# Run relion
new_project.set_relion_refine_args(skip_rotate=args_dict['skiprotate'],
sigma_psi=args_dict['sigmapsi'],
offset_range=args_dict['offsetrange'])
new_project.run_refine2D()
# Process 2D refine files
new_project.prepare_refine2D()
# Check if we skip particle alignment
if not args_dict['skipparticles']:
# Transform particles
new_project.transform_particles(final_offset=args_dict['finaloffset'])
# Write output files
new_project.write_output_files()
# Make transformed class stacks
new_project.create_transformed_class_stacks()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle par file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-orig",
"--original",
type=str,
help="Original star file")
parser.add_argument("-del-classes",
"--delclasses",
type=int,
nargs='*',
help="Classes to be deleted",
default=None)
parser.add_argument("-sel-classes",
"--selclasses",
type=int,
nargs='*',
help="Selected classes",
default=None)
parser.add_argument("-score-cutoff",
"--scorecutoff",
type=float,
help="Frealign score lower cutoff",
default=None)
parser.add_argument("-sigma-cutoff",
"--sigmacutoff",
type=float,
help="Frealign sigma noise lower cutoff",
default=None)
parser.add_argument("-ml-cutoff",
"--mlcutoff",
type=float,
help="Frealign maximum-likelihood lower cutoff",
default=None)
parser.add_argument("-db",
"--db",
type=str,
help="Cistem database file",
default=None)
parser.add_argument("-dont-copy",
"--dontcopy",
action='store_true',
help="Dont copy alignment offset and angle values")
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'original': args.original,
'delclasses': args.delclasses,
'selclasses': args.selclasses,
'scorecutoff': args.scorecutoff,
'sigmacutoff': args.sigmacutoff,
'mlcutoff': args.mlcutoff,
'db': args.db,
'dontcopy': args.dontcopy,
'output': args.output
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Check if the input file exists
if args_dict['original'] is None or not os.path.isfile(
args_dict['original']):
parser.print_help()
sys.exit('Original star file does not exist!')
# Create an EM project object
new_project = em.Cistem(name='EMPar2Star')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['original'])
print('Read particle star file {}'.format(args_dict['original']))
# Read apix from star file
new_project.read_particle_apix()
# Prepare output star files
new_project.prepare_io_files_star()
# Create write formatter
new_project.create_write_formatter()
# Read par file
new_project.read_par(args_dict['input'])
print('Read particle par file {}'.format(args_dict['input']))
# Prepare project
new_project.set_par2star_params(args_dict['delclasses'],
args_dict['selclasses'],
args_dict['scorecutoff'],
args_dict['sigmacutoff'],
args_dict['mlcutoff'])
# Read cistem database
new_project.read_db(args_dict['db'])
# Select particles that exist in the refinement package
new_project.select_particles()
# Convert to par
if not args_dict['dontcopy']:
new_project.copy2star()
# Write output file
new_project.write_star_file()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-refclass",
"--refclass",
type=str,
help="Class star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-diameter",
"--diameter",
type=float,
help="Particle diameter in Angstroms",
default=None)
parser.add_argument("-masksolvent",
"--masksolvent",
type=str,
help="Solvent mask used for 2D classification",
default=None)
parser.add_argument("-masksub",
"--masksub",
type=str,
help="Mask used for the subtraction",
default=None)
parser.add_argument(
"-maskref",
"--maskref",
type=str,
help="Reference mask that defines the boundary of the structure",
default=None)
parser.add_argument("-batch",
"--batch",
type=int,
help="Particle batch size",
default=100)
parser.add_argument("-maxptcl",
"--maxptcl",
type=int,
help="Maximum number of particles to write",
default=None)
parser.add_argument("-method",
"--method",
type=str,
help="Particle subtraction method",
choices=['subctf', 'cropctf', 'crop'],
default='subctf')
parser.add_argument("-norm",
"--norm",
type=str,
help="Normalization method for subtraction",
choices=['ccc', 'intensity', 'frc'],
default='frc')
parser.add_argument("-subtractbg",
"--subtractbg",
action='store_true',
help="Subtract background. For crop methods only.")
parser.add_argument("-skipfirstpeak",
"--skipfirstpeak",
action='store_true',
help="Skip first peak in CTF.")
parser.add_argument("-innerdiameter",
"--innerdiameter",
type=float,
help="Inner diameter for the region of interest",
default=None)
parser.add_argument("-clip",
"--clip",
type=int,
help="Clip box size in pixels",
default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'refclass': args.refclass,
'output': args.output,
'diameter': args.diameter,
'masksolvent': args.masksolvent,
'masksub': args.masksub,
'maskref': args.maskref,
'batch': args.batch,
'maxptcl': args.maxptcl,
'method': args.method,
'norm': args.norm,
'subtractbg': args.subtractbg,
'skipfirstpeak': args.skipfirstpeak,
'innerdiameter': args.innerdiameter,
'clip': args.clip
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Check if the class reference file exists
if args_dict['refclass'] is None and not os.path.isfile(
args_dict['refclass']):
parser.print_help()
sys.exit('Class Reference file file does not exist!')
# Create an EM project object
new_project = em.ProjectSubtract2D()
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
new_project.read_class_refs(args_dict['refclass'])
print('Read class reference file {}'.format(args_dict['refclass']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Determine pixel size from particle star file
new_project.read_particle_apix()
# Set particle diameter
new_project.set_particle_diameter(args_dict['diameter'])
# Set alignment mask
new_project.set_alignment_mask(args_dict['masksolvent'])
# Set subtraction mask
new_project.set_subtraction_mask(args_dict['masksub'])
# Set alignment reference
new_project.set_structure_mask(args_dict['maskref'])
# Set inner diameter
new_project.set_inner_diameter(args_dict['innerdiameter'])
# Set clip box
new_project.set_clip_box(args_dict['clip'])
# Prepare project files
new_project.prepare_project()
# Subtract class mrc from particle mrc
new_project.subtract_class_mrc(
max_ptcl=args_dict['maxptcl'],
batch_size=args_dict['batch'],
subtract_func=args_dict['method'],
subtract_bg=args_dict['subtractbg'],
norm_method=args_dict['norm'],
skip_to_firstpeak=args_dict['skipfirstpeak'])
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-mic",
"--micrograph",
type=str,
help="Micrograph star file")
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'micrograph': args.micrograph
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Check if the reference file exists
if args_dict['micrograph'] is None and not os.path.isfile(
args_dict['micrograph']):
parser.print_help()
sys.exit('Micrographs file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMClean')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Read particle pixel size information
new_project.read_particle_apix()
new_project.read_micrographs(args_dict['micrograph'])
print('Read micrographs star file {}'.format(args_dict['micrograph']))
# Read micrograph pixel size information
new_project.read_mic_apix()
# Read micrograph header
new_project.read_mic_header()
# Prepare input and output files
new_project.prepare_io_files_star()
# Check particle positions
new_project.check_particle_pos()
# Delete outside particles
new_project.delete_outside_ptcls()
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
parser.add_argument("-copytopriors", "--copypriors", action='store_true', help="Copy offset and/or angle parameters to priors", default=True)
parser.add_argument("-copytooffsets", "--copyoffsets", action='store_true', help="Copy priors to angle and distance offset parameters")
parser.add_argument("-fliponly", "--fliponly", action='store_true', help="Set only flip ratio to 0")
parser.add_argument("-fliprot", "--fliprot", action='store_true', help="Set flip ratio to 0 and delete rlnAngleRotPrior")
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'output': args.output,
'copypriors': args.copypriors,
'copyoffsets': args.copyoffsets,
'fliponly': args.fliponly,
'fliprot': args.fliprot
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Copy offsets to priors overwrites
if args_dict['copypriors']:
add_column_parameters = {'rlnAngleTilt':90,
'rlnAngleTiltPrior':90,
'rlnAnglePsiFlipRatio':0}
del_column_parameters = {'rlnAngleRotPrior':None}
copy_column_parameters = {'rlnOriginX': 'rlnOriginXPrior',
'rlnOriginY': 'rlnOriginYPrior',
'rlnAnglePsi': 'rlnAnglePsiPrior',
'rlnAngleTilt':'rlnAngleTiltPrior'}
if args_dict['copyoffsets']:
add_column_parameters = {}
del_column_parameters = {}
copy_column_parameters = {'rlnOriginXPrior': 'rlnOriginX',
'rlnOriginYPrior': 'rlnOriginY',
'rlnAnglePsiPrior': 'rlnAnglePsi',
'rlnAngleTiltPrior':'rlnAngleTilt'}
if args_dict['fliponly']:
add_column_parameters = {'rlnAnglePsiFlipRatio':0}
del_column_parameters = {}
copy_column_parameters = {}
if args_dict['fliprot']:
add_column_parameters = {'rlnAnglePsiFlipRatio':0}
del_column_parameters = {'rlnAngleRotPrior':None}
copy_column_parameters = {}
# Create an EM project object
new_project = em.Project(name='EMHelixReady')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Delete columns
new_project.delete_columns(del_column_parameters)
# Add new columns
new_project.add_columns(add_column_parameters)
# Add new columns
new_project.copy_columns(copy_column_parameters)
# Write output files
new_project.write_output_files(write_ref_class_star=False)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument(
"-maxmics",
"--maxmics",
type=int,
help="Maximum number of micrographs allowed in a group",
default=50)
parser.add_argument("-method",
"--method",
type=str,
help="Grouping method",
choices=['defocus', 'intensity'],
default='defocus')
parser.add_argument("-ref",
"--reference",
type=str,
help="Reference file to make the groups")
parser.add_argument("-threshdef",
"--thresholddefocus",
type=float,
help="Defocus threshold value for grouping (Angstrom)",
default=100)
parser.add_argument("-threshint",
"--thresholdintensity",
type=float,
help="Intensity scale threshold value for grouping",
default=0.1)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'maxmics': args.maxmics,
'method': args.method,
'reference': args.reference,
'thresholddefocus': args.thresholddefocus,
'thresholdintensity': args.thresholdintensity
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.ProjectGroup(name='EMGroup')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Set project parameters
new_project.set_params(maxmics=args_dict['maxmics'],
threshdef=args_dict['thresholddefocus'],
threshint=args_dict['thresholdintensity'])
# Prepare input and output files
new_project.prepare_io_files_star()
# Read micrographs
if args_dict['reference'] is not None and os.path.isfile(
args_dict['reference']):
new_project.read_micrographs(args_dict['reference'])
print('Read micrographs star file {}'.format(args_dict['reference']))
# Group particles based on a method
new_project.group_micrographs()
# Assign the groups
new_project.assign_groups()
else:
print('Reference file does not exist!')
new_project.group_particles()
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-selbarcode",
"--selbarcode",
type=str,
help="Barcode to select",
nargs='*',
default={})
parser.add_argument("-delbarcode",
"--delbarcode",
type=str,
help="Barcode to delete",
nargs='*',
default={})
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'selbarcode': args.selbarcode,
'delbarcode': args.delbarcode
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.Project(name='EMSelectBarcode')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Select barcode
new_project.select_by_barcode(args_dict['selbarcode'])
# Delete barcode
new_project.delete_by_barcode(args_dict['delbarcode'])
# Write output files
new_project.write_output_files(write_ref_class_star=False)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-cols",
"--columns",
type=str,
help="Columns to copy",
nargs='*',
default=None)
parser.add_argument("-copytopriors",
"--copypriors",
type=str,
help="Copy offset and/or angle parameters to priors",
default=None,
choices=['angle', 'all', 'helix'])
parser.add_argument(
"-copytooffsets",
"--copyoffsets",
type=str,
help="Copy priors to angle and distance offset parameters",
default=None,
choices=['angle', 'all', 'helix'])
parser.add_argument("-reset-priors",
"--resetpriors",
action='store_true',
help="Delete prior offset and angle columngs")
parser.add_argument("-reset-offsets",
"--resetoffsets",
action='store_true',
help="Assign angle and origin offsets to 0")
parser.add_argument("-invert-psi",
"--invertpsi",
action='store_true',
help="Invert psi angle")
parser.add_argument("-invert-origin",
"--invertorigin",
action='store_true',
help="Invert originX and originY")
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'columns': args.columns,
'copypriors': args.copypriors,
'copyoffsets': args.copyoffsets,
'resetpriors': args.resetpriors,
'resetoffsets': args.resetoffsets,
'invertpsi': args.invertpsi,
'invertorigin': args.invertorigin
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Get the new column parameters
if args_dict['columns'] is not None:
new_column_parameters = util.parse_star_parameters(
args_dict['columns'])
else:
new_column_parameters = None
# Copy offsets to priors overwrites
if args_dict['copypriors'] == 'all':
new_column_parameters = {
'rlnOriginX': 'rlnOriginXPrior',
'rlnOriginY': 'rlnOriginYPrior',
'rlnAnglePsi': 'rlnAnglePsiPrior',
'rlnAngleRot': 'rlnAngleRotPrior',
'rlnAngleTilt': 'rlnAngleTiltPrior'
}
elif args_dict['copypriors'] == 'angle':
new_column_parameters = {
'rlnAnglePsi': 'rlnAnglePsiPrior',
'rlnAngleRot': 'rlnAngleRotPrior',
'rlnAngleTilt': 'rlnAngleTiltPrior'
}
elif args_dict['copypriors'] == 'helix':
new_column_parameters = {
'rlnOriginX': 'rlnOriginXPrior',
'rlnOriginY': 'rlnOriginYPrior',
'rlnAnglePsi': 'rlnAnglePsiPrior',
'rlnAngleTilt': 'rlnAngleTiltPrior'
}
# Copy priors to offsets overwrites
if args_dict['copyoffsets'] == 'all':
new_column_parameters = {
'rlnOriginXPrior': 'rlnOriginX',
'rlnOriginYPrior': 'rlnOriginY',
'rlnAnglePsiPrior': 'rlnAnglePsi',
'rlnAngleRotPrior': 'rlnAngleRot',
'rlnAngleTiltPrior': 'rlnAngleTilt'
}
elif args_dict['copyoffsets'] == 'angle':
new_column_parameters = {
'rlnAnglePsiPrior': 'rlnAnglePsi',
'rlnAngleRotPrior': 'rlnAngleRot',
'rlnAngleTiltPrior': 'rlnAngleTilt'
}
elif args_dict['copyoffsets'] == 'helix':
new_column_parameters = {
'rlnOriginXPrior': 'rlnOriginX',
'rlnOriginYPrior': 'rlnOriginY',
'rlnAnglePsiPrior': 'rlnAnglePsi',
'rlnAngleTiltPrior': 'rlnAngleTilt'
}
# Create an EM project object
new_project = em.Project(name='EMCopyColumns')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# If reset priors option is ON
if args_dict['resetpriors']:
new_project.reset_priors()
# If reset offset option is on
if args_dict['resetoffsets']:
new_project.reset_offsets()
# If invert-psi option is on
if args_dict['invertpsi']:
new_project.invert_psi()
# If invert-origin
if args_dict['invertorigin']:
new_project.invert_origin()
# Add new columns
new_project.copy_columns(new_column_parameters)
# Write output files
new_project.write_output_files(write_ref_class_star=False)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-orimic",
"--orimic",
type=str,
help="Original micrograph star file")
parser.add_argument("-newmic",
"--newmic",
type=str,
help="New micrograph star file")
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'orimic': args.orimic,
'newmic': args.newmic
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Check if the reference file exists
if args_dict['orimic'] is None and not os.path.isfile(args_dict['orimic']):
parser.print_help()
sys.exit('Original micrographs file does not exist!')
# Check if the reference file exists
if args_dict['newmic'] is None and not os.path.isfile(args_dict['newmic']):
parser.print_help()
sys.exit('New micrographs file does not exist!')
# Create an EM project object
new_project = em.ProjectScale(name='EMScale')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Read particle pixel size information
new_project.read_particle_apix()
new_project.read_micrographs(args_dict['orimic'])
print('Read original micrographs star file {}'.format(args_dict['orimic']))
# Read original micrographs apix
new_project.read_mic_apix()
new_project.read_new_micrographs(args_dict['newmic'])
print('Read new micrographs star file {}'.format(args_dict['newmic']))
# Read new micrographs apix
new_project.read_new_mic_apix()
# Perform the transformation
new_project.run()
# Prepare input and output files
new_project.prepare_io_files_star()
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i", "--input", type=str, help="Particle star file")
parser.add_argument("-o", "--output", type=str, help="Output directory", default=None)
parser.add_argument("-cols", "--columns", type=str, nargs='*', default=['rlnDefocusU',
'rlnDefocusV',
'rlnDefocusAngle',
'rlnCtfFigureOfMerit',
'rlnFinalResolution',
'rlnMaxValueProbDistribution',
'rlnNrOfSignificantSamples',
'rlnLogLikeliContribution',
'rlnAngleRot',
'rlnAngleRotPrior',
'rlnAngleTilt',
'rlnAngleTiltPrior',
'rlnAnglePsi',
'rlnOriginX',
'rlnOriginY'])
parser.add_argument("-pairs", "--pairs", type=str, nargs='*', default=['rlnCtfFigureOfMerit:rlnFinalResolution',
'rlnAngleTilt:rlnAngleRot',
'rlnMaxValueProbDistribution:rlnNrOfSignificantSamples',
'rlnOriginX:rlnOriginY',
'rlnAngleRot:rlnAngleRotPrior',
'rlnAngleTilt:rlnAngleTiltPrior',
'rlnAnglePsi:rlnAnglePsiPrior'])
parser.add_argument("-diffs", "--diffs", type=str, nargs='*', default=['rlnOriginX:rlnOriginXPrior',
'rlnOriginY:rlnOriginYPrior',
'rlnAngleRot:rlnAngleRotPrior',
'rlnAngleTilt:rlnAngleTiltPrior',
'rlnAnglePsi:rlnAnglePsiPrior'])
parser.add_argument("-orientation", "--orientation", action='store_true', help="Plot orientation of the particles with respect to priors")
parser.add_argument("-nbins", "--nbins", type=int, default=30)
parser.add_argument("-fontsize", "--fontsize", type=int, default=5)
parser.add_argument("-format", "--format", type=str, default='svg', choices=['png','svg'])
parser.add_argument("-ref", "--reference", type=str, help="Reference star file", default=None)
parser.add_argument("-barcode", "--barcode", type=str, help="Barcode to select", nargs='*', default={})
parser.add_argument("-offsetrot", "--offsetrot", type=int, default=0)
args = parser.parse_args()
# Prepare args dict
args_dict = {'input': args.input,
'output': args.output,
'columns': args.columns,
'pairs': args.pairs,
'diffs': args.diffs,
'orientation': args.orientation,
'fontsize': args.fontsize,
'reference': args.reference,
'nbins': args.nbins,
'format': args.format,
'barcode': args.barcode,
'offsetrot': args.offsetrot}
# Get the new column parameters
if args_dict['barcode'] is not None:
barcode_parameters = util.parse_star_parameters(args_dict['barcode'])
else:
barcode_parameters = None
# Create an EM project object
new_project = em.ProjectPlot(name='EMPlot')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory+'/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
# Select based on the barcode
if barcode_parameters is not None:
new_project.select_by_barcode(args_dict['barcode'])
# Read particle mrc paths
new_project.read_ptcl_mrc_paths()
# Prepare io files
new_project.prepare_io_files(args_dict['format'])
# Set rotation angle offset
new_project.set_offsetrot(args_dict['offsetrot'])
# Set tick fontsizes
new_project.set_tick_fontsize(size=args_dict['fontsize'])
# Read references if it is provided
if args_dict['reference'] is not None and os.path.isfile(args_dict['reference']):
# Read particles
new_project.read_reference(args_dict['reference'])
print('Read reference star file {}'.format(args_dict['reference']))
# Run ptcl project
new_project.run_ptcl(args_dict['columns'], args_dict['pairs'], args_dict['diffs'], args_dict['orientation'], args_dict['nbins'])
# Write output files
new_project.write_output_files(args_dict['format'])
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i",
"--input",
type=str,
help="Input particle star file")
parser.add_argument("-ref",
"--reference",
type=str,
help="Reference star file")
parser.add_argument("-addsuffix",
"--addsuffix",
type=str,
nargs='*',
help="Suffix to add to the image names",
default=None)
parser.add_argument("-remsuffix",
"--removesuffix",
type=str,
help="Suffix to remove from the image names",
default=None)
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'reference': args.reference,
'addsuffix': args.addsuffix,
'removesuffix': args.removesuffix,
'output': args.output
}
# Check if the input file exists
if args_dict['input'] is None or not os.path.isfile(args_dict['input']):
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.ProjectImgName(name='EMReplaceImgName')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_particles(args_dict['input'])
print('Read particle star file {}'.format(args_dict['input']))
if args_dict['addsuffix'] is not None:
new_project.add_suffix(args_dict['addsuffix'])
elif args_dict['removesuffix'] is not None:
new_project.remove_suffix(args_dict['removesuffix'])
else:
# Check if the reference file exists
if args_dict['reference'] is None or not os.path.isfile(
args_dict['reference']):
parser.print_help()
sys.exit('Reference file does not exist!')
# Read particles
new_project.read_reference(args_dict['reference'])
print('Read reference star file {}'.format(args_dict['reference']))
# Prepare project
new_project.replace_particle_img()
# Prepare input and output files
new_project.prepare_io_files_star()
# Write output files
new_project.write_output_files()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument("-i",
"--input",
type=str,
help="Class reference star file")
parser.add_argument("-o",
"--output",
type=str,
help="Output directory",
default=None)
parser.add_argument("-use-unmasked",
"--useunmasked",
action='store_true',
help='Use unmasked classes for alignment')
parser.add_argument("-apix",
"--apix",
type=float,
help='Pixel size in anstroms',
default=1.82)
parser.add_argument("-diameter",
"--diameter",
type=float,
help='Particle diameter in Anstroms',
default=1000)
parser.add_argument("-numiter",
"--numiter",
type=int,
help='Number of iterations',
default=20)
parser.add_argument("-sigma-psi",
"--sigmapsi",
type=float,
help="Sigma-psi for alignment of classes",
default=-1)
parser.add_argument("-offset-range",
"--offsetrange",
type=int,
help="Offset range for alignment of classes",
default=10)
args = parser.parse_args()
# Prepare args dict
args_dict = {
'input': args.input,
'output': args.output,
'useunmasked': args.useunmasked,
'apix': args.apix,
'diameter': args.diameter,
'numiter': args.numiter,
'sigmapsi': args.sigmapsi,
'offsetrange': args.offsetrange
}
# Check if the input file exists
if args_dict['input'] is None:
parser.print_help()
sys.exit('Input file does not exist!')
# Create an EM project object
new_project = em.ProjectAlign2D(name='EMAlignClasses')
new_project.set_output_directory(args_dict['output'], project_root='.')
# Write parameters to args filename
args_filename = new_project.output_directory + '/args.yaml'
util.write_config_file(args_filename, args_dict)
# Read particles
new_project.read_class_refs(args_dict['input'])
print('Read class reference file {}'.format(args_dict['input']))
# Prepare input and output files
new_project.prepare_io_files_star()
# Set parameters
new_project.set_params(args_dict['apix'], args_dict['diameter'])
# Prepare project files
new_project.prepare_project(use_unmasked_classes=args_dict['useunmasked'])
# Normalize class averages
new_project.normalize_class_refs()
# Run relion
new_project.set_relion_refine_args(offset_range=args_dict['offsetrange'],
sigma_psi=args_dict['sigmapsi'],
num_iter=args_dict['numiter'],
firstiter_cc=False,
T=4)
new_project.run_refine2D()
# Process 2D refine files
new_project.prepare_refine2D()
# Make transformed class stacks
new_project.create_transformed_class_stacks()
