def do_ali(ptcls, projs): boxsize=ptcls[0]["nx"] bslst=[] quals=[] bss=.0 pjs=[(p, None) for p in projs] for i in range(len(ptcls)): #sim=cmponetomany(pjs,ptcls[i],align=("rotate_translate_flip",{"maxshift":boxsize/5}),alicmp=("ccc",{}),ralign=("refine",{}),cmp=("frc",{"minres":80,"maxres":20})) sim=cmponetomany(pjs,ptcls[i],align=("rotate_translate_tree",{"maxshift":old_div(boxsize,5), "maxres":20}),alicmp=("ccc",{}),ralign=("refine",{}),cmp=("frc",{"minres":160,"maxres":20})) bs=min(sim) bss+=bs[0] bslst.append((bs[0],i)) n=sim.index(bs) # print n ptcls[i]["match_n"]=n ptcls[i]["match_qual"]=-bs[0] ptcls[i]["xform.projection"]=projs[n]["xform.projection"]# best orientation set in the original particle bslst.sort()# sorted list of all particle qualities bslst.reverse() aptcls=[] #for i in range(len(ptcls)*3/4):# We used to include 3/4 of the particles for i in range(len(ptcls)): n=ptcls[bslst[i][1]]["match_n"] quals.append(ptcls[bslst[i][1]]["match_qual"]) aptcls.append(ptcls[bslst[i][1]].align("rotate_translate_tree",projs[n],{"maxshift":old_div(boxsize,5), "maxres":20},"frc",{})) aptcls[-1].process_inplace("normalize.toimage",{"to":projs[n]}) #aptcls[-1].process_inplace("normalize") aptcls[-1].add(-aptcls[-1]["mean"]) return aptcls
def do_ali_fullcov(ptcls, projs): boxsize = ptcls[0]["nx"] quals = [] bss = .0 pts = [(p, None) for p in ptcls] for i in range(len(projs)): #sim=cmponetomany(pjs,ptcls[i],align=("rotate_translate_flip",{"maxshift":boxsize/5}),alicmp=("ccc",{}),ralign=("refine",{}),cmp=("frc",{"minres":80,"maxres":20})) sim = cmponetomany(pts, projs[i], align=("rotate_translate_tree", { "maxshift": boxsize / 5, "maxres": 20 }), alicmp=("ccc", {}), ralign=("refine", {}), cmp=("frc", { "minres": 80, "maxres": 20 })) bs = min(sim) bss += bs[0] n = sim.index(bs) # print n projs[i]["match_n"] = n projs[i]["match_qual"] = -bs[0] aptcls = [] #for i in range(len(ptcls)*3/4):# We used to include 3/4 of the particles for i in range(len(projs)): n = projs[i]["match_n"] quals.append(projs[i]["match_qual"]) aptcls.append(ptcls[n].align("rotate_translate_tree", projs[i], { "maxshift": boxsize / 5, "maxres": 20 }, "frc", {})) aptcls[-1].process_inplace("normalize.toimage", {"to": projs[i]}) #aptcls[-1].process_inplace("normalize") aptcls[-1]["match_n"] = i aptcls[-1].add(-aptcls[-1]["mean"]) aptcls[-1]["xform.projection"] = projs[i][ "xform.projection"] # best orientation set in the original return aptcls
def main(): progname = os.path.basename(sys.argv[0]) usage = """prog [options] <c input> <r input> <output> Computes a similarity matrix between c-input (col - projections) and r-input (row - particles) stacks of 2-D images. Images may optionally be aligned before comparison. Output is a matrix stored as an image with similarity value pairs. When used for classification, c input is the references and r input are the particles. More information on the output file can be found in the Wiki.""" parser = EMArgumentParser(usage=usage, version=EMANVERSION) #parser.add_argument("--apix", "-A", type=float, help="A/voxel", default=1.0) #parser.add_argument("--box", "-B", type=str, help="Box size in pixels, <xyz> or <x>,<y>,<z>") #parser.add_argument("--het", action="store_true", help="Include HET atoms in the map", default=False) parser.add_argument( "--align", type=str, help="The name of an 'aligner' to use prior to comparing the images", default=None) parser.add_argument( "--aligncmp", type=str, help="Name of the aligner along with its construction arguments", default="dot") parser.add_argument( "--ralign", type=str, help= "The name and parameters of the second stage aligner which refines the results of the first alignment", default=None) parser.add_argument( "--raligncmp", type=str, help= "The name and parameters of the comparitor used by the second stage aligner. Default is dot.", default="dot") parser.add_argument( "--cmp", type=str, help="The name of a 'cmp' to be used in comparing the aligned images", default="dot:normalize=1") parser.add_argument( "--prefilt", action="store_true", help= "Filter each reference (c) to match the power spectrum of each particle (r) before alignment and comparison", default=False) parser.add_argument("--prectf", action="store_true", help="Apply CTF to each projection before comparison", default=False) parser.add_argument( "--mask", type=str, help= "File containing a single mask image to apply after alignment, but before similarity comparison", default=None) parser.add_argument( "--colmasks", type=str, help= "File containing one mask for each column (projection) image, to be used when refining row (particle) image alignments.", default=None) parser.add_argument( "--range", type=str, help= "Range of images to process (c0,r0,c1,r1) c0,r0 inclusive c1,r1 exclusive", default=None) parser.add_argument( "--saveali", action="store_true", help= "Save alignment values, output is 5, c x r images instead of 1. Images are (score,dx,dy,da,flip). ", default=False) 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") # parser.add_argument("--lowmem",action="store_true",help="prevent the bulk reading of the reference images - this will save memory but potentially increase CPU time",default=False) parser.add_argument( "--init", action="store_true", help= "Initialize the output matrix file before performing 'range' calculations", default=False) parser.add_argument( "--fillzero", action="store_true", help= "Checks the existing output file, and fills only matrix elements which are exactly zero.", default=False) # parser.add_argument("--force", "-f",dest="force",default=False, action="store_true",help="Force overwrite the output file if it exists") parser.add_argument( "--exclude", type=str, default=None, help= "The named file should contain a set of integers, each representing an image from the input file to exclude. Matrix elements will still be created, but will be zeroed." ) parser.add_argument( "--shrink", type=float, default=None, help= "Optionally shrink the input particles by an integer amount prior to computing similarity scores. This will speed the process up." ) parser.add_argument( "--nofilecheck", action="store_true", help= "Turns file checking off in the check functionality - used by e2refine.py.", default=False) parser.add_argument("--check", "-c", action="store_true", help="Performs a command line argument check only.", 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("--parallel", type=str, help="Parallelism string", default=None) (options, args) = parser.parse_args() if len(args) < 3: parser.error("Input and output files required") if (options.check): options.verbose = 1 # turn verbose on if the user is only checking... options.reffile = args[0] options.datafile = args[1] options.outfile = args[2] error = check(options, True) if options.verbose > 0: if (error): print("e2simmx.py command line arguments test.... FAILED") else: print("e2simmx.py command line arguments test.... PASSED") if error: exit(1) if options.check: exit(0) if options.prectf: if options.prefilt: print("ERROR: may only specify one of prefilt or prectf") sys.exit(1) options.prefilt = 2 elif options.prefilt: options.prefilt = 1 else: options.prefilt = 0 E2n = E2init(sys.argv, options.ppid) if options.parallel: parsimmx = EMParallelSimMX(options, args, E2n) parsimmx.execute() # Region writing is used extensively, so we do the compression as a post-processing operation # compress_hdf(options.outfile,0) E2end(E2n) sys.exit(0) # just remove the file - if the user didn't specify force then the error should have been found in the check function if file_exists(options.outfile): # if (options.force): remove_file(options.outfile) options.align = parsemodopt(options.align) options.aligncmp = parsemodopt(options.aligncmp) options.ralign = parsemodopt(options.ralign) options.raligncmp = parsemodopt(options.raligncmp) options.cmp = parsemodopt(options.cmp) if options.exclude: try: excl = open(options.exclude, "r").readlines() excl = [int(i) for i in excl] excl = set(excl) except: print("Warning: exclude file failed") # it's ok if this fails clen = EMUtil.get_image_count(args[0]) rlen = EMUtil.get_image_count(args[1]) if options.init: a = EMData() a.set_size(clen, rlen, 1) a.to_zero() a.write_image(args[2], 0) if options.saveali: for i in range(1, 6): a.write_image(args[2], i) E2end(E2n) sys.exit(0) # Compute range in c and r if options.range: crange = options.range.split(",")[0:4:2] rrange = options.range.split(",")[1:4:2] crange[0] = int(crange[0]) crange[1] = int(crange[1]) rrange[0] = int(rrange[0]) rrange[1] = int(rrange[1]) else: crange = [0, clen] rrange = [0, rlen] # initialize output array mxout = [EMData()] mxout[0].set_attr(PROJ_FILE_ATTR, args[0]) mxout[0].set_attr(PART_FILE_ATTR, args[1]) mxout[0].set_size(crange[1] - crange[0], rrange[1] - rrange[0], 1) mxout[0].to_zero() if options.saveali: mxout.append(mxout[0].copy()) # dx mxout.append(mxout[0].copy()) # dy mxout.append(mxout[0].copy()) # alpha (angle) mxout.append(mxout[0].copy()) # mirror mxout.append(mxout[0].copy()) # scale if options.verbose > 0: print("Computing Similarities") # Read all c images, then read and compare one r image at a time cimgs = EMData.read_images(args[0], list(range(*crange))) if options.colmasks: cmimgs = EMData.read_images(options.colmasks, list(range(*crange))) cimgs = list(zip(cimgs, cmimgs)) else: for i in range(len(cimgs)): cimgs[i] = (cimgs[i], None) if options.shrink != None: # the check function guarantees that shrink is an integer greater than 1 #d = [ image.process("math.meanshrink",{"n":options.shrink}) for image in cimgs] #cimgs = d for image, imagem in cimgs: image.process_inplace("math.fft.resample", {"n": options.shrink}) if imagem != None: imagem.process_inplace("math.fft.resample", {"n": options.shrink}) # if (options.lowmem): rimg = EMData() # else: # rimages = EMData.read_images(args[1],range(*rrange)) # if options.shrink != None: # the check function guarantees that shrink is an integer greater than 1 # #d = [ image.process("math.meanshrink",{"n":options.shrink}) for image in rimages] # #rimages = d # # I chose this way in the end for memory efficiency. There's probably a better way to do it # for image in rimages: # image.process_inplace("math.meanshrink",{"n":options.shrink}) #dimages = EMData.read_images(args[1],range(*rrange)) #d = [ image.process_inplace("math.meanshrink",{"n":options.shrink}) for image in dimages] if options.mask == None: mask = None else: mask = EMData(options.mask, 0) for r in range(*rrange): if options.exclude and r in excl: continue if options.verbose > 0: print("%d/%d\r" % (r, rrange[1]), end=' ') sys.stdout.flush() # With the fillzero option, we only compute values where there is a zero in the existing matrix if options.fillzero: ss = EMData() ss.read_image(args[2], 0, False, Region(crange[0], r, crange[1] - crange[0] + 1, 1)) subset = [i for i in range(ss["nx"]) if ss[i, 0] == 0] else: subset = None # if ( options.lowmem ): rimg.read_image(args[1], r) if options.shrink != None: # the check function guarantees that shrink is an integer greater than rimg.process_inplace("math.fft.resample", {"n": options.shrink}) if mask != None: mask.process_inplace("math.fft.resample", {"n": options.shrink}) if mask != None: rimg.mult(mask) # cimgs are masked in cmponetomany # else: # rimg = rimages[r] E2progress(E2n, old_div(float(r - rrange[0]), (rrange[1] - rrange[0]))) shrink = options.shrink if options.verbose > 1: print("%d. " % r, end=' ') row = cmponetomany(cimgs, rimg, options.align, options.aligncmp, options.cmp, options.ralign, options.raligncmp, options.shrink, mask, subset, options.prefilt, options.verbose) for c, v in enumerate(row): if v == None: mxout[0].set_value_at(c, r, 0, -1.0e38) else: mxout[0].set_value_at(c, r, 0, v[0]) # This is to catch any NaNs - yes this is a problem but this is a temporary work around mxout[0].process_inplace("math.finite", {"to": 1e24}) if options.saveali: for c, v in enumerate(row): if v == None: mxout[1].set_value_at(c, r, 0, 0) mxout[2].set_value_at(c, r, 0, 0) mxout[3].set_value_at(c, r, 0, 0) mxout[4].set_value_at(c, r, 0, 0) mxout[5].set_value_at(c, r, 0, 0) else: mxout[1].set_value_at(c, r, 0, v[1]) mxout[2].set_value_at(c, r, 0, v[2]) mxout[3].set_value_at(c, r, 0, v[3]) mxout[4].set_value_at(c, r, 0, v[4]) mxout[5].set_value_at(c, r, 0, v[5]) if options.verbose > 0: print("\nSimilarity computation complete") # write the results into the full-sized matrix if crange == [0, clen] and rrange == [0, rlen]: for i, j in enumerate(mxout): j.write_image(args[2], i) # compress_hdf(args[2],0) else: for i, j in enumerate(mxout): j.write_image( args[2], i, IMAGE_UNKNOWN, 0, Region(crange[0], rrange[0], 0, crange[1] - crange[0], rrange[1] - rrange[0], 1)) E2end(E2n)