Exemplo n.º 1
0
def shiftToCenter(infile, shiftfile, isEMAN=False):
    '''
	EMAN defines the rotation origin differently from other packages.
	Therefore, it needs to be recenterred according to the package
	after using EMAN proc3d rotation functions.
	'''
    # center of rotation for eman is not at length/2.
    if isEMAN:
        formatoffset = getEmanCenter()
        prefix = ''
    else:
        formatoffset = (0, 0, 0)
        prefix = 'non-'

    apDisplay.printMsg('Shifting map center for %sEMAN usage' % (prefix, ))
    # Find center of mass of the density map
    a = mrc.read(infile)
    t = a.mean() + 2 * a.std()
    numpy.putmask(a, a >= t, t)
    numpy.putmask(a, a < t, 0)
    center = ndimage.center_of_mass(a)
    offset = (center[0] + formatoffset[0] - a.shape[0] / 2,
              center[1] + formatoffset[1] - a.shape[1] / 2,
              center[2] + formatoffset[2] - a.shape[2] / 2)
    offset = (-offset[0], -offset[1], -offset[2])
    apDisplay.printMsg('Shifting map center by (x,y,z)=(%.2f,%.2f,%.2f)' %
                       (offset[2], offset[1], offset[0]))
    # shift the map
    a = mrc.read(infile)
    a = ndimage.interpolation.shift(a, offset)
    mrc.write(a, shiftfile)
    h = mrc.readHeaderFromFile(infile)
    mrc.update_file_header(shiftfile, h)
Exemplo n.º 2
0
def shiftToCenter(infile,shiftfile,isEMAN=False):
	'''
	EMAN defines the rotation origin differently from other packages.
	Therefore, it needs to be recenterred according to the package
	after using EMAN proc3d rotation functions.
	'''
	# center of rotation for eman is not at length/2.
	if isEMAN:
		formatoffset = getEmanCenter()
		prefix = ''
	else:
		formatoffset = (0,0,0)
		prefix = 'non-'

	apDisplay.printMsg('Shifting map center for %sEMAN usage' % (prefix,))
	# Find center of mass of the density map
	a = mrc.read(infile)
	t = a.mean()+2*a.std()
	numpy.putmask(a,a>=t,t)
	numpy.putmask(a,a<t,0)
	center = ndimage.center_of_mass(a)
	offset = (center[0]+formatoffset[0]-a.shape[0]/2,center[1]+formatoffset[1]-a.shape[1]/2,center[2]+formatoffset[2]-a.shape[2]/2)
	offset = (-offset[0],-offset[1],-offset[2])
	apDisplay.printMsg('Shifting map center by (x,y,z)=(%.2f,%.2f,%.2f)' % (offset[2],offset[1],offset[0]))
	# shift the map
	a = mrc.read(infile)
	a = ndimage.interpolation.shift(a,offset)
	mrc.write(a,shiftfile)
	h = mrc.readHeaderFromFile(infile)
	mrc.update_file_header(shiftfile,h)
Exemplo n.º 3
0
def testMRCImages():
        file1,file2 = sys.argv[1:3]
        print 'reading MRCs'
        image1 = mrc.read(file1)
        image2 = mrc.read(file2)
        image1 = imagefun.bin(image1, 4)
        image2 = imagefun.bin(image2, 4)
        print 'register...'
        #result = register(image1, image2, range()
        #result = register2(image1, image2, range(86,95))
        result = register2(image1, image2, range(90,91))
Exemplo n.º 4
0
def writeMrcStack(path, stackname, mrc_files, binning=1):
    apDisplay.printMsg("Writing MRC stack file... ")
    stackname = os.path.join(path, stackname)
    im = mrc.read(mrc_files[0])
    image = imagefun.bin(im, binning)
    mrc.write(image, stackname)
    del mrc_files[0]
    for mrcfile in mrc_files:
        im = mrc.read(mrcfile)
        image = imagefun.bin(im, binning)
        mrc.append(image, stackname)
def writeMrcStack(path, stackname, mrc_files, binning=1):
        apDisplay.printMsg("Writing MRC stack file... ")
        stackname = os.path.join(path, stackname)
        im = mrc.read(mrc_files[0])
        image = imagefun.bin(im, binning)
        mrc.write(image,stackname)
        del mrc_files[0]
        for mrcfile in mrc_files:
                im = mrc.read(mrcfile)
                image = imagefun.bin(im, binning)
                mrc.append(image, stackname)
Exemplo n.º 6
0
 def makeStack(self, tiltseries, mrc_files):
     stackname = self.getFilename(tiltseries) + '.st'
     stackname = os.path.join(self.settings['path'], stackname)
     im = mrc.read(mrc_files[0])
     image = imagefun.bin(im, int(self.settings['binning']))
     mrc.write(image, stackname)
     #shutil.copy(mrc_files[0], stackname)
     del mrc_files[0]
     for mrcfile in mrc_files:
         im = mrc.read(mrcfile)
         image = imagefun.bin(im, int(self.settings['binning']))
         mrc.append(image, stackname)
 def makeStack(self, tiltseries, mrc_files):
         stackname = self.getFilename(tiltseries) + '.st'
         stackname = os.path.join(self.settings['path'], stackname)
         im = mrc.read(mrc_files[0])
         image = imagefun.bin(im, int(self.settings['binning']))
         mrc.write(image,stackname)
         #shutil.copy(mrc_files[0], stackname)
         del mrc_files[0]
         for mrcfile in mrc_files:
                 im = mrc.read(mrcfile)
                 image = imagefun.bin(im, int(self.settings['binning']))
                 mrc.append(image, stackname)
 def averageStack(self, stackfile):
     avgfile = "avg.mrc"
     a = mrc.read(stackfile)
     a = np.sum(a, axis=0)
     a = (a - a.min()) / (a.max() - a.min())
     mrc.write(a, avgfile)
     return avgfile
 def load(self, filename=None):
         if filename is None:
                 filename = self.filename.get()
         try:
                 self.pluginpipeline.process(Image(mrc.read(filename)))
         except IOError:
                 self.logger.error('Load file "%s" failed' % filename)
Exemplo n.º 10
0
	def start(self):
		#def runCTFdisplayTools(imgdata, ctfvalues, opimagedir, fftpath=None, fftfreq=None):
		### RUN CTF DISPLAY TOOLS
		imgdata = {
			'filename': os.path.abspath(self.params['imagefile']),
			'image': mrc.read(self.params['imagefile']),
		}
		ctfdata = {
			'volts': self.params['kv']*1e3,
			'cs': self.params['cs'],
			'apix': self.params['apix'],
			'defocus1': self.params['defocus1']*1e-6,
			'defocus2': self.params['defocus2']*1e-6,
			'angle_astigmatism': self.params['astigangle'],
			'amplitude_contrast': self.params['ampcontrast'],
		}
		a = ctfdisplay.CtfDisplay()
		a.debug = self.params['debug']
		ctfdisplay.ctftools.debug = self.params['debug']
		ctfdisplaydict = a.CTFpowerspec(imgdata, ctfdata, None, None, True)
		if ctfdisplaydict is None:
			raise

		ctfdata['confidence_30_10'] = ctfdisplaydict['conf3010']
		ctfdata['confidence_5_peak'] = ctfdisplaydict['conf5peak']
		ctfdata['overfocus_conf_30_10'] = ctfdisplaydict['overconf3010']
		ctfdata['overfocus_conf_5_peak'] = ctfdisplaydict['overconf5peak']
		ctfdata['resolution_80_percent'] = ctfdisplaydict['res80']
		ctfdata['resolution_50_percent'] = ctfdisplaydict['res50']
		### override the confidence
		ctfdata['confidence'] = max(ctfdisplaydict['conf5peak'], ctfdisplaydict['conf3010'])

		return ctfdata
Exemplo n.º 11
0
def getImageFiles(imgtree, rawdir, link, copy):
    #This function should replace linkImageFiles in all calls (i.e. in tomoaligner.py and everywhere else)
    filenamelist = []
    newimgtree = []
    for imagedata in imgtree:
        #set up names
        imgpath = imagedata['session']['image path']
        presetname = imagedata['preset']['name']
        imgprefix = presetname + imagedata['filename'].split(presetname)[-1]
        imgname = imgprefix + '.mrc'
        filenamelist.append(imgprefix)
        destpath = os.path.join(rawdir, imgname)
        newimgtree.append(destpath)
        imgfullpath = os.path.join(imgpath, imagedata['filename'] + '.mrc')

        if link == "True":
            #create symlinks to files
            if os.path.islink(destpath):
                os.remove(destpath)
            if not os.path.isfile(destpath):
                os.symlink(imgfullpath, destpath)
        elif copy == "True":
            shutil.copy(imgfullpath, destpath)

            #Y-flip raw images, normalize them, and convert them to float32 because Protomo
            image = mrc.read(destpath)
            image = numpy.flipud(image)
            image = imagenorm.normStdev(image)
            image = numpy.float32(image)
            mrc.write(image, destpath)
        #else: just return values
    return filenamelist, newimgtree
Exemplo n.º 12
0
def makeProjection(filename, xsize=512):
    mrcpath = filename
    dirpath = os.path.dirname(mrcpath)
    apDisplay.printMsg("Reading 3D recon %s" % mrcpath)
    array = mrc.read(mrcpath)
    shape = array.shape
    xsize = min(xsize, shape[2])
    # default for full tomogram is XZY
    if shape[0] > shape[1]:
        renders = {
            "a": {"axis": 0, "axisname": "z"},
            "b": {"axis": 1, "axisname": "y"},
            "c": {"axis": 2, "axisname": "x"},
        }
    else:
        renders = {
            "a": {"axis": 1, "axisname": "y"},
            "b": {"axis": 0, "axisname": "z"},
            "c": {"axis": 2, "axisname": "x"},
        }
    keys = renders.keys()
    keys.sort()
    for key in keys:
        apDisplay.printMsg("project to axis %s" % renders[key]["axisname"])
        pictpath = os.path.join(dirpath, "projection" + key)
        axis = renders[key]["axis"]
        slice = numpy.sum(array[:, :, :], axis=axis) / (shape[axis])
        mrc.write(slice, pictpath + ".mrc")
        # adjust and shrink each image
        array2jpg(pictpath, slice, size=xsize)
	def applyEnvelope(self, inimage, outimage, scaleFactor=1, msg=False):
		"""
		input path to image and envelope, output amplitude-adjusted image
		"""

		if msg is True:
			apDisplay.printColor("now applying envelope function to: "+inimage, "cyan")

		if self.envamp is None:
			self.prepareEnvelope(scaleFactor)

		### read image
		im = mrc.read(inimage)

		### fourier transform
		imfft = self.real_fft2d(im)

		### mutliply real envelope function by image fft
		newfft = self.envamp * imfft

		### inverse transform
		newimg = self.inverse_real_fft2d(newfft)

		### normalize between 0 and 1
		newimg = (newimg-newimg.mean()) / newimg.std()

		### save image
		mrc.write(newimg, outimage)

		### workaround for now
		time.sleep(0.1)

		return
def makeMovie(filename, xsize=512):
    apDisplay.printMsg('Making movie', 'blue')
    mrcpath = filename
    dirpath = os.path.dirname(mrcpath)
    splitnames = os.path.splitext(mrcpath)
    rootpath = splitnames[0]
    apDisplay.printMsg('Reading 3D recon %s' % mrcpath)
    array = mrc.read(mrcpath)
    shape = array.shape
    xsize = min(xsize, shape[2])
    stats = {}
    # speed up stats calculation by projecting to axis 0 to reduce array dimension
    apDisplay.printMsg('Calculating stats...')
    slice = numpy.sum(array[:, :, :], axis=0) / shape[0]
    stats['std'] = slice.std()
    stats['mean'] = slice.mean()
    if shape[0] > shape[1]:
        renders = {
            'a': {
                'axis': 0,
                'axisname': 'z'
            },
            'b': {
                'axis': 1,
                'axisname': 'y'
            }
        }
    else:
        renders = {
            'a': {
                'axis': 1,
                'axisname': 'y'
            },
            'b': {
                'axis': 0,
                'axisname': 'z'
            }
        }
    keys = renders.keys()
    keys.sort()
    for key in keys:
        axis = renders[key]['axis']
        dimz = shape[axis]
        #generate a sequence of jpg images, each is an average of 5 slices
        apDisplay.printMsg('Making smoothed slices...')
        for i in range(0, dimz):
            pictpath = rootpath + '_avg%05d' % i
            ll = max(0, i - 2)
            hh = min(dimz, i + 3)
            if axis == 0:
                slice = numpy.sum(array[ll:hh, :, :], axis=axis) / (hh - ll)
            else:
                slice = numpy.sum(array[:, ll:hh, :], axis=axis) / (hh - ll)
            # adjust and shrink each image
            array2jpg(pictpath, slice, stats['mean'] - 8 * stats['std'],
                      stats['mean'] + 8 * stats['std'], xsize)
        apDisplay.printMsg('Putting the jpg files together to flash video...')
        moviepath = dirpath + '/minitomo%s' % key + '.flv'
        framepath = rootpath + '_avg*.jpg'
        apMovie.makeflv('jpg', framepath, moviepath)
 def makeDenoisedParticleJPGFrames(self,partdatas,shiftdata,shortname):
         '''
         Denoise the boxed particles and then read in the resulting frame stack of the particle for saving as movie frames.
         '''
         if not partdatas:
                 return
         if not self.is_dd_stack:
                 apDisplay.printError('Denoising works only with ddstack for now')
         imgdata = partdatas[0]['image']
         ddstackdir,stackfile = self.getDDStackDirFile(imgdata)
         framestacks = []
         for p,partdata in enumerate(partdatas):
                 # denoise within the particle box
                 col_start,row_start = apBoxer.getBoxStartPosition(imgdata,self.half_box,partdata, shiftdata)
                 row_end = row_start + self.boxsize
                 col_end = col_start + self.boxsize
                 roi = ((row_start,row_end),(col_start,col_end))
                 paramstr = self.denoise.setupKSVDdenoise(self.frameavg,self.firstframe,self.nframe,roi)
                 apDisplay.printMsg('denoise param string: %s' % paramstr)
                 self.denoise.makeDenoisedStack(ddstackdir, stackfile)
                 outputstackfile = '%s_%s.mrc' % (stackfile[:-4], paramstr)
                 framestacks.append(outputstackfile)
         for i,start_frame in enumerate(range(self.firstframe,self.nframe-self.frameavg-self.firstframe+1,self.framestep)):
                 for p,partdata in enumerate(partdatas):
                         array = mrc.read(os.path.join(self.params['rundir'],'results/mrc',framestacks[p]),i)
                         # bin is not used for now
                         movieframe_number = start_frame
                         self.saveFrameFromArray(array,shortname,p,movieframe_number)
Exemplo n.º 16
0
def getImageFiles(imgtree, rawdir, link, copy):
	#This function should replace linkImageFiles in all calls (i.e. in tomoaligner.py and everywhere else)
	filenamelist = []
	newimgtree=[]
	for imagedata in imgtree:
		#set up names
		imgpath=imagedata['session']['image path']
		presetname=imagedata['preset']['name']
		imgprefix=presetname+imagedata['filename'].split(presetname)[-1]
		imgname=imgprefix+'.mrc'
		filenamelist.append(imgprefix)
		destpath = os.path.join(rawdir,imgname)
		newimgtree.append(destpath)
		imgfullpath = os.path.join(imgpath,imagedata['filename']+'.mrc')

		if link == "True":
			#create symlinks to files
			if os.path.islink(destpath):
				os.remove(destpath)
			if not os.path.isfile(destpath):
				os.symlink(imgfullpath,destpath)
		elif copy == "True":
			shutil.copy(imgfullpath,destpath)	
			
			#Y-flip raw images, normalize them, and convert them to float32 because Protomo
			image=mrc.read(destpath)
			image=numpy.flipud(image)
			image=imagenorm.normStdev(image)
			image=numpy.float32(image)
			mrc.write(image,destpath)
		#else: just return values
	return filenamelist, newimgtree
Exemplo n.º 17
0
def getParticleContrastFromMrc(mrcfile):
    apDisplay.printMsg("Particle contrast determination is experimental")
    if not os.path.isfile(mrcfile):
        apDisplay.printWarning(
            "Could not determine particle contrast, mrc file not found")
        return None
    rawimage = mrc.read(mrcfile)
    boxSize = min(rawimage.shape) - 1
    innerNoise = boxSize / 2 / 20  #one-twentieth the box radius
    particleRadius = boxSize / 2 / 3 + 1  #one-third the box radius
    outerLimit = boxSize / 2 * 0.9  # 90% of the box radius
    radialData, densityData = ctftools.rotationalAverage(rawimage, full=True)

    # find indices for radial values
    innerNoiseIndex = numpy.searchsorted(radialData, innerNoise)
    partRadIndex = numpy.searchsorted(radialData, particleRadius)
    outerLimitIndex = numpy.searchsorted(radialData, outerLimit)
    maxDiam = radialData[-1]

    innerVal = numpy.median(densityData[innerNoiseIndex:partRadIndex])
    outerVal = numpy.median(densityData[outerLimitIndex:])
    #print innerMean, outerMean, mrcfile

    if debug is True:
        print "%d:%d and %d:%d" % (innerNoiseIndex, partRadIndex,
                                   outerLimitIndex, densityData.shape[0])
        print "inner density %.1f <> outer density %.1f" % (innerVal, outerVal)
        from matplotlib import pyplot
        pyplot.plot(radialData, densityData, 'ko-')
        pyplot.xlabel('Pixel Radius')
        pyplot.ylabel('Density')
        xmin, xmax, ymin, ymax = pyplot.axis()
        pyplot.axhline(y=innerVal,
                       xmin=innerNoise / xmax,
                       xmax=particleRadius / xmax,
                       linewidth=2,
                       color="blue",
                       linestyle='-')
        #pyplot.axhline(y=innerVal, xmax=particleRadius, linewidth=2, color="cyan", linestyle='-')
        #print innerVal, radialData[1], particleRadius
        pyplot.axhline(y=outerVal,
                       xmin=outerLimit / xmax,
                       xmax=maxDiam / xmax,
                       linewidth=2,
                       color="orange",
                       linestyle='-')
        #pyplot.axhline(y=outerVal, xmax=maxDiam, linewidth=2, color="orange", linestyle='-')
        #print outerVal, outerLimit, maxDiam
        pyplot.grid(True)
        pyplot.show()

    if innerVal > outerVal:
        apDisplay.printMsg(
            "Contrast determined as WHITE particles on black background")
        return "whiteOnBlack"
    else:
        apDisplay.printMsg(
            "Contrast determined as BLACK particles on white background")
        print "BLACK on white", mrcfile
        return "blackOnWhite"
Exemplo n.º 18
0
 def load(self, filename=None):
     if filename is None:
         filename = self.filename.get()
     try:
         self.pluginpipeline.process(Image(mrc.read(filename)))
     except IOError:
         self.logger.error('Load file "%s" failed' % filename)
    def combine_polished_stacks(self):

        oldmovieid = None
        nmic = 0
        for part in self.stackparts:
            self.dd.setImageData(part['particle']['image'])
            movieid = part['particle']['image'].dbid
            alignpairdata = self.dd.getAlignImagePairData(
                None, query_source=not self.dd.getIsAligned())
            if alignpairdata is False:
                apDisplay.printWarning(
                    'Image not used for nor a result of alignment.')

            if movieid != oldmovieid:
                ddstack = orig_dd_file = alignpairdata['source'][
                    'filename'] + "_lmbfgs.mrc"
                particlestack = os.path.join(self.params['rundir'],
                                             "Particles", ddstack)
                a = mrc.read(particlestack)
                apDisplay.printMsg("appending stack %s" % ddstack)
                if oldmovieid is None:
                    mrc.write(a, "polished.mrc")
                else:
                    mrc.append(a, "polished.mrc")
                oldmovieid = movieid
Exemplo n.º 20
0
	def processCTF(self, event):  # wxGlade: MyFrame.<event_handler>
		if self.checkCTFvalues() is False:
			event.Skip()
			return
		self.statbar.PushStatusText("Processing please wait...", 0)
		self.processButton.SetBackgroundColour(wx.Colour(255, 191, 191))
		self.Update()
		#self.statbar.SetBackgroundColour(wx.Colour(255, 191, 191))
		imgdata = {
			'filename': self.fullimagepath,
			'image': mrc.read(self.fullimagepath),
		}
		ctfdata = {
			'volts': self.voltValue.GetValue()*1e3,
			'cs': self.csValue.GetValue(),
			'apix': self.pixelSizeValue.GetValue(),
			'defocus1': self.defoc1Value.GetValue()*1e-6,
			'defocus2': self.defoc2Value.GetValue()*1e-6,
			'angle_astigmatism': self.angleValue.GetValue(),
			'amplitude_contrast': self.ampConValue.GetValue(),
		}
		a = ctfdisplay.CtfDisplay()
		ctfdisplaydict = a.CTFpowerspec(imgdata, ctfdata, None, None, True)
		self.statbar.PushStatusText("Finished", 0)
		self.processButton.SetBackgroundColour(wx.Colour(191, 255, 191))
		self.Update()
		
		self.showImages(ctfdisplaydict)

		event.Skip()
 def readUploadInfo(self,info=None):
         if info is None:
                 # example
                 info = ['test.mrc','2e-10','1','1','50000','-2e-6','120000']
         self.logger.info('reading image info')
         try:
                 self.uploadedInfo = {}
                 self.uploadedInfo['original filepath'] = os.path.abspath(info[0])
                 self.uploadedInfo['unbinned pixelsize'] = float(info[1])
                 self.uploadedInfo['binning'] = {'x':int(info[2]),'y':int(info[3])}
                 self.uploadedInfo['magnification'] = int(info[4])
                 self.uploadedInfo['defocus'] = float(info[5])
                 self.uploadedInfo['high tension'] = int(info[6])
                 if len(info) > 7:
                         self.uploadedInfo['stage a'] = float(info[7])*3.14159/180.0
                 # add other items in the dictionary and set to instrument in the function
                 # setInfoToInstrument if needed
         except:
                 #self.logger.exception('Bad batch file parameters')
                 raise
         try:
                 self.uploadedInfo['image'] = mrc.read(self.uploadedInfo['original filepath'])
         except IOError, e:
                 self.logger.exception('File %s not available for upload' % self.uploadedInfo['original filepath'])
                 raise
 def readUploadInfo(self, info=None):
     if info is None:
         # example
         info = ['test.mrc', '2e-10', '1', '1', '50000', '-2e-6', '120000']
     self.logger.info('reading image info')
     try:
         self.uploadedInfo = {}
         self.uploadedInfo['original filepath'] = os.path.abspath(info[0])
         self.uploadedInfo['unbinned pixelsize'] = float(info[1])
         self.uploadedInfo['binning'] = {
             'x': int(info[2]),
             'y': int(info[3])
         }
         self.uploadedInfo['magnification'] = int(info[4])
         self.uploadedInfo['defocus'] = float(info[5])
         self.uploadedInfo['high tension'] = int(info[6])
         if len(info) > 7:
             self.uploadedInfo['stage a'] = float(info[7]) * 3.14159 / 180.0
         # add other items in the dictionary and set to instrument in the function
         # setInfoToInstrument if needed
     except:
         #self.logger.exception('Bad batch file parameters')
         raise
     try:
         self.uploadedInfo['image'] = mrc.read(
             self.uploadedInfo['original filepath'])
     except IOError, e:
         self.logger.exception('File %s not available for upload' %
                               self.uploadedInfo['original filepath'])
         raise
	def applyEnvelope(self, inimage, outimage, scaleFactor=1, msg=False):
		"""
		input path to image and envelope, output amplitude-adjusted image
		"""

		if msg is True:
			apDisplay.printColor("now applying envelope function to: "+inimage, "cyan")

		if self.envamp is None:
			self.prepareEnvelope(scaleFactor)

		### read image
		im = mrc.read(inimage)

		### fourier transform
		imfft = self.real_fft2d(im)

		### mutliply real envelope function by image fft
		newfft = self.envamp * imfft

		### inverse transform
		newimg = self.inverse_real_fft2d(newfft)

		### normalize between 0 and 1
		newimg = (newimg-newimg.mean()) / newimg.std()

		### save image
		mrc.write(newimg, outimage)

		### workaround for now
		time.sleep(0.1)

		return
Exemplo n.º 24
0
	def medianVolume(self):
		volpath = os.path.join(self.params['rundir'], "volumes/*a.mrc")
		mrcfiles = glob.glob(volpath)
		volumes = []
		for filename in mrcfiles:
			if os.path.isfile(filename):
				vol = mrc.read(filename)
				print filename, vol.shape
				volumes.append(vol)
		volarray = numpy.asarray(volumes, dtype=numpy.float32)
		try:
			medarray = numpy.median(volarray, axis=0)
		except:
			medarray = numpy.median(volarray)
		medfile = os.path.join(self.params['rundir'], "volumes/medianVolume.mrc")
		print medfile, medarray.shape
		mrc.write(medarray, medfile)

		apix = apStack.getStackPixelSizeFromStackId(self.params['stackid'])
		sessiondata = apStack.getSessionDataFromStackId(self.params['stackid'])

		uploadcmd = ( ("uploadModel.py --projectid=%d --session=%s --file=%s "
				+"--apix=%.3f --sym=%s --name=satmedian-recon%d.mrc --res=30 --description='%s %d'")
			%(self.params['projectid'], sessiondata['name'], medfile, 
				apix, self.params['symmname'], self.params['reconid'],
				"SAT selected median volume for recon", self.params['reconid'], ) )
		apDisplay.printColor(uploadcmd, "purple")
		f = open("upload.sh", "w")
		f.write(uploadcmd+"\n")
		f.close()
        def medianVolume(self):
                volpath = os.path.join(self.params['rundir'], "volumes/*a.mrc")
                mrcfiles = glob.glob(volpath)
                volumes = []
                for filename in mrcfiles:
                        if os.path.isfile(filename):
                                vol = mrc.read(filename)
                                print filename, vol.shape
                                volumes.append(vol)
                volarray = numpy.asarray(volumes, dtype=numpy.float32)
                try:
                        medarray = numpy.median(volarray, axis=0)
                except:
                        medarray = numpy.median(volarray)
                medfile = os.path.join(self.params['rundir'], "volumes/medianVolume.mrc")
                print medfile, medarray.shape
                mrc.write(medarray, medfile)

                apix = apStack.getStackPixelSizeFromStackId(self.params['stackid'])
                sessiondata = apStack.getSessionDataFromStackId(self.params['stackid'])

                uploadcmd = ( ("uploadModel.py --projectid=%d --session=%s --file=%s "
                                +"--apix=%.3f --sym=%s --name=satmedian-recon%d.mrc --res=30 --description='%s %d'")
                        %(self.params['projectid'], sessiondata['name'], medfile, 
                                apix, self.params['symmname'], self.params['reconid'],
                                "SAT selected median volume for recon", self.params['reconid'], ) )
                apDisplay.printColor(uploadcmd, "purple")
                f = open("upload.sh", "w")
                f.write(uploadcmd+"\n")
                f.close()
Exemplo n.º 26
0
	def readFile(self, oldmrcfile):
		apDisplay.printMsg('Reading %s into memory' % oldmrcfile)
		imagearray = mrc.read(oldmrcfile)
		# invert image density
		if self.params['invert'] is True:
			imagearray *= -1.0
		return imagearray
Exemplo n.º 27
0
    def findLastCompletedIteration(self):
        ''' find the last iteration that finished in EMAN job, trying to make this more clever and look at actual volumes '''

        lastiter = 0
        if os.path.isdir(self.projmatchpath) is False:
            apDisplay.printError(
                "projection matching did not run. Please double check and restart the job"
            )

        files = glob.glob(
            os.path.join(self.projmatchpath, "threed.[0-9]*a.mrc"))
        if isinstance(files, list) and len(files) > 0:
            for file in files:
                m = re.search("[0-9]+", os.path.basename(file))
                iternum = int(m.group(0))
                if iternum > lastiter:
                    lastiter = iternum

        ### now open up in numpy and make sure that it's a valid file
        vol = mrc.read(
            os.path.join(self.projmatchpath, "threed.%da.mrc" % lastiter))
        if vol.mean() == 0 and vol.max() == 0 and vol.min() == 0:
            apDisplay.printError(
                "there is something wrong with your volumes, make sure that the refinement ran correctly"
            )
        else:
            apDisplay.printMsg("EMAN ran " + str(lastiter) + " iterations")

        return lastiter
Exemplo n.º 28
0
def shiftMRCStartToZero(filename):
    h = mrc.readHeaderFromFile(filename)
    if h['nxstart'] != 0 or h['nystart'] != 0:
        apDisplay.printMsg("Shifting image header start to zero on %s" %
                           (os.path.basename(filename)))
        a = mrc.read(filename)
        mrc.write(a, filename)
Exemplo n.º 29
0
def boxerRotate(imgfile, parttree, outstack, boxsize):
        """
        boxes the particles with expanded size,
        applies a rotation to particle,
        reduces boxsize to requested size,
        and saves them to a imagic file
        """
        # size needed is sqrt(2)*boxsize, using 1.5 to be extra safe
        bigboxsize = int(math.ceil(1.5*boxsize))
        imgarray = mrc.read(imgfile)
        bigboxedparticles = boxerMemory(imgarray, parttree, bigboxsize)
        
        boxedparticles = []
        boxshape = (boxsize,boxsize)
        apDisplay.printMsg("Rotating particles...")
        for i in range(len(bigboxedparticles)):
                if i % 10 == 0:
                        sys.stderr.write(".")
                bigboxpart = bigboxedparticles[i]
                partdict = parttree[i]
                ### add 90 degrees because database angle is from x-axis not y-axis
                angle = partdict['angle']+90.0
                rotatepart = ndimage.rotate(bigboxpart, angle=angle, reshape=False, order=1)
                boxpart = imagefilter.frame_cut(rotatepart, boxshape)
                boxedparticles.append(boxpart)
        sys.stderr.write("done\n")
        apImagicFile.writeImagic(boxedparticles, outstack)
        return True
Exemplo n.º 30
0
    def start(self):
        #get aligned stack id
        aligndata = appiondata.ApAlignStackData.direct_query(
            self.params['alignstackid'])
        xSizeVoxel = aligndata['boxsize']
        #get averaged image
        avgmrc = os.path.join(aligndata['path']['path'],
                              aligndata["avgmrcfile"])
        avg = mrc.read(avgmrc)
        tmpSpiderFile = "average.xmp"
        spider.write(avg, tmpSpiderFile)
        self.runFindCenter(tmpSpiderFile, xSizeVoxel)
        #get aligned stack
        alignStack = os.path.join(aligndata['path']['path'],
                                  aligndata["imagicfile"])
        tempFileNameforSpectra = self.runMakeSpectra(alignStack)

        #kerdensom will work with spectra output
        self.runKerdenSOM(tempFileNameforSpectra)
        self.createMontageInMemory()
        self.insertRotKerDenSOM()

        #apFile.removeFile(outdata)
        apFile.removeFilePattern("*.cod")
        apFile.removeFilePattern("*.err")
        apFile.removeFilePattern("*.his")
        apFile.removeFilePattern("*.inf")
        apFile.removeFilePattern("*.vs")
        apFile.removeFilePattern("*.xmp")
        apFile.removeFile(tempFileNameforSpectra)
Exemplo n.º 31
0
def boxMaskStack(bmstackf, partdatas, box, xmask, ymask, falloff, imask=None, norotate=False):
        from appionlib.apSpider import operations
        from appionlib import apEMAN
        import os

        # create blank image for mask using SPIDER
        maskfile = "boxmask.spi"
        operations.createBoxMask(maskfile,box,xmask,ymask,falloff,imask)

        # convert mask to MRC
        apEMAN.executeEmanCmd("proc2d boxmask.spi boxmask.mrc",verbose=False,showcmd=False)
        os.remove("boxmask.spi")

        maskarray = mrc.read("boxmask.mrc")

        # box particles
        maskedparts = []
        for i in range(len(partdatas)):
                if norotate is True:
                        rotatemask = maskarray
                else:
                        angle = (-partdatas[i]['angle'])-90
                        rotatemask = ndimage.rotate(maskarray, angle=angle, reshape=False, order=1)
                maskedparts.append(rotatemask)

        # write to stack
        apImagicFile.writeImagic(maskedparts, bmstackf)
        os.remove("boxmask.mrc")
        return bmstackf
Exemplo n.º 32
0
 def averageStack(self, stackfile):
     avgfile = 'avg.mrc'
     a = mrc.read(stackfile)
     a = np.sum(a, axis=0)
     a = (a - a.min()) / (a.max() - a.min())
     mrc.write(a, avgfile)
     return avgfile
Exemplo n.º 33
0
        def targetTestImage(self):
                usercheck = self.settings['user check']
                self.settings['user check'] = False
                filename = self.settings['test image']
                
                try:
                        image2 = mrc.read(filename)             
                        image = numpy.asarray(image2,dtype=numpy.float)
                        
                except:
                        self.logger.error('Failed to load test image')
                        raise
                        return
                self.setImage(image, 'Image')

                if self.handle is None:
                        self.handle = pymat.open()
                pymat.put(self.handle, 'image', image)

                imdata_id = 0

                pymat.put(self.handle, 'image_id',imdata_id)
        
                self.matlabFindTargets()

                self.settings['user check'] = usercheck
        def start(self):
                #get aligned stack id
                aligndata = appiondata.ApAlignStackData.direct_query(self.params['alignstackid'])
                xSizeVoxel = aligndata['boxsize']
                #get averaged image
                avgmrc = os.path.join(aligndata['path']['path'], aligndata["avgmrcfile"])
                avg = mrc.read(avgmrc)
                tmpSpiderFile="average.xmp"
                spider.write(avg, tmpSpiderFile)
                self.runFindCenter(tmpSpiderFile,xSizeVoxel)
                #get aligned stack
                alignStack = os.path.join(aligndata['path']['path'], aligndata["imagicfile"])
                tempFileNameforSpectra=self.runMakeSpectra(alignStack)

                #kerdensom will work with spectra output
                self.runKerdenSOM(tempFileNameforSpectra)
                self.createMontageInMemory()
                self.insertRotKerDenSOM()

                #apFile.removeFile(outdata)
                apFile.removeFilePattern("*.cod")
                apFile.removeFilePattern("*.err")
                apFile.removeFilePattern("*.his")
                apFile.removeFilePattern("*.inf")
                apFile.removeFilePattern("*.vs")
                apFile.removeFilePattern("*.xmp")
                apFile.removeFile(tempFileNameforSpectra)
Exemplo n.º 35
0
def filterAndChimera(density, res=30, apix=None, box=None, chimtype='snapshot',
		contour=None, zoom=1.0, sym='c1', color=None, silhouette=True, mass=None):
	"""
	filter volume and then create a few snapshots for viewing on the web
	"""
	if isValidVolume(density) is False:
		apDisplay.printError("Volume file %s is not valid"%(density))
	if box is None:
		boxdims = apFile.getBoxSize(density)
		box = boxdims[0]
	### if eotest failed, filter to 30
	if not res or str(res) == 'nan':
		res = 30
	### low pass filter the volume to 60% of reported res
	tmpf = os.path.abspath(density+'.tmp.mrc')
	density = os.path.abspath(density)
	filtres = 0.6*res
	shrinkby = 1
	if box is not None and box > 250:
		shrinkby = int(math.ceil(box/160.0))
		if box % (2*shrinkby) == 0:
			### box is divisible by shrink by
			lpcmd = ('proc3d %s %s apix=%.3f tlp=%.2f shrink=%d origin=0,0,0 norm=0,1'
				% (density, tmpf, apix, filtres, shrinkby))
		else:
			### box not divisible by shrink by, need a clip
			clip = math.floor(box/shrinkby/2.0)*2*shrinkby
			lpcmd = ('proc3d %s %s apix=%.3f tlp=%.2f shrink=%d origin=0,0,0 norm=0,1 clip=%d,%d,%d'
				% (density, tmpf, apix, filtres, shrinkby, clip, clip, clip))
	else:
		lpcmd = ('proc3d %s %s apix=%.3f tlp=%.2f origin=0,0,0 norm=0,1'
			% (density, tmpf, apix, filtres))
	apDisplay.printMsg("Low pass filtering model for images")
	proc = subprocess.Popen(lpcmd, shell=True)
	proc.wait()

	### flatten solvent
	vol = mrc.read(tmpf)
	numpy.where(vol < 0, 0.0, vol)
	mrc.write(vol, tmpf)
	del vol

	### contour volume to mass
	if mass is not None:
		setVolumeMass(tmpf, apix*shrinkby, mass)
		contour = 1.0

	### set pixelsize and origin
	recmd = "proc3d %s %s apix=%.3f origin=0,0,0"%(tmpf, tmpf, apix)
	proc = subprocess.Popen(recmd, shell=True)
	proc.wait()

	### render images
	renderSlice(density, box=box, tmpfile=tmpf, sym=sym)
	if chimtype != 'snapshot':
		renderAnimation(tmpf, contour, zoom, sym, color, silhouette, name=density)
	elif chimtype != 'animate':
		renderSnapshots(tmpf, contour, zoom, sym, color, silhouette, name=density)
	apFile.removeFile(tmpf)
Exemplo n.º 36
0
def read_mrc(filename):
    a = mrc.read(filename)
    info = {}
    info["array"] = a
    stats = arraystats.all(a)
    info["min"] = stats["min"]
    info["max"] = stats["max"]
    return info
Exemplo n.º 37
0
def getModelDimensions(mrcfile):
	print "calculating dimensions..."
	vol=mrc.read(mrcfile)
	(x,y,z)=vol.shape
	if x!=y!=z:
		apDisplay.printWarning("starting model is not a cube")
		return max(x,y,z)
	return x
Exemplo n.º 38
0
	def makeStack(self, tiltseries, mrc_files):
		stackname = self.getFilename(tiltseries) + '_stack.mrc'
		stackname = os.path.join(self.settings['path'], stackname)
		shutil.copy(mrc_files[0], stackname)

		for mrcfile in mrc_files:
			im = mrc.read(mrcfile)
			mrc.append(im, stackname)
Exemplo n.º 39
0
def read_mrc(filename):
    a = mrc.read(filename)
    info = {}
    info['array'] = a
    stats = arraystats.all(a)
    info['min'] = stats['min']
    info['max'] = stats['max']
    return info
Exemplo n.º 40
0
def read_mrc(filename):
	a = mrc.read(filename)
	info = {}
	info['array'] = a
	stats = arraystats.all(a)
	info['min'] = stats['min']
	info['max'] = stats['max']
	return info
Exemplo n.º 41
0
def boxer(imgfile, parttree, outstack, boxsize):
        """
        boxes the particles and saves them to a imagic file
        """
        imgarray = mrc.read(imgfile)
        boxedparticles = boxerMemory(imgarray, parttree, boxsize)
        apImagicFile.writeImagic(boxedparticles, outstack)
        return True
    def start(self):
        ### get volume files
        volumefiles = glob.glob(self.params['volumes'])
        if not volumefiles:
            apDisplay.printError("Could not find volumes, %s" %
                                 (self.params['volumes']))

        ### make list of all alignments to run
        cmdlist = []
        alignfiles = []
        for volfile in volumefiles:
            alignfile = "align-" + os.path.basename(volfile)
            alignfiles.append(alignfile)
            emancmd = "align3d %s %s %s " % (self.params['reference'], volfile,
                                             alignfile)
            if self.params['slow'] is True:
                emancmd += "slow "
            if self.params['noshrink'] is True:
                emancmd += "noshrink "
            #print emancmd
            cmdlist.append(emancmd)

        ### run several alignment commands in parallel
        apThread.threadCommands(cmdlist)

        ### average volumes together
        ref = mrc.read(self.params['reference'])
        average = numpy.zeros(ref.shape, dtype=numpy.float32)
        del ref
        count = 0
        for alignfile in alignfiles:
            if not os.path.isfile(alignfile):
                apDisplay.printWarning("aligned volume not found: %s" %
                                       (alignfile))
            aligned = mrc.read(alignfile)
            count += 1
            ### this assume all aligned volume have same box size
            average += aligned
            del aligned

        ### save average
        average /= count
        avgfile = os.path.abspath(self.params['average'])
        mrc.write(average, avgfile)
        apDisplay.printMsg("Wrote average file: " + avgfile)
Exemplo n.º 43
0
        def start(self):
                """
                this is the main component of the script
                where all the processing is done
                """

                imgarray = mrc.read(self.params['image'])
                if self.params['invert'] is True:
                        imgarray = -1.0*imgarray

                dogmaps = apDog.diffOfGaussParam(imgarray, self.params)
                rootname = os.path.splitext(self.params['image'])[0]
                pixdiam = self.params['diam']/self.params['apix']
                pixrad = pixdiam/2.0

                peaktreelist = []
                count = 0
                for dogmap in dogmaps:
                        count += 1

                        ### threshold maps and extract peaks
                        peaktree = apPeaks.findPeaksInMap(dogmap, thresh=self.params['thresh'],
                                pixdiam=pixdiam, count=count, olapmult=self.params["overlapmult"],
                                maxpeaks=self.params["maxpeaks"], maxsizemult=self.params["maxsizemult"],
                                msg=True, bin=1)

                        ### remove peaks from areas near the border of the image
                        peaktree = apPeaks.removeBorderPeaks(peaktree, pixdiam, 
                                dogmap.shape[0], dogmap.shape[1])

                        ### create a nice image of pick locations
                        mapfile = "%s-map%02d.jpg"%(rootname, count)
                        apPeaks.createPeakMapImage(peaktree, dogmap, imgname=mapfile, pixrad=pixrad)
                        imgfile = "%s-picks%02d.jpg"%(rootname, count)
                        apPeaks.subCreatePeakJpeg(imgarray, peaktree, pixrad, imgfile, bin=1)

                        peaktreelist.append(peaktree)

                ### merge list in a single set of particle picks
                imgdata = { 'filename': self.params['image'], }
                peaktree = apPeaks.mergePeakTrees(imgdata, peaktreelist, self.params, pikfile=False)

                ### throw away particles above maxthresh
                precount = len(peaktree)
                peaktree = apPeaks.maxThreshPeaks(peaktree, self.params['maxthresh'])
                postcount = len(peaktree)
                apDisplay.printMsg("Filtered %d particles above max threshold %.2f"
                        %(precount-postcount,self.params['maxthresh']))

                ### create final images with pick locations
                mapfile = "%s-finalmap.jpg"%(rootname)
                apPeaks.createPeakMapImage(peaktree, dogmap, imgname=mapfile, pixrad=pixrad)
                imgfile = "%s-finalpicks.jpg"%(rootname)
                apPeaks.subCreatePeakJpeg(imgarray, peaktree, pixrad, imgfile, bin=1)

                ### write output file
                self.writeTextFile(peaktree)
Exemplo n.º 44
0
def mrcToArray(filename, msg=True):
    """
	takes a numpy and writes a Mrc
	"""
    numer = mrc.read(filename)
    if msg is True:
        apDisplay.printMsg("reading MRC: "+apDisplay.short(filename)+\
         " size:"+str(numer.shape)+" dtype:"+str(numer.dtype))
    return numer
	def openImageFile(self, filename):
		self.filename = filename
		if filename is None:
			self.setImage(None)
		elif filename[-4:] == '.mrc':
			image = mrc.read(filename)
			self.setImage(image.astype(numpy.float32))
		else:
			self.setImage(Image.open(filename))
	def getImage(self, filename):
		if filename is None:
			image = None;
		elif filename[-4:] == '.mrc':
			image = mrc.read(filename)
			image = image.astype(numpy.float32)
		else:
			image = Image.open(filename)
		return image
 def readImage(self,filename,imagetype=None):
         imagedata = self.getImageFromDB(filename)
         if imagedata is None:
                 try:
                         orig = mrc.read(filename)
                         self.logger.exception('Read image not in session')
                 except Exception, e:
                         self.logger.exception('Read image failed: %s' % e[-1])
                         return
Exemplo n.º 48
0
 def readImage(self, filename):
         # convert to float
         image2 = mrc.read(filename)
         image = numpy.asarray(image2,dtype=numpy.float)
         
         if image.any():
                 self.setImage(image, 'Image')
         else:
                 self.logger.error('Can not load image')