def split_matrix(parId, iterator): x0 = -1 y0 = -1 z0 = -1 t0 = 0 for x in iterator: x0 = x[1][0] y0 = x[1][1] z0 = x[1][2] t0 += 1 vol10 = npy2vol(BC_vol1.value, 3) vol20 = npy2vol(BC_vol2.value, 3) boxhalf_x1 = BC_sizeX.value / 2 boxhalf_y1 = BC_sizeY.value / 2 boxhalf_z1 = BC_sizeZ.value / 2 vol1_sub = subvolume(vol10, x0 - boxhalf_x1, y0 - boxhalf_y1, z0 - boxhalf_z1, BC_sizeX.value, BC_sizeY.value, BC_sizeZ.value) vol2_sub = subvolume(vol20, x0 - boxhalf_x1, y0 - boxhalf_y1, z0 - boxhalf_z1, BC_sizeX.value, BC_sizeY.value, BC_sizeZ.value) avg1 = mean(vol1_sub) vol1_sub1 = hanning_taper(vol1_sub, avg1) avg2 = mean(vol2_sub) vol2_sub1 = hanning_taper(vol2_sub, avg2) res = fsc2_v(vol1_sub1, vol2_sub1, BC_fsc_criterion.value, BC_max_resolution.value, BC_pixelSize.value, x0, y0, z0) tup = (round(res,6), x0, y0, z0) del avg1, avg2, vol1_sub1, vol2_sub1 del vol1_sub, vol2_sub, res, vol10, vol20, boxhalf_x1, boxhalf_y1, boxhalf_z1, x0, y0, z0, t0 return tup
def theta_vol_projection(vol_src, theta): from pytom_volume import vol from pytom_volume import rotate from pytom_volume import subvolume from pytom_volume import sum vol_src_dim_x = vol_src.sizeX() vol_src_dim_y = vol_src.sizeY() vol_src_dim_z = vol_src.sizeZ() vol_dst = vol(vol_src_dim_x, vol_src_dim_y, vol_src_dim_z) vol_dst.setAll(0.0) rotate(vol_src, vol_dst, 270, 90, theta) vol_img = vol(vol_src_dim_x, vol_src_dim_y, 1) vol_img.setAll(0.0) for i in range(vol_src_dim_x): for j in range(vol_src_dim_y): vol_img.setV(sum(subvolume(vol_dst, i, j, 0, 1, 1, vol_src_dim_z)), i, j, 0) return vol_img
def convolutionCTF(volume, defocus, pixelSize=None, voltage=None, Cs=None, sigma=None): """ convolutionCTF: @param volume: input volume to be convolved with CTF @type volume: L{pytom_volume.vol} @param defocus: Negative value = underfocus (in microns) @param pixelSize: Size of pixels / voxels (in Anstroms) @param voltage: @param Cs: @param sigma: @return: CTF filtered volume @rtype L{pytom_volume.vol} @author: FF """ from pytom_volume import subvolume, complexRealMult from pytom.basic.fourier import ftshift, fft, ifft from pytom.basic.filter import volCTF dimX = volume.sizeX() dimY = volume.sizeY() dimZ = volume.sizeZ() ctf = volCTF(defocus, dimX, dimY, dimZ, pixelSize, voltage, Cs, sigma) filterCTF = subvolume(ftshift(ctf,inplace=False), 0, 0, 0, dimX, dimY, (dimZ/2)+1) filteredVolume = ifft( complexRealMult(fft(volume), filterCTF) ) return filteredVolume
def writeCroppedParticles(particleListName, output, center, cubesize): """ @param particleListName: name of particle list @type particleListName: str @param output: Name of output particles @type output: str @param center: center of output particles in template orientation @type center: list @param cubesize: Size of output particles in pixel @type cubesize: int """ from pytom.basic.structures import ParticleList, Particle, Shift from pytom_volume import transformSpline as transform from pytom_volume import subvolume, vol pl = ParticleList() pl.fromXMLFile(filename=particleListName) #copy particle list for list of cropped particles pl_new = pl.copy() pvol = pl[0].getVolume() sizeX = pvol.sizeX() sizeY = pvol.sizeY() sizeZ = pvol.sizeZ() pvol_ali = vol(sizeX, sizeY, sizeZ) subV = vol(cubesize, cubesize, cubesize) sub_startX = center[0]-cubesize/2 sub_startY = center[1]-cubesize/2 sub_startZ = center[2]-cubesize/2 if (sub_startX < 0) or (sub_startY < 0) or (sub_startZ < 0): raise ValueError('cubesize too large :(') for (ipart, part) in enumerate(pl): pvol_ali.setAll(0) subV.setAll(0) pvol = part.getVolume() rot = part.getRotation() rotinvert = rot.invert() shiftV = part.getShift() transform(pvol, pvol_ali, rotinvert[0], rotinvert[1], rotinvert[2], sizeX/2, sizeY/2, sizeZ/2, -shiftV[0], -shiftV[1], -shiftV[2], 0, 0, 0) # box out subvolume subV = subvolume(pvol_ali, sub_startX, sub_startY, sub_startZ, cubesize, cubesize, cubesize) transform(subV, subV, rot[0], rot[1], rot[2], cubesize/2, cubesize/2, cubesize/2, 0, 0, 0, 0, 0, 0) fname = part.getFilename() idx = fname.split('_')[-1].split('.')[0] nfname = output+'_'+idx+'.em' print("write file " + nfname) subV.write(nfname) pl_new[ipart].setFilename(newFilename=nfname) pl_new[ipart].setShift(shift=Shift(0,0,0)) return pl_new
def averagePlanes(volume, sliceStart, sliceEnd, sliceStep=1, axis='Z'): """ averagePlanes: @param volume: @param sliceStart: @param sliceEnd: @param axis: @author: """ from pytom_volume import subvolume planes = [] for i in range(sliceStart, sliceEnd, sliceStep): if axis == 'X': v = subvolume(volume, 0, 0, i, volume.sizeX(), volume.sizeY(), 1) planes.append(v) if axis == 'Y': v = subvolume(volume, 0, 0, i, volume.sizeX(), volume.sizeY(), 1) planes.append(v) if axis == 'Z': v = subvolume(volume, 0, 0, i, volume.sizeX(), volume.sizeY(), 1) planes.append(v) if len(planes) > 0: p = planes[0] for i in range(len(planes) - 1): p += planes[i + 1] return p else: raise RuntimeError( 'Could not select on single plane from your parameters.')
def transformFourierSpline(volume,z1,z2,x,shiftX,shiftY,shiftZ,twice=False): """ transformFourierSpline: Rotate and shift a volume in fourierspace @param volume: @param z1: @param z2: @param x: @param shiftX: Shift after rotation @param shiftY: Shift after rotation @param shiftZ: Shift after rotation @param twice: Zero pad volume into a twice sized volume and perform calculation there. @return: The transformed volume. @author: Yuxiang Chen and Thomas Hrabe """ from pytom.basic.fourier import fft, ifft, ftshift, iftshift from pytom_volume import vol, pasteCenter, subvolume, transformFourierSpline if z1 == 0 and z2 == 0 and x == 0: return vol(volume) if twice: # paste into a twice sized volume v = vol(volume.sizeX()*2, volume.sizeY()*2, volume.sizeZ()*2) pasteCenter(volume, v) else: v = volume fvol = fft(iftshift(v, inplace=False)) # these steps have to be done in python level because of the fft resF = transformFourierSpline(fvol,z1,z2,x,shiftX,shiftY,shiftZ) res = ftshift(ifft(resF),inplace=False) / v.numelem() # reverse it back if twice: # cut the center part back res = subvolume(res, (volume.sizeX()+1)/2, (volume.sizeY()+1)/2, (volume.sizeZ()+1)/2, volume.sizeX(), volume.sizeY(), volume.sizeZ()) return res
def particleVolume(particleList, templateVolume, dimX, dimY, dimZ, volume=None): from pytom_volume import vol, paste, rotate, subvolume if volume == None: volume = vol(dimX, dimY, dimZ) volume.setAll(0.0) for p in particleList: x = p.getPickPosition().getX() y = p.getPickPosition().getY() z = p.getPickPosition().getZ() z1 = p.getRotation().getZ1() z2 = p.getRotation().getZ2() x1 = p.getRotation().getX() tempTemplate = vol(templateVolume.sizeX(), templateVolume.sizeY(), templateVolume.sizeZ()) tempTemplate.setAll(0.0) rotate(templateVolume, tempTemplate, z1, z2, x1) tempTemplate = tempTemplate + subvolume( volume, int(x - templateVolume.sizeX() / 2), int(y - templateVolume.sizeY() / 2), int(z - templateVolume.sizeZ() / 2), templateVolume.sizeX(), templateVolume.sizeY(), templateVolume.sizeZ()) paste(tempTemplate, volume, int(x - templateVolume.sizeX() / 2), int(y - templateVolume.sizeY() / 2), int(z - templateVolume.sizeZ() / 2)) return volume
def parallelStart_splitVol(self, job, splitX, splitY, splitZ, verbose=True): """ """ self.parallelInit() import pytom_mpi mpi_myid = pytom_mpi.rank() if mpi_myid == 0: # manager # distribute the job to the workers and get the original size of the volume self.splitVolumes(job, splitX, splitY, splitZ, verbose) [vsizeX, vsizeY, vsizeZ] = self.jobInfo["originalSize"] # gather results and post processing from pytom_volume import vol volume = vol(vsizeX, vsizeY, vsizeZ) volume.setAll(0) orient = vol(vsizeX, vsizeY, vsizeZ) orient.setAll(0) i = 0 while i < splitX * splitY * splitZ: mpi_msgString = getMsgStr() msg = self.getResMsg(mpi_msgString) resFromWorker = self.resFromMsg(msg) if verbose == True: print("Manager: processing result from worker " + msg.getSender()) resV = resFromWorker.result.getVolume() resO = resFromWorker.orient.getVolume() jobID = resFromWorker.jobID [sizeX, sizeY, sizeZ] = self.jobInfo["splitSize"] [sub_start, start] = self.jobInfo[jobID] from pytom_volume import subvolume, putSubVolume sub_resV = subvolume(resV, sub_start[0], sub_start[1], sub_start[2], sizeX, sizeY, sizeZ) sub_resO = subvolume(resO, sub_start[0], sub_start[1], sub_start[2], sizeX, sizeY, sizeZ) putSubVolume(sub_resV, volume, start[0], start[1], start[2]) putSubVolume(sub_resO, orient, start[0], start[1], start[2]) i = i + 1 # write the final result back to the disk volume.write(self.name + '_res.em') orient.write(self.name + '_orient.em') # delete the temporary files on the disk import os files = os.listdir('.') for name in files: if 'job' in name and '.em' in name and not 'sum' in name and not 'sqr' in name: os.remove(name) # rename the result files name os.rename('node_0_res.em', 'scores{}{}.em'.format(suffix)) os.rename('node_0_orient.em', 'angles{}{}.em'.format(suffix)) # finishing, stop all workers self.parallelEnd(verbose) if verbose == True: print("Manager: end") else: # worker worker = PeakWorker() worker.parallelRun(verbose) pytom_mpi.finalise()
def summarize(self, result, jobID, verbose=True): """ summarize: Get the result and do the summarization accordingly.\ (Send back, or update result, or write to the disk). @param result: result @type result: L{pytom.localization.peak_job.PeakResult} @param jobID: ID of job @type jobID: integer """ resV = result[0] orientV = result[1] if self.jobInfoPool == {}: # leaf node assert self.backTo != None #self.parallelEnd(verbose) if not self.backTo is None: result = self.writeRes(resV, orientV, jobID) result.send(self.mpi_id, self.backTo) else: self.writeRes(resV, orientV, None) self.parallelEnd(verbose) return # non leaf node, update the result if self.jobInfoPool[jobID].splitType == "Ang": self.jobInfoPool[ "numDoneJobsA"] = self.jobInfoPool["numDoneJobsA"] + 1 offset = self.jobInfoPool[jobID].angleOffset # print self.name + ': JobID ' + str(jobID) + ' Offset ' + str(offset) orientV = orientV + offset if self.resVolA == None or self.resOrientA == None: from pytom_volume import vol self.resVolA = vol(resV.sizeX(), resV.sizeY(), resV.sizeZ()) self.resOrientA = vol(orientV.sizeX(), orientV.sizeY(), orientV.sizeZ()) self.resVolA.copyVolume(resV) self.resOrientA.copyVolume(orientV) else: from pytom_volume import updateResFromVol updateResFromVol(self.resVolA, resV, self.resOrientA, orientV) if self.jobInfoPool["numDoneJobsA"] == self.jobInfoPool[ "numJobsA"] and self.jobInfoPool["numJobsV"] > 0: self.summarize([self.resVolA, self.resOrientA], self.jobInfoPool[jobID].originalJobID, verbose) return elif self.jobInfoPool[jobID].splitType == "Vol": self.jobInfoPool[ "numDoneJobsV"] = self.jobInfoPool["numDoneJobsV"] + 1 [originX, originY, originZ] = self.jobInfoPool[jobID].origin if self.resVol == None or self.resOrient == None: from pytom_volume import vol [vsizeX, vsizeY, vsizeZ] = self.jobInfoPool[jobID].originalSize self.resVol = vol(vsizeX, vsizeY, vsizeZ) self.resVol.setAll(0) self.resOrient = vol(vsizeX, vsizeY, vsizeZ) self.resOrient.setAll(0) [vsizeX, vsizeY, vsizeZ] = self.jobInfoPool[jobID].originalSize [sizeX, sizeY, sizeZ] = self.jobInfoPool[jobID].splitSize sub_start = self.jobInfoPool[jobID].sub_start start = self.jobInfoPool[jobID].whole_start stepSizeX = min(vsizeX - sub_start[0], sizeX) stepSizeY = min(vsizeY - sub_start[1], sizeY) stepSizeZ = min(vsizeZ - sub_start[2], sizeZ) from pytom_volume import subvolume, putSubVolume sub_resV = subvolume(resV, sub_start[0], sub_start[1], sub_start[2], stepSizeX, stepSizeY, stepSizeZ) sub_resO = subvolume(orientV, sub_start[0], sub_start[1], sub_start[2], stepSizeX, stepSizeY, stepSizeZ) putSubVolume(sub_resV, self.resVol, start[0] - originX, start[1] - originY, start[2] - originZ) putSubVolume(sub_resO, self.resOrient, start[0] - originX, start[1] - originY, start[2] - originZ) else: raise RuntimeError("Unclear split type!") # if all results are there, write back to disk and return to high level if self.jobInfoPool["numDoneJobsA"] + self.jobInfoPool[ "numDoneJobsV"] == self.jobInfoPool[ "numJobsA"] + self.jobInfoPool["numJobsV"]: if self.jobInfoPool["numJobsV"] == 0: self.resVol = self.resVolA self.resOrient = self.resOrientA if self.backTo != None: result = self.writeRes(self.resVol, self.resOrient, self.jobInfoPool[jobID].originalJobID) if verbose == True: print(self.name + ': sending back result to ' + str(self.backTo)) result.send(self.mpi_id, self.backTo) else: # write the final result to the disk self.writeRes(self.resVol, self.resOrient) self.parallelEnd(verbose)
def subPixelPeak(scoreVolume, coordinates, cubeLength=8, interpolation='Spline', verbose=False): """ subPixelPeak: Will determine the sub pixel area of peak. Utilizes spline, fourier or parabolic interpolation. @param verbose: be talkative @type verbose: L{str} @param scoreVolume: The score volume @param coordinates: [x,y,z] coordinates where the sub pixel peak will be determined @param cubeLength: length of cube - only used for Spline and Fourier interpolation @type cubeLength: int (even) @param interpolation: interpolation type: 'Spline', 'Quadratic', or 'Fourier' @type interpolation: str @return: Returns [peakValue,peakCoordinates] with sub pixel accuracy last change: 02/07/2013 FF: 2D functionality added """ assert type( interpolation) == str, 'subPixelPeak: interpolation must be str' if (interpolation.lower() == 'quadratic') or (interpolation.lower() == 'parabolic'): (peakValue, peakCoordinates) = subPixelPeakParabolic(scoreVolume=scoreVolume, coordinates=coordinates, verbose=verbose) return [peakValue, peakCoordinates] if gpu: import cupy as xp else: import numpy as xp from pytom_volume import vol, subvolume, rescaleSpline, peak from pytom.basic.transformations import resize #extend function for 2D twoD = (scoreVolume.shape) == 2 cubeStart = cubeLength // 2 sizeX = scoreVolume.sizeX() sizeY = scoreVolume.sizeY() sizeZ = scoreVolume.sizeZ() if twoD: if (coordinates[0]-cubeStart < 1 or coordinates[1]-cubeStart < 1) or\ (coordinates[0]-cubeStart + cubeLength >= sizeX or coordinates[1]-cubeStart + cubeLength >= sizeY): if verbose: print( "SubPixelPeak: position too close to border for sub-pixel") return [ scoreVolume(coordinates[0], coordinates[1], coordinates[2]), coordinates ] subVolume = subvolume(scoreVolume, coordinates[0] - cubeStart, coordinates[1] - cubeStart, 0, cubeLength, cubeLength, 1) else: if (coordinates[0]-cubeStart < 1 or coordinates[1]-cubeStart < 1 or coordinates[2]-cubeStart < 1) or \ (coordinates[0]-cubeStart + cubeLength >= sizeX or coordinates[1]-cubeStart + cubeLength >= sizeY or \ coordinates[2]-cubeStart + cubeLength >= sizeZ): if verbose: print( "SubPixelPeak: position too close to border for sub-pixel") return [ scoreVolume(coordinates[0], coordinates[1], coordinates[2]), coordinates ] subVolume = subvolume(scoreVolume, coordinates[0] - cubeStart, coordinates[1] - cubeStart, coordinates[2] - cubeStart, cubeLength, cubeLength, cubeLength) #size of interpolated volume scaleSize = 10 * cubeLength #ratio between interpolation area and large volume scaleRatio = 1.0 * cubeLength / scaleSize #resize into bigger volume if interpolation == 'Spline': if twoD: subVolumeScaled = vol(scaleSize, scaleSize, 1) else: subVolumeScaled = vol(scaleSize, scaleSize, scaleSize) rescaleSpline(subVolume, subVolumeScaled) else: subVolumeScaled = resize(volume=subVolume, factor=10)[0] peakCoordinates = peak(subVolumeScaled) peakValue = subVolumeScaled(peakCoordinates[0], peakCoordinates[1], peakCoordinates[2]) #calculate sub pixel coordinates of interpolated peak peakCoordinates[ 0] = peakCoordinates[0] * scaleRatio - cubeStart + coordinates[0] peakCoordinates[ 1] = peakCoordinates[1] * scaleRatio - cubeStart + coordinates[1] if twoD: peakCoordinates[2] = 0 else: peakCoordinates[ 2] = peakCoordinates[2] * scaleRatio - cubeStart + coordinates[2] if (peakCoordinates[0] > scoreVolume.sizeX() or peakCoordinates[1] > scoreVolume.sizeY() or peakCoordinates[2] > scoreVolume.sizeZ()): if verbose: print( "SubPixelPeak: peak position too large :( return input value") #something went awfully wrong here. return regular value return [ scoreVolume(coordinates[0], coordinates[1], coordinates[2]), coordinates ] return [peakValue, peakCoordinates]
pi = particle.getPickPosition() try: x = int(pi.getX() - cubeSize / 2) y = int(pi.getY() - cubeSize / 2) z = int(pi.getZ() - cubeSize / 2) if x < cubeSize or y < cubeSize or z < cubeSize or\ x+cubeSize > volX or y+cubeSize > volY or z+cubeSize > volZ: 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'
def readSubvolumeFromFourierspaceFile(filename, sizeX, sizeY, sizeZ): """ readSubvolumeFromFourierspaceFile: This function is required when data \ (in real space) is read in binned mode and a related fourier space file like a wedge needs to be read alongside. Works only if fourier file is reduced complex without any shift applied. @param filename: The fourier space file name @param sizeX: X final size of subvolume if it was complete (what L{pytom.basic.structures.Wedge.returnWedgeVolume} with humanUnderstandable == True returns) @param sizeY: Y final size of subvolume if it was complete (what L{pytom.basic.structures.Wedge.returnWedgeVolume} with humanUnderstandable == True returns) @param sizeZ: Z final size of subvolume if it was complete (what L{pytom.basic.structures.Wedge.returnWedgeVolume} with humanUnderstandable == True returns) @return: A subvolume @author: Thomas Hrabe """ from pytom_volume import vol, subvolume, paste from pytom.basic.fourier import fourierSizeOperation [newX, newY, newZ] = fourierSizeOperation(sizeX, sizeY, sizeZ, reducedToFull=False) newVolume = vol(newX, newY, newZ) newVolume.setAll(0) newX = newX / 2 newY = newY / 2 if filename.__class__ == str: originalVolume = read(filename) elif filename.__class__ == vol: # open a backdoor for this function to take volumes, but # this should be rather an exception -> not fully documented originalVolume = filename else: raise TypeError('Filename must be a string') originalSizeX = int(originalVolume.sizeX()) originalSizeY = int(originalVolume.sizeY()) # the original volume is reduced complex without shift -> # zero frequency is in outer corner (0,0,0) # read a subvolume around every corner with a subvolume # of half x,y of the final volume with constant z if filename.__class__ == str: firstSubvolume = read(filename, subregion=[0, 0, 0, newX, newY, newZ]) else: firstSubvolume = subvolume(filename, 0, 0, 0, newX, newY, newZ) if filename.__class__ == str: secondSubvolume = read( filename, subregion=[originalSizeX - newX, 0, 0, newX, newY, newZ]) else: secondSubvolume = subvolume(filename, originalSizeX - newX, 0, 0, newX, newY, newZ) if filename.__class__ == str: thirdSubvolume = read( filename, subregion=[0, originalSizeY - newY, 0, newX, newY, newZ]) else: thirdSubvolume = subvolume(filename, 0, originalSizeY - newY, 0, newX, newY, newZ) if filename.__class__ == str: fourthSubvolume = read(filename, subregion=[ originalSizeX - newX, originalSizeY - newY, 0, newX, newY, newZ ]) else: fourthSubvolume = subvolume(filename, originalSizeX - newX, originalSizeY - newY, 0, newX, newY, newZ) # merge the volumes to the final volume paste(firstSubvolume, newVolume, 0, 0, 0) paste(secondSubvolume, newVolume, newX, 0, 0) paste(thirdSubvolume, newVolume, 0, newY, 0) paste(fourthSubvolume, newVolume, newX, newY, 0) return newVolume
def maskOut(self, mask, center, size): """ maskOut: Set part of mask volume to all zero. The region is specified by center and size. @param mask: volume that you handle with @type mask: L{pytom_volume.vol} @param center: center of the region @type center: [x,y,z] @param size: size of the region @type size: [sizeX, sizeY, sizeZ] or radius """ from pytom_volume import vol, putSubVolume if size.__class__ == list: p_sizeX = size[0] p_sizeY = size[1] p_sizeZ = size[2] elif size.__class__ == vol: mm = size p_sizeX = mm.sizeX() p_sizeY = mm.sizeY() p_sizeZ = mm.sizeZ() else: radius = size p_sizeX = radius * 2 p_sizeY = radius * 2 p_sizeZ = radius * 2 maskSize = [mask.sizeX(), mask.sizeY(), mask.sizeZ()] if maskSize < center: raise RuntimeError('Center out of range!') # [) # mask out double size. CHANGED!!! startX = int(center[0] - p_sizeX / 2) endX = int(center[0] + p_sizeX / 2) startY = int(center[1] - p_sizeY / 2) endY = int(center[1] + p_sizeY / 2) startZ = int(center[2] - p_sizeZ / 2) endZ = int(center[2] + p_sizeZ / 2) # only used for radius sub_startX = 0 sub_startY = 0 sub_startZ = 0 if startX < 0: sub_startX = -startX startX = 0 if endX > maskSize[0]: endX = maskSize[0] if startY < 0: sub_startY = -startY startY = 0 if endY > maskSize[1]: endY = maskSize[1] if startZ < 0: sub_startZ = -startZ startZ = 0 if endZ > maskSize[2]: endZ = maskSize[2] sizeX = endX - startX sizeY = endY - startY sizeZ = endZ - startZ if size.__class__ == list: subV = vol(sizeX, sizeY, sizeZ) subV.setAll(0) elif size.__class__ == vol: from pytom_volume import limit, subvolume subV = (mm - 1) / -1 limit(subV, 0.999, 0, 0, 0, True, False) subV = subvolume(subV, sub_startX, sub_startY, sub_startZ, sizeX, sizeY, sizeZ) tempV = subvolume(mask, startX, startY, startZ, sizeX, sizeY, sizeZ) subV = subV * tempV # AND operation else: from pytom_volume import initSphere, subvolume subV = vol(radius * 2, radius * 2, radius * 2) initSphere(subV, radius, 0, 0, radius, radius, radius) tempV = vol(radius * 2, radius * 2, radius * 2) tempV.setAll(1) subV = tempV - subV subV = subvolume(subV, sub_startX, sub_startY, sub_startZ, sizeX, sizeY, sizeZ) tempV = subvolume(mask, startX, startY, startZ, sizeX, sizeY, sizeZ) subV = subV * tempV # AND operation putSubVolume(subV, mask, startX, startY, startZ)
if not dest_dir: 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)
def _display(volume, sliceNumber=0, projectionAxis='z'): """ _display: Generate image for volume display @author: Thomas Hrabe @param volume: The image / volume @param sliceNumber: Slice number at which the volume will be cut @param projectionAxis: Defines the axis. Default is z, means you look on the xy plane. (x equals to 'yz' plane, y to 'xz') """ import Image from pytom_volume import min, max, mean, variance, limit, subvolume from math import sqrt if projectionAxis == 'x': size1 = volume.sizeY() size2 = volume.sizeZ() if projectionAxis == 'y': size1 = volume.sizeX() size2 = volume.sizeZ() if projectionAxis == 'z': size1 = volume.sizeX() size2 = volume.sizeY() img = Image.new('L', (size1, size2)) if sliceNumber > 0: if projectionAxis == 'x': volume = subvolume(volume, sliceNumber, 0, 0, 1, size1, size2) elif projectionAxis == 'y': volume = subvolume(volume, 0, sliceNumber, 0, size1, 1, size2) elif projectionAxis == 'z': volume = subvolume(volume, 0, 0, sliceNumber, size1, size2, 1) elif sliceNumber == 0 and volume.sizeZ() > 1: sliceNumber = int(volume.sizeZ() / 2) if projectionAxis == 'x': volume = subvolume(volume, sliceNumber, 0, 0, 1, size1, size2) elif projectionAxis == 'y': volume = subvolume(volume, 0, sliceNumber, 0, size1, 1, size2) elif projectionAxis == 'z': volume = subvolume(volume, 0, 0, sliceNumber, size1, size2, 1) minValue = min(volume) volume.shiftscale(-minValue, 1) maxValue = max(volume) if maxValue == 0: maxValue = 1 volume.shiftscale(0, 255.0 / maxValue) for i in range(size1): for j in range(size2): if projectionAxis == 'x': value = volume(0, i, j) elif projectionAxis == 'y': value = volume(i, 0, j) elif projectionAxis == 'z': value = volume(i, j, 0) img.putpixel((i, j), int(value)) return img
def _dspcub(volume, sigma=None, projectionAxis='z'): """ _dspcub: Creates a dspcub image dspcub2PNG: display z-slices in 2D image @param volume: The input volume @type volume: L{pytom_volume.vol} @parameter sigma: thresholding as multiples of standard deviation sigma @type sigma: float @param projectionAxis: Defines the axis. Default is z, means you look on the xy plane. (x equals to 'yz' plane, y to 'xz') @return: Image @rtype: Image @@author: Pia Unverdorben """ if volume.sizeZ() == 1: raise Exception('You can use ') import Image from pytom_volume import min, max, mean, variance, limit, subvolume from math import sqrt, ceil, floor sizeX = volume.sizeX() sizeY = volume.sizeY() sizeZ = volume.sizeZ() if projectionAxis == 'x': imagesPerRow = int(floor(sqrt(sizeX))) size1 = float(sizeX) sizeI = sizeY sizeJ = sizeZ elif projectionAxis == 'y': imagesPerRow = int(floor(sqrt(sizeY))) size1 = float(sizeY) sizeI = sizeX sizeJ = sizeZ elif projectionAxis == 'z': imagesPerRow = int(floor(sqrt(sizeZ))) size1 = float(sizeZ) sizeI = sizeX sizeJ = sizeY numberIterations = imagesPerRow * imagesPerRow if size1 < numberIterations: iterationSteps = float(numberIterations / size1) else: iterationSteps = float(size1 / numberIterations) iterationSteps = int(iterationSteps) if projectionAxis == 'x': img = Image.new('L', (sizeY * imagesPerRow, sizeZ * imagesPerRow)) elif projectionAxis == 'y': img = Image.new('L', (sizeX * imagesPerRow, sizeZ * imagesPerRow)) elif projectionAxis == 'z': img = Image.new('L', (sizeX * imagesPerRow, sizeY * imagesPerRow)) # normalize according to standard deviation if sigma is specified if sigma: meanv = mean(volume) stdv = sqrt(variance(volume, False)) minValue = meanv - float(sigma) * stdv maxValue = meanv + float(sigma) * stdv else: minValue = min(volume) maxValue = max(volume) for sliceNumber in range(0, numberIterations, iterationSteps): if projectionAxis == 'x': png = Image.new('L', (sizeY, sizeZ)) elif projectionAxis == 'y': png = Image.new('L', (sizeX, sizeZ)) elif projectionAxis == 'z': png = Image.new('L', (sizeX, sizeY)) (yvalue, xvalue) = divmod(sliceNumber, imagesPerRow) if projectionAxis == 'x': vol = subvolume(volume, sliceNumber, 0, 0, 1, sizeY, sizeZ) elif projectionAxis == 'y': vol = subvolume(volume, 0, sliceNumber, 0, sizeX, 1, sizeZ) elif projectionAxis == 'z': vol = subvolume(volume, 0, 0, sliceNumber, sizeX, sizeY, 1) vol.shiftscale(-minValue, 1) vol.shiftscale(0, 255 / maxValue) for i in range(sizeI): for j in range(sizeJ): if projectionAxis == 'x': value = vol(0, i, j) elif projectionAxis == 'y': value = vol(i, 0, j) elif projectionAxis == 'z': value = vol(i, j, 0) png.putpixel((i, j), int(value)) img.paste(png, (xvalue * sizeI, yvalue * sizeJ)) return img