def scaleTemplates(self): reffile = os.path.join(self.params['rundir'], "references.hed") if self.params['apix'] != self.templatestack['apix']: scalefactor = float( self.templatestack['apix']) / self.params['apix'] templates = apImagicFile.readImagic(reffile) scaledtemplates = [] for templatearray in templates['images']: newarray = apTemplate.scaleTemplate(templatearray, scalefactor) scaledtemplates.append(newarray) apImagicFile.writeImagic(scaledtemplates, reffile) refbox = apFile.getBoxSize(reffile)[0] stbox = self.params['boxsize'] ### now clip the references to get identical boxsizes if stbox != refbox: while os.path.isfile(reffile + ".new.img"): apFile.removeStack(reffile + ".new.img") emancmd = "proc2d " + reffile + " " + reffile + ".new.hed clip=" + str( stbox) + " edgenorm" apParam.runCmd(emancmd, "EMAN") os.rename(reffile + ".new.hed", reffile) os.rename(reffile + ".new.img", reffile[:-4] + ".img") return
def assemblePngs(keys, tag, montagestack): apDisplay.printMsg("assembling pngs into montage") # get path from montagestack stackpath = os.path.dirname(os.path.abspath(montagestack)) montagecmd = "montage -geometry +4+4 " montagestackdata = apImagicFile.readImagic(montagestack) for i,key in enumerate(keys): if i % 20 == 0: sys.stderr.write(".") pngfile = key+".png" array = montagestackdata['images'][i] apImage.arrayToPng(array, pngfile, normalize=True, msg=False) #proccmd = "proc2d "+montagestack+" "+pngfile+" first="+str(i)+" last="+str(i) #apEMAN.executeEmanCmd(proccmd, verbose=False, showcmd=False) montagecmd += pngfile+" " apDisplay.printMsg("montaging") montagefile = os.path.join(stackpath,"montage"+tag+".png") montagecmd += montagefile apEMAN.executeEmanCmd(montagecmd, verbose=True) #rotatecmd = "mogrify -rotate 180 -flop "+montagefile #apEMAN.executeEmanCmd(rotatecmd, verbose=False) for key in keys: apFile.removeFile(key+".png") if not os.path.isfile(montagefile): apDisplay.printWarning("failed to create montage file")
def createAlignedStacks(self, partlist): stackid = self.params['stackid'] stackdata = apStack.getOnlyStackData(stackid) origstackfile = os.path.join(stackdata['path']['path'], stackdata['name']) imagesdict = apImagicFile.readImagic(origstackfile) i = 0 t0 = time.time() apDisplay.printMsg("rotating and shifting particles at "+time.asctime()) alignstack = [] while i < len(partlist): partimg = imagesdict['images'][i] partdict = partlist[i] partnum = i+1 #print partnum, partdict, partimg.shape if partdict['partnum'] != partnum: apDisplay.printError("particle shifting "+str(partnum)+" != "+str(partdict)) xyshift = (partdict['xshift'], partdict['yshift']) alignpartimg = apImage.xmippTransform(partimg, rot=partdict['inplane'], shift=xyshift, mirror=partdict['mirror']) alignstack.append(alignpartimg) i += 1 apDisplay.printMsg("rotate then shift %d particles in %s"%(i,apDisplay.timeString(time.time()-t0))) alignstackarray = numpy.asarray(alignstack) self.alignimagicfile = "alignstack.hed" apImagicFile.writeImagic(alignstackarray, self.alignimagicfile)
def createAlignedStacks(self, partlist): stackid = self.params['stackid'] stackdata = apStack.getOnlyStackData(stackid) origstackfile = os.path.join(stackdata['path']['path'], stackdata['name']) imagesdict = apImagicFile.readImagic(origstackfile) i = 0 t0 = time.time() apDisplay.printMsg("rotating and shifting particles at " + time.asctime()) alignstack = [] while i < len(partlist): partimg = imagesdict['images'][i] partdict = partlist[i] partnum = i + 1 #print partnum, partdict, partimg.shape if partdict['partnum'] != partnum: apDisplay.printError("particle shifting " + str(partnum) + " != " + str(partdict)) xyshift = (partdict['xshift'], partdict['yshift']) alignpartimg = apImage.xmippTransform(partimg, rot=partdict['inplane'], shift=xyshift, mirror=partdict['mirror']) alignstack.append(alignpartimg) i += 1 apDisplay.printMsg("rotate then shift %d particles in %s" % (i, apDisplay.timeString(time.time() - t0))) alignstackarray = numpy.asarray(alignstack) self.alignimagicfile = "alignstack.hed" apImagicFile.writeImagic(alignstackarray, self.alignimagicfile)
def getPartMeanTree(self, stackfile, ctfpartlist): ### read mean and stdev self.partmeantree = [] imgnum = 0 while imgnum < self.params['projcount']: apDisplay.printColor("Reading mean and standard deviation values for each particle", "cyan") ### loop over the particles and read data first = imgnum last = first + self.params['filesperdir'] if last >= self.params['projcount']: last = self.params['projcount'] imagicdata = apImagicFile.readImagic(stackfile, first=first+1, last=last) for i in range(last - first): partdata = ctfpartlist[imgnum] partarray = imagicdata['images'][i] # take abs of mean, because ctf whole image may become negative partmeandict = { 'partdata': partdata, 'mean': abs(partarray.mean()), 'stdev': partarray.std(), 'min': partarray.min(), 'max': partarray.max(), } if partmeandict['mean'] > 1.0e7: partmeandict['mean'] /= 1.0e7 if partmeandict['stdev'] > 1.0e7: partmeandict['stdev'] /= 1.0e7 if abs(partmeandict['stdev']) < 1.0e-6: apDisplay.printError("Standard deviation == 0 for particle %d in image %s"%(i,shortname)) self.partmeantree.append(partmeandict) imgnum += 1
def fillSimilarityMatrix(stackfile): ### Get initial correlation values ### this is really, really slow numpart = apFile.numImagesInStack(stackfile) similarfile = "similarities.dat" if os.path.isfile(similarfile): simf = open(similarfile, 'r') simlist = [] count = 0 for line in simf: count += 1 sline = line.strip() slist = sline.split() ccval = float(slist[2]) simlist.append(ccval) simf.close() apDisplay.printMsg("There are %d lines in the sim file: %s"%(count, similarfile)) if count == numpart*(numpart-1): ### we have a valid file already return similarfile, simlist ### read data and estimate time imagicdict = apImagicFile.readImagic(stackfile) partarray = imagicdict['images'] numpart = partarray.shape[0] boxsize = partarray.shape[1] #timeper = 27.0e-9 timeper = 17.0e-9 apDisplay.printMsg("Computing CC values in about %s" %(apDisplay.timeString(timeper*numpart**2*boxsize**2))) ### Computing CC values simf = open(similarfile, 'w') cctime = time.time() simlist = [] for i in range(0, numpart): if i % 100 == 99: sys.stderr.write(".") for j in range(i+1, numpart): ccval = self.getCCValue(partarray[i],partarray[j]) str1 = "%05d %05d %.10f\n" % (i+1, j+1, ccval) simf.write(str1) str2 = "%05d %05d %.10f\n" % (j+1, i+1, ccval) simf.write(str2) simlist.append(ccval) sys.stderr.write("\n") simf.close() del partarray del imagicdict['images'] apDisplay.printMsg("CC calc time: %s :: %s per part :: %s per part per pixel" %(apDisplay.timeString(time.time()-cctime), apDisplay.timeString((time.time()-cctime)/numpart**2), apDisplay.timeString((time.time()-cctime)/numpart**2/boxsize**2))) return similarfile, simlist
def calculateParticleStackStats(self, imgstackfile, boxedpartdatas): ### read mean and stdev partmeantree = [] t0 = time.time() imagicdata = apImagicFile.readImagic(imgstackfile) apDisplay.printMsg("gathering mean and stdev data") ### loop over the particles and read data for i in range(len(boxedpartdatas)): partdata = boxedpartdatas[i] partarray = imagicdata['images'][i] ### if particle stdev == 0, then it is all constant, i.e., a bad particle stdev = float(partarray.std()) if stdev < 1.0e-6: apDisplay.printError("Standard deviation == 0 for particle %d in image %s"%(i,self.shortname)) ### skew and kurtosis partravel = numpy.ravel(partarray) skew = float(stats.skew(partravel)) kurtosis = float(stats.kurtosis(partravel)) ### edge and center stats edgemean = float(ndimage.mean(partarray, self.edgemap, 1.0)) edgestdev = float(ndimage.standard_deviation(partarray, self.edgemap, 1.0)) centermean = float(ndimage.mean(partarray, self.edgemap, 0.0)) centerstdev = float(ndimage.standard_deviation(partarray, self.edgemap, 0.0)) self.summedParticles += partarray ### take abs of all means, because ctf whole image may become negative partmeandict = { 'partdata': partdata, 'mean': abs(float(partarray.mean())), 'stdev': stdev, 'min': float(partarray.min()), 'max': float(partarray.max()), 'skew': skew, 'kurtosis': kurtosis, 'edgemean': abs(edgemean), 'edgestdev': edgestdev, 'centermean': abs(centermean), 'centerstdev': centerstdev, } ### show stats for first particle """ if i == 0: keys = partmeandict.keys() keys.sort() mystr = "PART STATS: " for key in keys: if isinstance(partmeandict[key], float): mystr += "%s=%.3f :: "%(key, partmeandict[key]) print mystr """ partmeantree.append(partmeandict) self.meanreadtimes.append(time.time()-t0) return partmeantree
def fillSimilarityMatrix(stackfile, partnum, outfile): ### Get initial correlation values ### this is really, really slow numpart = apFile.numImagesInStack(stackfile) ### read data and estimate time imagicdict = apImagicFile.readImagic(stackfile, first=partnum) partarray = imagicdict["images"] numpart = partarray.shape[0] boxsize = partarray.shape[1] # timeper = 27.0e-9 timeper = 17.0e-9 apDisplay.printMsg( "Computing CC values in about %s" % (apDisplay.timeString(timeper * numpart ** 2 * boxsize ** 2)) ) ### Computing CC values simf = open(outfile, "w") cctime = time.time() for i in range(partnum, numpart): if i % 100 == 99: sys.stderr.write(".") for j in range(i + 1, numpart): ccval = self.getCCValue(partarray[i], partarray[j]) str1 = "%05d %05d %.10f\n" % (i + 1, j + 1, ccval) simf.write(str1) str2 = "%05d %05d %.10f\n" % (j + 1, i + 1, ccval) simf.write(str2) sys.stderr.write("\n") simf.close() del partarray del imagicdict["images"] apDisplay.printMsg( "CC calc time: %s :: %s per part :: %s per part per pixel" % ( apDisplay.timeString(time.time() - cctime), apDisplay.timeString((time.time() - cctime) / numpart ** 2), apDisplay.timeString((time.time() - cctime) / numpart ** 2 / boxsize ** 2), ) ) return
def fillSimilarityMatrix(stackfile, partnum, outfile): ### Get initial correlation values ### this is really, really slow numpart = apFile.numImagesInStack(stackfile) ### read data and estimate time imagicdict = apImagicFile.readImagic(stackfile, first=partnum) partarray = imagicdict['images'] numpart = partarray.shape[0] boxsize = partarray.shape[1] #timeper = 27.0e-9 timeper = 17.0e-9 apDisplay.printMsg( "Computing CC values in about %s" % (apDisplay.timeString(timeper * numpart**2 * boxsize**2))) ### Computing CC values simf = open(outfile, 'w') cctime = time.time() for i in range(partnum, numpart): if i % 100 == 99: sys.stderr.write(".") for j in range(i + 1, numpart): ccval = self.getCCValue(partarray[i], partarray[j]) str1 = "%05d %05d %.10f\n" % (i + 1, j + 1, ccval) simf.write(str1) str2 = "%05d %05d %.10f\n" % (j + 1, i + 1, ccval) simf.write(str2) sys.stderr.write("\n") simf.close() del partarray del imagicdict['images'] apDisplay.printMsg( "CC calc time: %s :: %s per part :: %s per part per pixel" % (apDisplay.timeString(time.time() - cctime), apDisplay.timeString((time.time() - cctime) / numpart**2), apDisplay.timeString( (time.time() - cctime) / numpart**2 / boxsize**2))) return
def readFileStats(self, filename): if filename[-4:] == ".mrc": ### mrc data = mrc.read(filename) mean = data.mean() stdev = data.std() elif filename[-4:] == ".hed" or filename[-4:] == ".img": ### imagic last = min(256,self.params['filesperdir']) data = apImagicFile.readImagic(filename, last=last)['images'] mean = data.mean() stdev = data.std() """ ### read mean and stdev parameters from original image data = EMAN.EMData() data.readImage(filename) mean = data.Mean() stdev = data.Sigma() """ return mean, stdev
def scaleTemplates(self): reffile = os.path.join(self.params['rundir'], "references.hed") if self.params['apix'] != self.templatestack['apix']: scalefactor = float(self.templatestack['apix']) / self.params['apix'] templates = apImagicFile.readImagic(reffile) scaledtemplates = [] for templatearray in templates['images']: newarray = apTemplate.scaleTemplate(templatearray, scalefactor) scaledtemplates.append(newarray) apImagicFile.writeImagic(scaledtemplates, reffile) refbox = apFile.getBoxSize(reffile)[0] stbox = self.params['boxsize'] ### now clip the references to get identical boxsizes if stbox != refbox: while os.path.isfile(reffile+".new.img"): apFile.removeStack(reffile+".new.img") emancmd = "proc2d "+reffile+" "+reffile+".new.hed clip="+str(stbox)+" edgenorm" apParam.runCmd(emancmd, "EMAN") os.rename(reffile+".new.hed", reffile) os.rename(reffile+".new.img", reffile[:-4]+".img") return
def mergeImageStackIntoBigStack(self, imgstackfile, imgdata): t0 = time.time() apDisplay.printMsg("filtering particles and adding to stack") # if applying a boxmask, write to a temporary file before adding to main stack bigimgstack = os.path.join(self.params['rundir'], self.params['single']) if self.params['boxmask'] is not None: bigimgstack = os.path.splitext(imgstackfile)[0]+"-premask.hed" ### here is the craziness ### step 1: read imgstackfile into memory imgstackmemmap = imagic.read(imgstackfile) ### when only particle is read it defaults to a 2D array instead of 3D array if len(imgstackmemmap.shape) < 3: imgstackmemmap = imgstackmemmap.reshape(1, imgstackmemmap.shape[0], imgstackmemmap.shape[1]) if self.params['debug'] is True: print "imgstackmemmap.shape", imgstackmemmap.shape apix = self.params['apix'] #apDatabase.getPixelSize(imgdata) boxshape = (self.boxsize, self.boxsize) processedParticles = [] for particle in imgstackmemmap: ### step 2: filter particles ### high / low pass filtering #if self.params['pixlimit']: # particle = imagefilter.pixelLimitFilter(particle, self.params['pixlimit']) if self.params['lowpass']: particle = imagefilter.lowPassFilter(particle, apix=apix, radius=self.params['lowpass']) if self.params['highpass']: particle = imagefilter.highPassFilter2(particle, self.params['highpass'], apix=apix) ### unless specified, invert the images if self.params['inverted'] is True: particle = -1.0 * particle if particle.shape != boxshape: if self.boxsize <= particle.shape[0] and self.boxsize <= particle.shape[1]: particle = imagefilter.frame_cut(particle, boxshape) else: apDisplay.printError("particle shape (%dx%d) is smaller than boxsize (%d)" %(particle.shape[0], particle.shape[1], self.boxsize)) ### step 3: normalize particles #self.normoptions = ('none', 'boxnorm', 'edgenorm', 'rampnorm', 'parabolic') #normalizemethod if self.params['normalizemethod'] == 'boxnorm': particle = imagenorm.normStdev(particle) elif self.params['normalizemethod'] == 'edgenorm': particle = imagenorm.edgeNorm(particle) elif self.params['normalizemethod'] == 'rampnorm': particle = imagenorm.rampNorm(particle) elif self.params['normalizemethod'] == 'parabolic': particle = imagenorm.parabolicNorm(particle) ### step 4: decimate/bin particles if specified ### binning is last, so we maintain most detail and do not have to deal with binned apix if self.params['bin'] > 1: particle = imagefun.bin2(particle, self.params['bin']) #from scipy.misc import toimage #toimage(particle).show() processedParticles.append(particle) ### step 5: merge particle list with larger stack apImagicFile.appendParticleListToStackFile(processedParticles, bigimgstack, msg=self.params['debug']) #remove original image stack from memory del imgstackmemmap del processedParticles t0 = time.time() # if applying boxmask, now mask the particles & append to stack if self.params['boxmask'] is not None: # normalize particles before boxing, since zeros in mask # can affect subsequent processing if not properly normalized apEMAN.executeEmanCmd("proc2d %s %s edgenorm inplace"%(bigimgstack,bigimgstack),showcmd=False) imgstack = apImagicFile.readImagic(bigimgstack, msg=False) maskstack = apImagicFile.readImagic(self.params['boxmaskf'],msg=False) for i in range(len(imgstack['images'])): imgstack['images'][i]*=maskstack['images'][i] maskedpartstack = os.path.splitext(imgstackfile)[0]+"-aftermask.hed" apImagicFile.writeImagic(imgstack['images'], maskedpartstack) bigimgstack = os.path.join(self.params['rundir'], self.params['single']) apEMAN.executeEmanCmd("proc2d %s %s flip"%(maskedpartstack,bigimgstack)) ### count particles bigcount = apFile.numImagesInStack(bigimgstack, self.boxsize/self.params['bin']) imgcount = apFile.numImagesInStack(imgstackfile, self.boxsize) ### append to particle log file partlogfile = os.path.join(self.params['rundir'], self.timestamp+"-particles.info") f = open(partlogfile, 'a') for i in range(imgcount): partnum = self.particleNumber + i + 1 line = str(partnum)+'\t'+os.path.join(imgdata['session']['image path'], imgdata['filename']+".mrc") f.write(line+"\n") f.close() self.mergestacktimes.append(time.time()-t0) return bigcount
def tiltPhaseFlipParticles(self, imgdata, imgstackfile, partdatas): apDisplay.printMsg("Applying per-particle CTF") ctfvalue = ctfdb.getBestTiltCtfValueForImage(imgdata) if ctfvalue is None: apDisplay.printError("Failed to get ctf parameters") apix = apDatabase.getPixelSize(imgdata) ctfimgstackfile = os.path.join(self.params['rundir'], apDisplay.short(imgdata['filename'])+"-ctf.hed") ampconst = ctfvalue['amplitude_contrast'] ### calculate defocus at given position dimx = imgdata['camera']['dimension']['x'] dimy = imgdata['camera']['dimension']['y'] CX = dimx/2 CY = dimy/2 if ctfvalue['tilt_axis_angle'] is not None: N1 = -1.0 * math.sin( math.radians(ctfvalue['tilt_axis_angle']) ) N2 = math.cos( math.radians(ctfvalue['tilt_axis_angle']) ) else: N1 = 0.0 N2 = 1.0 PSIZE = apix ### High tension on CM is given in kv instead of v so do not divide by 1000 in that case if imgdata['scope']['tem']['name'] == "CM": voltage = imgdata['scope']['high tension'] else: voltage = (imgdata['scope']['high tension'])/1000 # find cs cs = self.getCS(ctfvalue) imagicdata = apImagicFile.readImagic(imgstackfile, msg=False) ctfpartstack = [] for i in range(len(partdatas)): partdata = partdatas[i] prepartarray = imagicdata['images'][i] prepartmrc = "rawpart.dwn.mrc" postpartmrc = "ctfpart.dwn.mrc" apImage.arrayToMrc(prepartarray, prepartmrc, msg = False) ### calculate ctf based on position NX = partdata['xcoord'] NY = dimy-partdata['ycoord'] # reverse due to boxer flip DX = CX - NX DY = CY - NY DF = (N1*DX + N2*DY) * PSIZE * math.tan( math.radians(ctfvalue['tilt_angle']) ) ### defocus is in Angstroms DFL1 = abs(ctfvalue['defocus1'])*1.0e10 + DF DFL2 = abs(ctfvalue['defocus2'])*1.0e10 + DF DF_final = (DFL1+DFL2)/2.0 ### convert defocus to microns defocus = DF_final*-1.0e-4 ### check to make sure defocus is a reasonable value for applyctf self.checkDefocus(defocus, apDisplay.short(imgdata['filename'])) parmstr = ("parm=%f,200,1,%.3f,0,17.4,9,1.53,%i,%.1f,%f" %(defocus, ampconst, voltage, cs, apix)) emancmd = ("applyctf %s %s %s setparm flipphase" % (prepartmrc, postpartmrc, parmstr)) apEMAN.executeEmanCmd(emancmd, showcmd = False) ctfpartarray = apImage.mrcToArray(postpartmrc, msg=False) ctfpartstack.append(ctfpartarray) apImagicFile.writeImagic(ctfpartstack, ctfimgstackfile) return ctfimgstackfile
def createAlignedStacks(self, partlist, origstackfile): partperiter = min(4096,apImagicFile.getPartSegmentLimit(origstackfile)) numpart = len(partlist) if numpart < partperiter: partperiter = numpart t0 = time.time() imgnum = 0 stacklist = [] apDisplay.printMsg("rotating and shifting particles at "+time.asctime()) while imgnum < len(partlist): index = imgnum % partperiter if imgnum % 100 == 0: sys.stderr.write(".") if index == 0: ### deal with large stacks if imgnum > 0: sys.stderr.write("\n") stackname = "alignstack%d.hed"%(imgnum) apDisplay.printMsg("writing aligned particles to file "+stackname) stacklist.append(stackname) apFile.removeStack(stackname, warn=False) apImagicFile.writeImagic(alignstack, stackname, msg=False) perpart = (time.time()-t0)/imgnum apDisplay.printColor("particle %d of %d :: %s per part :: %s remain"% (imgnum+1, numpart, apDisplay.timeString(perpart), apDisplay.timeString(perpart*(numpart-imgnum))), "blue") alignstack = [] imagesdict = apImagicFile.readImagic(origstackfile, first=imgnum+1, last=imgnum+partperiter, msg=False) ### align particles partimg = imagesdict['images'][index] partdict = partlist[imgnum] partnum = imgnum+1 if partdict['partnum'] != partnum: apDisplay.printError("particle shifting "+str(partnum)+" != "+str(partdict)) xyshift = (partdict['xshift'], partdict['yshift']) alignpartimg = apImage.xmippTransform(partimg, rot=partdict['inplane'], shift=xyshift, mirror=partdict['mirror']) alignstack.append(alignpartimg) imgnum += 1 ### write remaining particle to file sys.stderr.write("\n") stackname = "alignstack%d.hed"%(imgnum) apDisplay.printMsg("writing aligned particles to file "+stackname) stacklist.append(stackname) apImagicFile.writeImagic(alignstack, stackname, msg=False) ### merge stacks alignimagicfile = "alignstack.hed" apFile.removeStack(alignimagicfile, warn=False) apImagicFile.mergeStacks(stacklist, alignimagicfile) #for stackname in stacklist: # emancmd = "proc2d %s %s"%(stackname, alignimagicfile) # apEMAN.executeEmanCmd(emancmd, verbose=False) filepart = apFile.numImagesInStack(alignimagicfile) if filepart != numpart: apDisplay.printError("number aligned particles (%d) not equal number expected particles (%d)"% (filepart, numpart)) for stackname in stacklist: apFile.removeStack(stackname, warn=False) ### summarize apDisplay.printMsg("rotated and shifted %d particles in %s"%(imgnum, apDisplay.timeString(time.time()-t0))) return alignimagicfile
def radonAlign(self, stackfile): """ performs the meat of the program aligning the particles and creating references """ ### FUTURE: only read a few particles into memory at one time imageinfo = apImagicFile.readImagic(stackfile, msg=False) imagelist = imageinfo['images'] reflist = self.createReferences(imagelist) radonimagelist = self.getRadons(imagelist) ### a pre-normalization value so the reference pixels do not overflow partperref = self.params['numpart'] / float(self.params['numrefs']) for iternum in range(self.params['numiter']): ### save references to a file apImagicFile.writeImagic(reflist, "reflist%02d.hed" % (iternum), msg=False) ### create Radon transforms for references radonreflist = self.getRadons(reflist) ### create empty references newreflist = [] newrefcount = [] shape = imagelist[0].shape for i in range(self.params['numrefs']): newrefcount.append(0) newreflist.append(numpy.zeros(shape)) ### get alignment parameters aligndatalist = [] cclist = [] t0 = time.time() for i in range(len(imagelist)): if i % 50 == 0: ### FUTURE: add time estimate sys.stderr.write(".") image = imagelist[i] radonimage = radonimagelist[i] aligndata = self.getBestAlignForImage(image, radonimage, reflist, radonreflist, None) #aligndatalist.append(aligndata) refid = aligndata['refid'] cclist.append(aligndata['bestcc']) ### create new references refimage = reflist[refid] alignedimage = self.transformImage(image, aligndata, refimage) newreflist[refid] += alignedimage / partperref newrefcount[refid] += 1 sys.stderr.write("\n") print "Alignment complete in %s" % ( apDisplay.timeString(time.time() - t0)) ### report median cross-correlation, it should get better each iter mediancc = numpy.median(numpy.array(cclist)) apDisplay.printMsg("Iter %02d, Median CC: %.8f" % (iternum, mediancc)) print newrefcount ### FUTURE: re-calculate Radon transform for particles with large shift ### new references are now the old references shape = reflist[0].shape reflist = [] for i in range(self.params['numrefs']): if newrefcount[i] == 0: ### reference with no particles -- just add noise apDisplay.printWarning("Reference %02d has no particles" % (i + 1)) ref = numpy.random.random(shape) else: ref = (newreflist[i] / newrefcount[i]) * partperref reflist.append(ref) return aligndatalist
def radonAlign(self, stackfile): """ performs the meat of the program aligning the particles and creating references """ ### FUTURE: only read a few particles into memory at one time imageinfo = apImagicFile.readImagic(stackfile, msg=False) imagelist = imageinfo['images'] reflist = self.createReferences(imagelist) radonimagelist = self.getRadons(imagelist) ### a pre-normalization value so the reference pixels do not overflow partperref = self.params['numpart'] / float(self.params['numrefs']) for iternum in range(self.params['numiter']): ### save references to a file apImagicFile.writeImagic(reflist, "reflist%02d.hed"%(iternum), msg=False) ### create Radon transforms for references radonreflist = self.getRadons(reflist) ### create empty references newreflist = [] newrefcount = [] shape = imagelist[0].shape for i in range(self.params['numrefs']): newrefcount.append(0) newreflist.append(numpy.zeros(shape)) ### get alignment parameters aligndatalist = [] cclist = [] t0 = time.time() for i in range(len(imagelist)): if i % 50 == 0: ### FUTURE: add time estimate sys.stderr.write(".") image = imagelist[i] radonimage = radonimagelist[i] aligndata = self.getBestAlignForImage(image, radonimage, reflist, radonreflist, None) #aligndatalist.append(aligndata) refid = aligndata['refid'] cclist.append(aligndata['bestcc']) ### create new references refimage = reflist[refid] alignedimage = self.transformImage(image, aligndata, refimage) newreflist[refid] += alignedimage/partperref newrefcount[refid] += 1 sys.stderr.write("\n") print "Alignment complete in %s"%(apDisplay.timeString(time.time()-t0)) ### report median cross-correlation, it should get better each iter mediancc = numpy.median(numpy.array(cclist)) apDisplay.printMsg("Iter %02d, Median CC: %.8f"%(iternum, mediancc)) print newrefcount ### FUTURE: re-calculate Radon transform for particles with large shift ### new references are now the old references shape = reflist[0].shape reflist = [] for i in range(self.params['numrefs']): if newrefcount[i] == 0: ### reference with no particles -- just add noise apDisplay.printWarning("Reference %02d has no particles"%(i+1)) ref = numpy.random.random(shape) else: ref = (newreflist[i] / newrefcount[i]) * partperref reflist.append(ref) return aligndatalist
if __name__ == "__main__": ### generate random image data shape = (128,128) partlist = [] for i in range(16): part = numpy.random.random(shape) part = ndimage.gaussian_filter(part, sigma=shape[0]/16) partlist.append(part) ### save original data apFile.removeStack("original.hed", warn=False) apImagicFile.writeImagic(partlist, "original.hed", msg=False) ### read and write with Appion apFile.removeStack("resave.hed", warn=False) imagic = apImagicFile.readImagic("original.hed", msg=False) partlist2 = imagic['images'] apImagicFile.writeImagic(partlist2, "resave.hed", msg=False) print "============\nCompare APPION IMAGIC" if not isSameStack(partlist, partlist2): print "Stacks are different" #sys.exit(1) ### read and write with EMAN mrc emanMrcToStack(partlist) imagic = apImagicFile.readImagic("emanmrc.hed", msg=False) partlist3 = imagic['images'] print "============\nCompare EMAN MRC" if not isSameStack(partlist, partlist3): print "Stacks are different" #sys.exit(1)
if __name__ == "__main__": ### generate random image data shape = (128, 128) partlist = [] for i in range(16): part = numpy.random.random(shape) part = ndimage.gaussian_filter(part, sigma=shape[0] / 16) partlist.append(part) ### save original data apFile.removeStack("original.hed", warn=False) apImagicFile.writeImagic(partlist, "original.hed", msg=False) ### read and write with Appion apFile.removeStack("resave.hed", warn=False) imagic = apImagicFile.readImagic("original.hed", msg=False) partlist2 = imagic['images'] apImagicFile.writeImagic(partlist2, "resave.hed", msg=False) print "============\nCompare APPION IMAGIC" if not isSameStack(partlist, partlist2): print "Stacks are different" #sys.exit(1) ### read and write with EMAN mrc emanMrcToStack(partlist) imagic = apImagicFile.readImagic("emanmrc.hed", msg=False) partlist3 = imagic['images'] print "============\nCompare EMAN MRC" if not isSameStack(partlist, partlist3): print "Stacks are different" #sys.exit(1)