def writeSetOfVolumes(volSet, volXml, volDir): """ Convert a SetOfVolumes to a xml file used by PyTom. The volumes will be converted to .mrc format if not are '.em' or '.mrc' Params: volSet: input SetOfVolumes. volXml: filename where to write the xml file. volDir: where to create links or copies (converted to mrc). """ # Add to the path the root to pytom backupPath = list(sys.path) addPyTomPaths() from pytom.basic.structures import Particle, ParticleList, Wedge, SingleTiltWedge from pytom.score.score import Score, PeakPrior, xcfScore from pytom.frm.FRMAlignment import FRMScore w = SingleTiltWedge() #s = PeakPrior() pl = ParticleList() ih = em.convert.ImageHandler() for vol in volSet: index, fn = vol.getLocation() convert = True # by default, convert, which is the save way if index == em.NO_INDEX: # means single volumes volName = os.path.basename(fn) if fn.endswith('.em') or fn.endswith('.mrc'): convert = False # we can just create a link in this case else: volName = 'volume_%03d.mrc' % vol.getObjId() volFn = os.path.join(volDir, volName) if convert: ih.convert(vol, volFn) else: pwutils.createLink(fn, volFn) # Make the volumes names relative to the xml file # where the programs will be executed volRel = os.path.relpath(volFn, os.path.dirname(volXml)) p = Particle() s = xcfScore() s.setValue(1.0) pytomInfo = getattr(vol, 'pytomInfo', None) if pytomInfo is None: p.setWedge(w) else: p.fromXML(pytomInfo.get()) # Get stored XML format from PyTom p.setFilename(volRel) p.setScore(s) pl.append(p) pl.toXMLFile(volXml) #pl.setWedgeAllParticles(w) sys.path = backupPath
def extractClassesFromPL(pl_name, class_names, output): from pytom.basic.structures import ParticleList pl = ParticleList() pl.fromXMLFile(pl_name) pls = pl.splitByClass() class_labels = class_names.split(',') res = ParticleList() for pp in pls: if pp[0].getClass() in class_labels: res += pp if output: res.toXMLFile(output) return res
def subTomoClust(particleListFilename, classifiedParticleListFilename, cccName, neig, nclass, verbose=False): """ subtomogram clustering using CCC and kmeans @param particleListFilename: particle list filename @type particleListFilename: str @param classifiedParticleListFilename: output particle list filename @type classifiedParticleListFilename: str @param cccName: Name of (Constrained) Correlation Coefficient (CCC) matrix @type cccName: str @param neig: number of eigenvectors @type neig: int @param nclass: number of classes @type nclass: int @author: FF Jan 2013 """ from pytom.basic.structures import ParticleList pl = ParticleList('.') pl.fromXMLFile(particleListFilename) if verbose: print("Particle List read in") ccc = readCCC(cccName) if verbose: print("CCC read in") coeffs, eigvalues = SVD_analysis(ccc) if verbose: print("Eigen analysis done") labels = kmeansCluster(coeff=coeffs, neig=neig, nclass=nclass) if verbose: print("kmeans clustering done") for (ipart, part) in enumerate(pl): part.setClass(className=str(labels[ipart])) if verbose: print("Class labels assigned") pl.toXMLFile(classifiedParticleListFilename) if verbose: print("File written")
def mirrorParticleList(particleList, outname, directory='./'): sizes = get_size(particleList, directory) if sizes == 'Failed': print( 'Mirroring particle coordinates did not succeed. Please ensure the paths to the origin tomogram are correct' ) return dimx, dimy, dimz = sizes tempPL = ParticleList() tempPL.fromXMLFile(particleList) for particle in tempPL: pp = particle.getPickPosition() pp.setX(dimx - pp.getX()) pp.setY(dimy - pp.getY()) pp.setZ(dimz - pp.getZ()) shift = particle.getShift() shift.invert() tempPL.toXMLFile(outname)
def convertCoords2PL(coordinate_files, particleList_file, subtomoPrefix=None, wedgeAngles=None, angleList=False): pl = ParticleList() for n, coordinate_file in enumerate(coordinate_files): wedgeAngle = wedgeAngles[2 * n:2 * (n + 1)] sourceInfo = pl.loadCoordinateFileHeader(coordinate_file) l2 = len(pl) pl.loadCoordinateFile(filename=coordinate_file, name_prefix=subtomoPrefix[n], wedgeAngle=wedgeAngle, sourceInfo=sourceInfo) try: cc = 180. / numpy.pi for i in range(len(pl) - l2): z1, z2, x = random.choice(angleList) pl[-i - 1].setRotation(rotation=Rotation( z1=z1 * cc, z2=z2 * cc, x=x * cc, paradigm='ZXZ')) except: pass pl.toXMLFile(particleList_file)
def start(self, job, verbose=False): """ start FRM job @param job: FRM job @type job: L{FRMJob} @param verbose: print stuff (default: False) @type verbose: C{bool} """ if self.mpi_id == 0: from pytom.basic.structures import ParticleList, Reference from pytom.basic.resolution import bandToAngstrom from pytom.basic.filter import lowpassFilter from math import ceil self.destination = job.destination new_reference = job.reference old_freq = job.freq new_freq = job.freq #print(f"reference = {job.reference}") #print(f"particlelist = {job.particleList}") print(f"iterations = {job.max_iter:d}") print(f"binning = {job.binning:d}") #print(f"mask = {job.mask}") #print(f"peak_offset= {job.peak_offset:f2.1}") print(f"destination= {job.destination:s}") print(f"freq cut = {job.freq:d}") # main node for i in range(job.max_iter): if verbose: print(self.node_name + ': starting iteration %d ...' % i) # construct a new job by updating the reference and the frequency new_job = FRMJob(job.particleList, new_reference, job.mask, job.peak_offset, job.sampleInformation, job.bw_range, new_freq, job.destination, job.max_iter - i, job.r_score, job.weighting, constraint=job.constraint, binning=job.binning) # distribute it self.distribute_job(new_job, verbose) # get the result back all_even_pre = None all_even_wedge = None all_odd_pre = None all_odd_wedge = None pl = ParticleList() for j in range(self.num_workers): result = self.get_result() pl += result.pl even_pre, even_wedge, odd_pre, odd_wedge = self.retrieve_res_vols( result.name) if all_even_pre: all_even_pre += even_pre all_even_wedge += even_wedge all_odd_pre += odd_pre all_odd_wedge += odd_wedge else: all_even_pre = even_pre all_even_wedge = even_wedge all_odd_pre = odd_pre all_odd_wedge = odd_wedge # write the new particle list to the disk pl.toXMLFile( os.path.join(job.destination, 'aligned_pl_iter' + str(i) + '.xml')) # create half sets even = self.create_average(all_even_pre, all_even_wedge) odd = self.create_average(all_odd_pre, all_odd_wedge) # apply symmetries before determine resolution even = job.symmetries.applyToParticle(even) odd = job.symmetries.applyToParticle(odd) resNyquist, resolutionBand, numberBands = self.determine_resolution( even, odd, job.fsc_criterion, None, job.mask, verbose) # write the half set to the disk even.write( os.path.join(self.destination, 'fsc_' + str(i) + '_even.em')) odd.write( os.path.join(self.destination, 'fsc_' + str(i) + '_odd.em')) # determine the resolution if verbose: print(self.node_name + ': determining the resolution ...') current_resolution = bandToAngstrom( resolutionBand, job.sampleInformation.getPixelSize(), numberBands, 1) if verbose: print( self.node_name + ': current resolution ' + str(current_resolution), resNyquist) # create new average all_even_pre += all_odd_pre all_even_wedge += all_odd_wedge average = self.create_average(all_even_pre, all_even_wedge) # apply symmetries average = job.symmetries.applyToParticle(average) # filter average to resolution and update the new reference average_name = os.path.join(self.destination, 'average_iter' + str(i) + '.em') # pl.average(average_name, True) average.write(average_name) new_reference = Reference(average_name) # low pass filter the reference and write it to the disk filtered = lowpassFilter(average, ceil(resolutionBand), ceil(resolutionBand) / 10) filtered_ref_name = os.path.join( self.destination, 'average_iter' + str(i) + '_res' + str(current_resolution) + '.em') filtered[0].write(filtered_ref_name) # if the position/orientation is not improved, break it # change the frequency to a higher value new_freq = int(ceil(resolutionBand)) + 1 if new_freq <= old_freq: if job.adaptive_res is not False: # two different strategies print( self.node_name + ': Determined resolution gets worse. Include additional %f percent frequency to be aligned!' % job.adaptive_res) new_freq = int((1 + job.adaptive_res) * new_freq) old_freq = new_freq else: # always increase by 1 print( self.node_name + ': Determined resolution gets worse. Increase the frequency to be aligned by 1!' ) new_freq = old_freq + 1 old_freq = new_freq else: old_freq = new_freq if new_freq >= numberBands: print(self.node_name + ': New frequency too high. Terminate!') break if verbose: print(self.node_name + ': change the frequency to ' + str(new_freq)) # send end signal to other nodes and terminate itself self.end(verbose) else: # other nodes self.run(verbose)
def updatePL(fnames, outnames, directory='', suffix='', wedgeangles=[], multiplypickpos=1, multiplyshift=None, new_center=[], sizeSubtomo=64, move_shift=False, binSubtomo=1, binRecon=1, rotation=[], anglelist='', mirror=False, tomogram_dir='./', convention='zxz'): if type(fnames) == str: fnames = [fnames] if type(outnames) == str: outnames = [outnames] try: wedgelen = len(wedgeangles) except: wedgelen = 0 for n, xmlfile in enumerate(fnames): tempPL = ParticleList() tempPL.fromXMLFile(xmlfile) for particle in tempPL: # Update directory to particle if directory: filename = os.path.join( directory, os.path.basename(particle.getFilename())) particle.setFilename(filename) # Add suffix to directory name in which particle is stored # e.g. suffix = _bin3 # --> Subtomograms/tomogram_000/particle_1.em will become Subtomograms/tomogram_000_bin3/particle_1.em if suffix: filename = particle.getFilename() filename = os.path.join( os.path.dirname(filename) + suffix, os.path.basename(filename)) particle.setFilename(filename) # Update wedge angles of angle1 and angle2 if wedgelen > n + 1: w = particle.getWedge() w.setWedgeAngles(wedgeangles[n * 2:n * 2 + 2]) # Multiply pick position if abs(multiplypickpos - 1) > 1E-3: pp = particle.getPickPosition() pp.scale(multiplypickpos) # Shift is multiply by the respective binning factor. if not (multiplyshift is None): shift = particle.getShift() shift.scale(multiplyshift) # Randomize the angles of all particles in particle list. if type(anglelist) == type(numpy.array([])): cc = 180. / numpy.pi import random z1, z2, x = random.choice(anglelist) particle.setRotation(rotation=Rotation( z1=z1 * cc, z2=z2 * cc, x=x * cc, paradigm='ZXZ')) shift = particle.getShift() angles = particle.getRotation().toVector(convention=convention) rot_particleList = R.from_euler(convention, angles, degrees=True) if new_center: new_center_vector = numpy.array(new_center) - sizeSubtomo // 2 new_center_vector_rotated = rot_particleList.apply( new_center_vector) shift.addVector(new_center_vector_rotated) if move_shift == True: pp = particle.getPickPosition() shift.scale(binSubtomo / binRecon) ss = shift.toVector() pp.setX(pp.getX() + ss[0]) pp.setY(pp.getY() + ss[1]) pp.setZ(pp.getZ() + ss[2]) particle.setPickPosition(pp) shift.scale(0.) #print(particle) # Combine rotations from particleList and rotation if rotation: rot_rotation = R.from_euler(convention, rotation, degrees=True) combined_rotation = rot_particleList * rot_rotation z1, x, z2 = combined_rotation.as_euler(convention, degrees=True) particle.setRotation( rotation=Rotation(z1=z1, z2=z2, x=x, paradigm='ZXZ')) if mirror: # Update shifts shift.scale(-1) particle.setShift(shift) # Update angles as well rotationT = particle.getRotation() rotationT.setZ1(-1 * rotationT.getZ1()) rotationT.setZ2(-1 * rotationT.getZ2()) rotationT.setX(-1 * rotationT.getX()) particle.setRotation(rotationT) tempPL.toXMLFile(outnames[n]) if mirror: mirrorParticleList(outnames[n], outnames[n], directory=tomogram_dir)
def start(self, job, verbose=False): if self.mpi_id == 0: from pytom.basic.structures import ParticleList, Reference from pytom.basic.resolution import bandToAngstrom from pytom.basic.filter import lowpassFilter from math import ceil # randomly split the particle list into 2 half sets if len(job.particleList.splitByClass()) != 2: import numpy as np n = len(job.particleList) labels = np.random.randint(2, size=(n, )) print(self.node_name + ': Number of 1st half set:', n - np.sum(labels), 'Number of 2nd half set:', np.sum(labels)) for i in range(n): p = job.particleList[i] p.setClass(labels[i]) self.destination = job.destination new_reference = job.reference old_freq = job.freq new_freq = job.freq # main node for i in range(job.max_iter): if verbose: print(self.node_name + ': starting iteration %d ...' % i) # construct a new job by updating the reference and the frequency new_job = FRMJob(job.particleList, new_reference, job.mask, job.peak_offset, job.sampleInformation, job.bw_range, new_freq, job.destination, job.max_iter - i, job.r_score, job.weighting) # distribute it self.distribute_job(new_job, verbose) # get the result back all_even_pre = None # the 1st set all_even_wedge = None all_odd_pre = None # the 2nd set all_odd_wedge = None pl = ParticleList() for j in range(self.num_workers): result = self.get_result() pl += result.pl pre, wedge = self.retrieve_res_vols(result.name) if self.assignment[result.worker_id] == 0: if all_even_pre: all_even_pre += pre all_even_wedge += wedge else: all_even_pre = pre all_even_wedge = wedge else: if all_odd_pre: all_odd_pre += pre all_odd_wedge += wedge else: all_odd_pre = pre all_odd_wedge = wedge # write the new particle list to the disk pl.toXMLFile('aligned_pl_iter' + str(i) + '.xml') # create the averages separately if verbose: print(self.node_name + ': determining the resolution ...') even = self.create_average(all_even_pre, all_even_wedge) odd = self.create_average(all_odd_pre, all_odd_wedge) # apply symmetries if any even = job.symmetries.applyToParticle(even) odd = job.symmetries.applyToParticle(odd) # determine the transformation between even and odd # here we assume the wedge from both sets are fully sampled from sh_alignment.frm import frm_align pos, angle, score = frm_align(odd, None, even, None, job.bw_range, new_freq, job.peak_offset) print(self.node_name + 'Transform of even set to match the odd set - shift: ' + str(pos) + ' rotation: ' + str(angle)) # transform the odd set accordingly from pytom_volume import vol, transformSpline from pytom.basic.fourier import ftshift from pytom_volume import reducedToFull from pytom_freqweight import weight transformed_odd_pre = vol(odd.sizeX(), odd.sizeY(), odd.sizeZ()) full_all_odd_wedge = reducedToFull(all_odd_wedge) ftshift(full_all_odd_wedge) odd_weight = weight( full_all_odd_wedge) # the funny part of pytom transformed_odd = vol(odd.sizeX(), odd.sizeY(), odd.sizeZ()) transformSpline(all_odd_pre, transformed_odd_pre, -angle[1], -angle[0], -angle[2], odd.sizeX() / 2, odd.sizeY() / 2, odd.sizeZ() / 2, -(pos[0] - odd.sizeX() / 2), -(pos[1] - odd.sizeY() / 2), -(pos[2] - odd.sizeZ() / 2), 0, 0, 0) odd_weight.rotate(-angle[1], -angle[0], -angle[2]) transformed_odd_wedge = odd_weight.getWeightVolume(True) transformSpline(odd, transformed_odd, -angle[1], -angle[0], -angle[2], odd.sizeX() / 2, odd.sizeY() / 2, odd.sizeZ() / 2, -(pos[0] - odd.sizeX() / 2), -(pos[1] - odd.sizeY() / 2), -(pos[2] - odd.sizeZ() / 2), 0, 0, 0) all_odd_pre = transformed_odd_pre all_odd_wedge = transformed_odd_wedge odd = transformed_odd # determine resolution resNyquist, resolutionBand, numberBands = self.determine_resolution( even, odd, job.fsc_criterion, None, job.mask, verbose) # write the half set to the disk even.write( os.path.join(self.destination, 'fsc_' + str(i) + '_even.em')) odd.write( os.path.join(self.destination, 'fsc_' + str(i) + '_odd.em')) current_resolution = bandToAngstrom( resolutionBand, job.sampleInformation.getPixelSize(), numberBands, 1) if verbose: print( self.node_name + ': current resolution ' + str(current_resolution), resNyquist) # create new average all_even_pre += all_odd_pre all_even_wedge += all_odd_wedge average = self.create_average(all_even_pre, all_even_wedge) # apply symmetries average = job.symmetries.applyToParticle(average) # filter average to resolution average_name = os.path.join(self.destination, 'average_iter' + str(i) + '.em') average.write(average_name) # update the references new_reference = [ Reference( os.path.join(self.destination, 'fsc_' + str(i) + '_even.em')), Reference( os.path.join(self.destination, 'fsc_' + str(i) + '_odd.em')) ] # low pass filter the reference and write it to the disk filtered = lowpassFilter(average, ceil(resolutionBand), ceil(resolutionBand) / 10) filtered_ref_name = os.path.join( self.destination, 'average_iter' + str(i) + '_res' + str(current_resolution) + '.em') filtered[0].write(filtered_ref_name) # if the position/orientation is not improved, break it # change the frequency to a higher value new_freq = int(ceil(resolutionBand)) + 1 if new_freq <= old_freq: if job.adaptive_res is not False: # two different strategies print( self.node_name + ': Determined resolution gets worse. Include additional %f percent frequency to be aligned!' % job.adaptive_res) new_freq = int((1 + job.adaptive_res) * old_freq) else: # always increase by 1 print( self.node_name + ': Determined resolution gets worse. Increase the frequency to be aligned by 1!' ) new_freq = old_freq + 1 old_freq = new_freq else: old_freq = new_freq if new_freq >= numberBands: print(self.node_name + ': New frequency too high. Terminate!') break if verbose: print(self.node_name + ': change the frequency to ' + str(new_freq)) # send end signal to other nodes and terminate itself self.end(verbose) else: # other nodes self.run(verbose)
def create_RandomParticleList(reffile, pl_filename='pl.xml', pdir='./testparticles', nparticles=10): """ @param reffile: reference file @type reffile: C{str} @param nparticles: number of particles (default: 10) @type nparticles: C{int} @param pl_filename: particle list filename @type pl_filename: C{str} @param pdir: particle directory @type pdir: C{str} @return: particleList @rtype: L{pytom.basic.ParticleList} """ from pytom.basic.structures import Particle, ParticleList, Rotation, Shift from pytom_volume import vol, rotate, shift, read from pytom.basic.transformations import general_transform_crop from pytom.simulation.whiteNoise import add as addNoise import random from os import mkdir from pytom.score.score import FLCFScore as score try: mkdir(pdir) except FileExistsError: print('directory ' + pdir + ' existed already - using this one') random.seed(0) pl = ParticleList(directory='./') ref = read(reffile) for ii in range(0, nparticles): rot = Rotation(random.uniform(0, 360), random.uniform(0, 360), random.uniform(0, 180)) shift = Shift(x=random.uniform(-5, 5), y=random.uniform(-5, 5), z=random.uniform(-5, 5)) rotvol = general_transform_crop(v=ref, rot=rot, shift=shift, scale=None, order=[0, 1, 2]) # add some noise noisy = addNoise(volume=rotvol, SNR=1) fname = pdir + '/particle_' + str(ii) + '.em' noisy.write(fname) p = Particle(filename=fname, rotation=rot, shift=shift, wedge=None, className=0, pickPosition=None, score=score, sourceInfo=None) p.setScoreValue(0.0) pl.append(particle=p) pl.setFileName(filename=pl_filename) pl.toXMLFile(filename=pl_filename) return pl
if wedgeangles: wedgeangles = wedgeangles.split(',') else: wedgeangle = [] if directory: fnames = [ line for line in glob.glob(os.path.join(directory, '*.xml')) if line.endswith('.xml') ] if XMLfnames: print(XMLfnames) fnames = XMLfnames.split(',') pl = ParticleList() if wedgeangles: wedgelen = len(wedgeangles) else: wedgelen = 0 for n, xmlfile in enumerate(fnames): tempPL = ParticleList() tempPL.fromXMLFile(xmlfile) for particle in tempPL: if not wedgelen > n + 1: continue w = particle.getWedge() w.setWedgeAngles(wedgeangles[n * 2:n * 2 + 2]) pl += tempPL a = pl.toXMLFile(outname)
from pytom.tools.parse_script_options import parse_script_options from pytom.basic.structures import ParticleList, SingleTiltWedge helper = ScriptHelper(sys.argv[0].split('/')[-1], # script name description='Set the same wedge to all the particles in the particle list.', authors='Yuxiang Chen', options=[ScriptOption(['-p'], 'Particle list', True, False), ScriptOption(['-w'], 'Wedge Angle (degree)', True, False), ScriptOption(['-o'], 'Output particle list', True, True), ScriptOption(['-h', '--help'], 'Help.', False, True)]) if len(sys.argv) == 1: print(helper) sys.exit() try: pl_name, wedge_angle, output, bHelp = parse_script_options(sys.argv[1:], helper) except: sys.exit() if bHelp is True: print(helper) sys.exit() pl = ParticleList() pl.fromXMLFile(pl_name) w = SingleTiltWedge(int(wedge_angle)) pl.setWedgeAllParticles(w) if output is None: pl.toXMLFile(pl_name) else: pl.toXMLFile(output)
def create_RandomParticleList(reffile, pl_filename='pl.xml', pdir='./testparticles', nparticles=10): """ @param reffile: reference file @type reffile: C{str} @param nparticles: number of particles (default: 10) @type nparticles: C{int} @param pl_filename: particle list filename @type pl_filename: C{str} @param pdir: particle directory @type pdir: C{str} @return: particleList @rtype: L{pytom.basic.ParticleList} """ from pytom.basic.structures import Particle, ParticleList, Rotation, Shift, Wedge from pytom_volume import vol, rotate, shift, read from pytom.basic.transformations import general_transform_crop from pytom.basic.functions import initSphere from pytom.simulation.whiteNoise import add as addNoise import random from os import mkdir from pytom.score.score import FLCFScore as score try: mkdir(pdir) except FileExistsError: print('directory ' + pdir + ' existed already - using this one') random.seed(0) a = 0 wedge = Wedge(wedgeAngles=[30.0, 30.0], cutoffRadius=50.0) pl = ParticleList(directory='./') ref1 = read(reffile) ref2 = initSphere(sizeX=ref1.sizeX(), sizeY=ref1.sizeY(), sizeZ=ref1.sizeZ(), radius=45) #ref2.write('testData/mask_45.em') parts = {0: ref1, 1: ref2} for ii in range(0, nparticles): if not ii % 2: ref = read(reffile) else: ref = initSphere(sizeX=ref1.sizeX(), sizeY=ref1.sizeY(), sizeZ=ref1.sizeZ(), radius=30, smooth=30 / 10) rot = Rotation(random.uniform(0, 360), random.uniform(0, 360), random.uniform(0, 180)) shift = Shift(x=a * random.uniform(-5, 5), y=a * random.uniform(-5, 5), z=a * random.uniform(-5, 5)) rotvol = general_transform_crop(v=ref, rot=rot, shift=shift, scale=None, order=[0, 1, 2]) # add some noise noisy = addNoise(volume=rotvol, SNR=1) fname = pdir + '/particle_' + str(ii) + '.em' #noisy.write( fname) p = Particle(filename=fname, rotation=rot, shift=shift, wedge=wedge, className=0, pickPosition=None, score=score, sourceInfo=None) p.setScoreValue(0.0) wg = p.getWedge().getWedgeObject() wg.apply(noisy, Rotation(0, 0, 0)).write(fname) pl.append(particle=p) pl.setFileName(filename=pl_filename) pl.toXMLFile(filename=pl_filename) return pl
from pytom.basic.structures import ParticleList alignmentList = 'AlignmentList-1.xml' particleList = 'alignedParticles.xml' pl = ParticleList() pl.fromAlignmentList(alignmentList) pl.toXMLFile(particleList)
dest_dir = '.' from pytom_volume import read, subvolume v = read(vol_filename) from pytom.basic.structures import ParticleList, Particle, WedgeInfo pl = ParticleList("./") pl.fromXMLFile(pl_filename) def regulaize(xx, dim): if xx*binning-radius < 0: if 2*radius > dim: raise Exception("Volume size to be cut is too big!") return 0 if xx*binning+radius > dim: if dim-2*radius < 0: raise Exception("Volume size to be cut is too big!") return dim-2*radius return xx*binning-radius res = ParticleList(dest_dir) for p in pl: x,y,z = p.getPickPosition().toVector() x = regulaize(int(x), v.sizeX()); y = regulaize(int(y), v.sizeY()); z = regulaize(int(z), v.sizeZ()) new_vol = subvolume(v, x, y, z, 2*radius, 2*radius, 2*radius) name = dest_dir+'/'+p.getFilename() new_vol.write(name) # write the subtomograms to the disk res.append(Particle(name, p.getRotation(), None, WedgeInfo(w), 1, p.getPickPosition(), p.getScore())) # append it to the particle list for alignment res.toXMLFile(dest_dir+'/'+res_name)
dir_name, name_prefix, wedge_angle, output, bHelp = parse_script_options( sys.argv[1:], helper) except: sys.exit() if bHelp is True: print(helper) sys.exit() if name_prefix is None: name_prefix = '' wedge_angle = float(wedge_angle) w = SingleTiltWedge(wedge_angle) pl = ParticleList() all_files = os.listdir(dir_name) for fname in all_files: p = None name_suffix = fname.split('.')[-1] if len(name_prefix): if name_prefix in fname and name_suffix in ['em', 'mrc']: p = Particle(dir_name + '/' + fname) else: if name_suffix in ['em', 'mrc']: p = Particle(dir_name + '/' + fname) if p is not None: pl.append(p) pl.setWedgeAllParticles(w) pl.toXMLFile(output)
for particle in res: newParticle = particle.toParticle() newParticle.setWedge(wedge) newParticle.setFilename(particlePath + newParticle.getFilename()) if scale != 1.0: pi = newParticle.getPickPosition() pi.setX(pi.getX() * scale) pi.setY(pi.getY() * scale) pi.setZ(pi.getZ() * scale) newParticle.setPickPosition(pi) pl.append(newParticle) pl.toXMLFile(plFilename) if motlFilename: from pytom.basic.structures import ParticleList pl = ParticleList() for newParticle in res: if scale != 1.0: pi = newParticle.getPickPosition() pi.setX(pi.getX() * scale) pi.setY(pi.getY() * scale) pi.setZ(pi.getZ() * scale) newParticle.setPickPosition(pi) pl.append(newParticle.toParticle())
print('Coordinate out of bounds (', x, y, z, ') for ') print(particle) print('Particle could not be cut out from origin volume!') print('') continue v = subvolume(vol, x, y, z, cubeSize, cubeSize, cubeSize) # faster this way newParticleList.append( particle) # this part should be inside the try block v.write(particle.getFilename()) except: print('Error for') print(particle) print('Particle could not be cut out from origin volume!') print('') continue if len(particleList) != len(newParticleList): new_plFilename = None if '/' in plFilename: new_plFilename = plFilename[:-4] + 'New.xml' else: new_plFilename = 'new_' + plFilename print( 'Length of particle list has been changed. The new particle list is saved as', new_plFilename) newParticleList.toXMLFile(new_plFilename)