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
Пример #2
0
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)
Пример #4
0
 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 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
Пример #9
0
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
Пример #10
0
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 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
Пример #14
0
	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
Пример #15
0
	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
Пример #16
0
	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
Пример #17
0
    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
Пример #18
0
	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)
Пример #20
0
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)