def fromFile(self, filename=None): from pytom.tompy.io import read from pytom.tools.files import checkFileExists filename = filename or self._filename if checkFileExists(filename): self._weight = read(filename) else: raise RuntimeError('PeakPrior: File ' + filename + ' not found')
def getTransformedVolume(self): from pytom.tompy.io import read from pytom.tompy.transform import translate3d, rotate3d v = read(self.filename) v2 = translate3d(v, -self.shift_x, -self.shift_y, -self.shift_z) v3 = rotate3d(v2, -self.rotation_psi, -self.rotation_phi, -self.rotation_the) return v3
def write_rotation_angles(filename, z1=0, z2=0, x=0): assert filename.endswith('.mrc') header = read_header(filename) header[43:46] = [z1, x, z2] data = read(filename) f = open(filename, 'wb') try: f.write(header.tostring()) f.write(data.tostring(order='F')) # fortran-order array finally: f.close()
def write_tilt_angle(filename, tilt_angle): emfile = filename.endswith('.em') * 1 header = read_header(filename) if emfile: header[42] = int(round(tilt_angle * 1000)) else: header[43] = tilt_angle data = read(filename) f = open(filename, 'wb') try: f.write(tostring(header)) f.write(data.tostring(order='F')) # fortran-order array finally: f.close()
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.tompy.io import read from pytom.basic.fourier import fourierSizeOperation [newX, newY, newZ] = fourierSizeOperation(sizeX, sizeY, sizeZ, reducedToFull=False) if filename.__class__ == str: originalVolume = read(filename) elif filename.__class__ == xp.array: # 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') originalVolume = xp.fft.fftshift(originalVolume, axes=(0, 1)) newVolume = originalVolume[sizeX // 2 - newX // 2:sizeX // 2 + newX // 2, sizeY // 2 - newY // 2:sizeY // 2 + newY // 2, :newZ] newVolume = xp.fft.fftshift(newVolume, axes=(0, 1)) return newVolume
def determineRotationCenter(particle, binning): """ determineRotationCenter: @param particle: The particle @type particle: Either L{pytom_volume.vol} or string specifying the particle file name @param binning: Binning factor @return: [centerX,centerY,centerZ] @author: GvdS """ if particle.__class__ == str: from pytom.tompy.io import read particle = read(particle) centerX = particle.shape[0] / 2.0 * (1.0 / float(binning)) centerY = particle.shape[1] / 2.0 * (1.0 / float(binning)) centerZ = particle.shape[2] / 2.0 * (1.0 / float(binning)) # # if binning > 1: # centerX = centerX - 0.25*(binning-1) # centerY = centerY - 0.25*(binning-1) # centerZ = centerZ - 0.25*(binning-1) return [centerX, centerY, centerZ]
#!/usr/bin/env pytom from pytom.tompy.io import read import sys import numpy as np a = read(sys.argv[1]) b = read(sys.argv[2]) a = np.angle(np.fft.fftshift(np.fft.fftn(a))) b = np.angle(np.fft.fftshift(np.fft.fftn(b))) d = np.abs(a - b) print(d.mean(), d.std(), d.min(), d.max()) import matplotlib matplotlib.use('Qt5Agg') from pylab import imshow, show d = d.squeeze() print(d.shape) imshow(d) show()
#!/usr/bin/env pytom from pytom.tompy.io import read import sys import numpy as np a = (read(sys.argv[1]).squeeze()) b = (read(sys.argv[2]).squeeze()) if len(sys.argv) > 3 and sys.argv[3] != 'plot' and int(sys.argv[3]) == 1: a = np.fft.fftshift(a, axes=(0, 1)) b = np.fft.fftshift(b, axes=(0, 1)) try: mask = read('mask.mrc') a = a * mask b = b * mask except Exception as e: print(e) mask = np.ones_like(a) #a = np.angle(np.fft.fftshift(np.fft.fftn(a))) #b = np.angle(np.fft.fftshift(np.fft.fftn(b))) d = np.abs(a - b) for e in [d]: print(e[mask > 1E-4].mean(), e[mask > 1E-4].std(), e.min(), e.max()) import matplotlib matplotlib.use('Qt5Agg')
options=options) if len(sys.argv) == 1: print(helper) sys.exit() try: filename, outname, numSTD, smooth, num_cycles, mask, help = parse_script_options( sys.argv[1:], helper) except Exception as e: print(e) sys.exit() if help is True: print(helper) sys.exit() if os.path.exists(filename): data = read(filename) else: print(helper) sys.exit() num_cycles = 2 if num_cycles is None else int(num_cycles) numStd = 1 if num_cycles is None else float(numSTD) smooth = 2 if smooth is None else float(smooth) if not mask is None: mask = read(mask) gen_mask_fsc(data, num_cycles, outname, numSTD, smooth, maskD=mask)
def CorrectProjection_proxy(fname, new_fname, p, metafile, gs, fs, binning_factor, rotation_angle): """ @param fname: filename @type fname: C{str} @param new_fname: @type new_fname: C{str} @param p: @param metafile: star-file with metadata (contains defoci (long-/short), astig agnle alpha, voltage, Cs, Amplitude-contrast, Imdim, PixelSpacing, Magnification @type metafile: C{str} @param gs: grid spacing [2,4,6,...] is the size of the area which is corrected with a constant ctf. The ctf value is taken from the center of this area. This area builds up the corrected projection. @param fs: fieldsize [2,4,6,...] & (fs>=gs) is the size of the area which is extracted from the projection and corrected with a constant ctf. Fieldsize is also the size of the modelled ctf. @param binning_factor: de-magnfication factor @type binning_factor: C{float} @param rotation_angle: @return: """ print('Correct projection:', fname) # load the metadata #from numpy import loadtxt from pytom.gui.guiFunctions import loadstar metadata = loadstar(metafile, dtype=datatype) # Alignment parameter Tiltangles = metadata['TiltAngle'] Tiltaxis = rotation_angle directions = {0: 'horizontal', 1: 'vertical'} direction = directions[int(np.around(Tiltaxis / 90)) % 2] dz1 = metadata['DefocusU'] dz2 = metadata['DefocusV'] alpha = metadata['DefocusAngle'] Voltage = metadata['Voltage'][p] Cs = metadata['SphericalAberration'][p] A = metadata['AmplitudeContrast'][p] Imdim = metadata['ImageSize'][p] if Imdim == 0: Imdim = 3710 Objectpixelsize = metadata['PixelSpacing'][p] * 0.1 * binning_factor from pytom.tompy.io import read, write # Load projection proj = np.array(read(fname)) proj = np.squeeze(proj) # squeeze it to 2D # Create defocus plane dz1 dz1p = CalculateDefocusModel(dz1[p], Objectpixelsize, Imdim, Tiltangles[p], Tiltaxis) # Create defocus plane dz2 dz2p = CalculateDefocusModel(dz2[p], Objectpixelsize, Imdim, Tiltangles[p], Tiltaxis) # Create astigmatism angle plane alphap = (alpha[p] + Tiltaxis) * np.ones((Imdim, Imdim)) # !!! ADDED Tiltaxis(1,p) to astigmatsm angle to correct for Tiltaxis rotation during CTF determination !!! -- SP 7.7.16 # originally: alphap = alpha[p]*np.ones((Imdim,Imdim)) projc = CorrectProjection(proj, dz1p, dz2p, alphap, gs, fs, Objectpixelsize, Voltage, Cs, A, direction=direction) # Save projection try: mrcfile.new(new_fname, projc.T.get(), overwrite=True) except: mrcfile.new(new_fname, projc.T, overwrite=True) #write(new_fname, projc, Tiltangles[p]) return True
print(helper) sys.exit() try: fscCriterion = float(fscCriterion) except TypeError: fscCriterion = 0.5 try: if pixelSize: pixelSize = float(pixelSize) except ValueError: raise ValueError('The value for pixelsize must be a float!') try: mask = read(mask) except: mask = None try: if numberBands: numberBands = int(numberBands) except ValueError: raise ValueError('The value for numberBands must be a integer!') try: if randomize is None: randomize = 0 else: randomize = float(randomize) except ValueError or randomize > 1 or randomize < 0:
def run_single_tilt_angle(subtomogram, ang, offset, vol_size, particle_position, particle_rotation, particle_filename, particle_number, binning, img, create_graphics, fsc_path, dimz, peak_border): """ To run a single tilt angle to allow for parallel computing @param ang: the tilt angle @type ang: int @param subtomogram: the filename of the subtomogram @type subtomogram: str @param offset: the offset used (x,y,z) @type offset: list(int, int, int) @param vol_size: the size of the volume to be reconstructed (in pixels) @type vol_size: int @param particle_position: the position of the particle in vector format, as given by particle.pickPosition().toVector() @type particle_position: tuple @param particle_rotation: the rotation of the particle (Z1/phi, X/the, Z2/psi) @type particle_rotation: tuple @param particle_filename: the filename of the particle, as given by particle.getfilename() @type particle_filename: str @param particle_number: the number of the particle, to allow for unique mapping @type particle_number: int @param binning: the binning factor used @type binning: int @param img: the filename of the projection to be used @type img: str @param create_graphics: to flag if images should be created for human inspection of the work done @type create_graphics: bool @return: the newly found positions of the particle, as a list in the LOCAL_ALIGNMENT_RESULTS format @returntype: list """ from pytom.reconstruction.reconstructionFunctions import alignImageUsingAlignmentResultFile from pytom.tompy.transform import rotate3d, rotate_axis from pytom.gui.guiFunctions import datatypeAR, loadstar import numpy as np from math import cos, sin, pi, sqrt from pytom.tompy.tools import create_circle from pytom.tompy.transform import cut_from_projection from pytom.tompy.filter import applyFourierFilterFull, bandpass_circle from pytom.tompy.io import read, write from pytom.tompy.correlation import meanUnderMask, stdUnderMask import os import time t = time.time() # print(particle_filename, ang) # Filter using FSC fsc_mask = None k = 0.01 subtomogram = read(subtomogram) * read( '/data/gijsvds/ctem/05_Subtomogram_Analysis/Alignment/GLocal/mask_200_75_5.mrc' ) import os from pytom.tompy.filter import filter_volume_by_profile, profile2FourierVol fsc_path = '' if os.path.isfile(fsc_path): profile = [line.split()[0] for line in open(fsc_path, 'r').readlines()] fsc_mask3d = profile2FourierVol(profile, subtomogram.shape) subtomogram = applyFourierFilterFull(subtomogram, fsc_mask3d) # Cross correlate the templat # e and patch, this should give the pixel shift it is after from pytom.tompy.correlation import nXcf # Get template # First rotate the template towards orientation of the particle, then to the tilt angle img = read(img) rotated1 = rotate3d(subtomogram, phi=particle_rotation[0], the=particle_rotation[1], psi=particle_rotation[2]) rotated2 = rotate_axis( rotated1, -ang, 'y') # SWITCHED TO ROTATE AXIS AND ANGLE *-1 THIS IS AN ATTEMPT template = rotated2.sum(axis=2) # write('pp1_template.mrc', template) # img = read(img) try: patch, xx, yy = cut_patch(img, ang, particle_position, dimz=dimz, vol_size=vol_size, binning=binning) mask2d = create_circle(patch.shape, radius=75, sigma=5, num_sigma=2) patch *= mask2d # write('pp1_patch.mrc', patch) if os.path.isfile(fsc_path): profile = [ line.split()[0] for line in open(fsc_path, 'r').readlines() ] fsc_mask2d = profile2FourierVol(profile, patch.shape) patch = applyFourierFilterFull(patch, fsc_mask2d) template = normalize_image(template, mask2d, mask2d.sum()) patch = normalize_image(patch, mask2d, mask2d.sum()) if 1: ff = xp.ones_like(patch) else: ff = bandpass_circle(patch.squeeze(), 6, 25, 3) ccf = normalised_cross_correlation(template, patch, ff) points2d1 = find_sub_pixel_max_value_2d(ccf.copy(), ignore_border=peak_border) points2d2 = find_sub_pixel_max_value(ccf.copy(), ignore_border=peak_border) points2d = list(points2d2[:2]) + [points2d1[-1]] x_diff = points2d[0] - vol_size / 2 y_diff = points2d[1] - vol_size / 2 dist = sqrt(x_diff**2 + y_diff**2) #rx, ry, ii, oox, ooy, x2, y2 = find_sub_pixel_max_value_voltools(ccf.copy()) #print(rx,ry, x_diff, y_diff, x2, y2, oox, ooy, ii.shape) #print(f'{particle_number:3d} {ang:5.1f}, {dist:5.2f} {x_diff} {y_diff} {ccf.max()}') if create_graphics: rx, ry, ii, oox, ooy, x2, y2 = find_sub_pixel_max_value_voltools( ccf.copy(), k=k) print(rx, ry) from scipy.ndimage.filters import gaussian_filter # Create an image to display and/or test the inner workings of the algorithm points = find_sub_pixel_max_value(ccf, ignore_border=peak_border) nx, ny, nz = particle_position nx += x_diff ny += y_diff npatch = cut_from_projection( img.squeeze(), [xx + x_diff, yy + y_diff], [vol_size, vol_size] ) # img.sum(axis=2)[int(xx+x_diff-v):int(xx+x_diff+v), int(yy+y_diff-v):int(yy+y_diff+v)] # npatch = normalize_image(npatch, mask2d, mask2d.sum()) nccf = normalised_cross_correlation(template, npatch.squeeze(), ff) npoints = find_sub_pixel_max_value(nccf, ignore_border=peak_border) npoints2d = find_sub_pixel_max_value_2d(nccf, ignore_border=peak_border) #rx, ry = abs(xp.array(npoints2d[:2]) - 100) from scipy.ndimage.filters import gaussian_filter # Create an image to display and/or test the inner workings of the algorithm points = find_sub_pixel_max_value(ccf, ignore_border=peak_border) nx, ny, nz = particle_position nx += x_diff ny += y_diff npatch = cut_from_projection( img.squeeze(), [xx + x_diff, yy + y_diff], [vol_size, vol_size] ) # img.sum(axis=2)[int(xx+x_diff-v):int(xx+x_diff+v), int(yy+y_diff-v):int(yy+y_diff+v)] # npatch = normalize_image(npatch, mask2d, mask2d.sum()) nccf = normalised_cross_correlation(template, npatch.squeeze(), ff) npoints = find_sub_pixel_max_value(nccf, ignore_border=peak_border) npoints2d = find_sub_pixel_max_value_2d(nccf, ignore_border=peak_border) #rx, ry = abs(xp.array(npoints2d[:2]) - 100) m_style = dict(color='tab:blue', linestyle=':', marker='o', markersize=5, markerfacecoloralt='tab:red') m_style_alt = dict(color='tab:red', linestyle=':', marker='o', markersize=5, markerfacecoloralt='tab:orange') grid = pp.GridSpec(3, 3, wspace=0, hspace=0.35, left=0.05, right=0.95, top=0.90, bottom=0.05) ax_0_0 = pp.subplot(grid[0, 0]) ax_0_1 = pp.subplot(grid[0, 1]) ax_0_2 = pp.subplot(grid[0, 2]) ax_1_0 = pp.subplot(grid[1, 0]) ax_1_1 = pp.subplot(grid[1, 1]) ax_1_2 = pp.subplot(grid[1, 2]) ax_2_0 = pp.subplot(grid[2, 0]) ax_2_1 = pp.subplot(grid[2, 1]) ax_2_2 = pp.subplot(grid[2, 2]) ax_0_0.axis('off') ax_0_1.axis('off') ax_0_2.axis('off') ax_1_0.axis('off') ax_1_1.axis('off') ax_1_2.axis('off') ax_2_0.axis('off') ax_2_1.axis('off') ax_2_2.axis('off') axis_title(ax_0_0, "Cutout") ax_0_0.imshow(applyFourierFilterFull(patch, xp.fft.fftshift(ff))) axis_title(ax_0_1, "Template") ax_0_1.imshow(template) axis_title(ax_0_2, "Shifted Cutout\n(based on cross correlation)") ax_0_2.imshow(npatch.squeeze()) axis_title(ax_1_0, u"Cross correlation\ncutout × template") ax_1_0.imshow(ccf) ax_1_0.plot([points[1]], [points[0]], fillstyle='none', **m_style) ax_1_0.plot([points2d[1]], [points2d[0]], fillstyle='none', **m_style_alt) ax_1_0.plot([vol_size / 2], [vol_size / 2], ",k") ax_1_1.text( 0.5, 0.8, "Red: 2D spline interpolation\nx: {:f}\ny: {:f}\nBlue: 1D spline interpolation\nx: {:f}\ny: {:f}" "\nBlack: center".format(x_diff, y_diff, points[0] - vol_size / 2, points[1] - vol_size / 2), fontsize=8, horizontalalignment='center', verticalalignment='center', transform=ax_1_1.transAxes) axis_title(ax_1_2, u"Cross correlation\nshifted cutout × template") ax_1_2.imshow(nccf) ax_1_2.plot([npoints[0]], [npoints[1]], fillstyle='none', **m_style) ax_1_2.plot([npoints2d[0]], [npoints2d[1]], fillstyle='none', **m_style_alt) ax_1_2.plot([vol_size / 2], [vol_size / 2], ",k") axis_title(ax_2_0, u"Zoom into red peak\nin CC cutout × template") d = 10 points2d = list(xp.unravel_index(ccf.argmax(), ccf.shape)) + [points2d[-1]] peak = ccf[int(points2d[0]) - d:int(points2d[0]) + d, int(points2d[1]) - d:int(points2d[1] + d)] ax_2_0.imshow(peak) axis_title( ax_2_1, u"Zoom into red peak\nin CC cutout × template\ninterpolated") ax_2_1.imshow(ii) ax_2_1.plot([y2 + (y_diff - ry) / k], [x2 + (x_diff - rx) / k], fillstyle='none', **m_style) ax_2_1.plot([y2], [x2], fillstyle='none', **m_style_alt) axis_title(ax_2_2, u"Cutout\nGaussian filter σ3") import scipy ax_2_2.imshow(scipy.ndimage.gaussian_filter(patch, 3)) pp.savefig( "../Images/test/polish_particle_{:04d}_tiltimage_{:05.2f}_shift_{:.1f}.png" .format(particle_number, ang, dist)) del img except Exception as e: print(e) x_diff = y_diff = 0 print( f'{particle_number:3d} {ang:4d} {x_diff:5.2f} {y_diff:5.2f} {points2d1[0]-patch.shape[0]//2:.2f} {points2d1[1]-patch.shape[0]//2:.2f} {time.time()-t:5.3f}' ) return particle_number, x_diff, y_diff, ang, 0, 0, particle_filename
import sys from pytom.tompy.io import read data1 = read(sys.argv[1]).squeeze() data2 = read(sys.argv[2]).squeeze() print(data1.shape, data2.shape) import matplotlib matplotlib.use('Qt5Agg') diff = abs(data1 - data2) from pylab import * print(allclose(data2, data1, rtol=1E-5)) fig, ax = subplots(1, 3, figsize=(15, 5)) ax[0].imshow(data1) ax[1].imshow(data2) ax[2].imshow(abs(data1 - data2)) show()
def run_single_tilt_angle(ang, subtomogram, offset, vol_size, particle_position, particle_rotation, particle_filename, particle_number, binning, img, create_graphics, fsc_path, dimz, peak_border): """ To run a single tilt angle to allow for parallel computing @param ang: the tilt angle @type ang: int @param subtomogram: the filename of the subtomogram @type subtomogram: str @param offset: the offset used (x,y,z) @type offset: list(int, int, int) @param vol_size: the size of the volume to be reconstructed (in pixels) @type vol_size: int @param particle_position: the position of the particle in vector format, as given by particle.pickPosition().toVector() @type particle_position: tuple @param particle_rotation: the rotation of the particle (Z1/phi, X/the, Z2/psi) @type particle_rotation: tuple @param particle_filename: the filename of the particle, as given by particle.getfilename() @type particle_filename: str @param particle_number: the number of the particle, to allow for unique mapping @type particle_number: int @param binning: the binning factor used @type binning: int @param img: the filename of the projection to be used @type img: str @param create_graphics: to flag if images should be created for human inspection of the work done @type create_graphics: bool @return: the newly found positions of the particle, as a list in the LOCAL_ALIGNMENT_RESULTS format @returntype: list """ print(ang, offset, binning, particle_position) from pytom.tompy.transform import rotate3d import numpy as np from math import cos, sin, pi from pytom.tompy.transform import cut_from_projection from pytom.tompy.io import read subtomogram = read(subtomogram) img = read(img) # Get the size of the original projection dim_x = img.shape[0] dim_z = dim_x if dimz is None else dimz print(dim_x, dim_z) x, y, z = particle_position x = (x + offset[0]) * binning y = (y + offset[1]) * binning z = (z + offset[2]) * binning # Get template # First rotate towards orientation of the particle, then to the tilt angle rotated1 = rotate3d(subtomogram, phi=particle_rotation[0], the=particle_rotation[1], psi=particle_rotation[2]) rotated2 = rotate3d(rotated1, the=ang) # 'the' is the rotational axis template = rotated2.sum(axis=2) # Get coordinates of the paricle adjusted for the tilt angle yy = y # assume the rotation axis is around y xx = (cos(ang * pi / 180) * (x - dim_x / 2) - sin(ang * pi / 180) * (z - dim_z / 2)) + dim_x / 2 # Cut the small patch out patch = cut_from_projection(img.sum(axis=2), [xx, yy], [vol_size, vol_size]) patch = patch - patch.mean() # Filter using FSC fsc_mask = None import os if os.path.isfile(fsc_path): f = open(fsc_path, "r") fsc = map(lambda a: float(a), f.readlines()) f.close() fsc_mask = create_fsc_mask(fsc, vol_size) elif fsc_path != "": print("Not an existing FSC file: " + fsc_path) # Cross correlate the template and patch, this should give the pixel shift it is after ccf = normalised_cross_correlation(template, patch, fsc_mask) points2d = find_sub_pixel_max_value_2d(ccf, ignore_border=peak_border) x_diff = points2d[0] - vol_size / 2 y_diff = points2d[1] - vol_size / 2 if create_graphics: # Create an image to display and/or test the inner workings of the algorithm m_style = dict(color='tab:blue', linestyle=':', marker='o', markersize=5, markerfacecoloralt='tab:red') m_style_alt = dict(color='tab:red', linestyle=':', marker='o', markersize=5, markerfacecoloralt='tab:blue') points = find_sub_pixel_max_value(ccf) nx, ny, nz = particle_position nx += x_diff ny += y_diff npatch = cut_from_projection( img.sum(axis=2), [xx + x_diff, yy + y_diff], [vol_size, vol_size] ) # img.sum(axis=2)[int(xx+x_diff-v):int(xx+x_diff+v), int(yy+y_diff-v):int(yy+y_diff+v)] # npatch = npatch - np.mean(npatch) nccf = normalised_cross_correlation(template, npatch.squeeze()) npoints = find_sub_pixel_max_value(nccf) npoints2d = find_sub_pixel_max_value_2d(nccf, ignore_border=peak_border) import pylab as pp grid = pp.GridSpec(3, 3, wspace=0, hspace=0.35, left=0.05, right=0.95, top=0.90, bottom=0.05) ax_0_0 = pp.subplot(grid[0, 0]) ax_0_1 = pp.subplot(grid[0, 1]) ax_0_2 = pp.subplot(grid[0, 2]) ax_1_0 = pp.subplot(grid[1, 0]) ax_1_1 = pp.subplot(grid[1, 1]) ax_1_2 = pp.subplot(grid[1, 2]) ax_2_0 = pp.subplot(grid[2, 0]) ax_2_1 = pp.subplot(grid[2, 1]) ax_2_2 = pp.subplot(grid[2, 2]) ax_0_0.axis('off') ax_0_1.axis('off') ax_0_2.axis('off') ax_1_0.axis('off') ax_1_1.axis('off') ax_1_2.axis('off') ax_2_0.axis('off') ax_2_1.axis('off') ax_2_2.axis('off') axis_title(ax_0_0, "Cutout") ax_0_0.imshow(patch) axis_title(ax_0_1, "Template") ax_0_1.imshow(template) axis_title(ax_0_2, "Shifted Cutout\n(based on cross correlation)") ax_0_2.imshow(npatch.squeeze()) axis_title(ax_1_0, u"Cross correlation\ncutout × template") ax_1_0.imshow(ccf) ax_1_0.plot([p[1] for p in points], [p[0] for p in points], fillstyle='none', **m_style) ax_1_0.plot([points2d[1]], [points2d[0]], fillstyle='none', **m_style_alt) ax_1_0.plot([vol_size / 2], [vol_size / 2], ",k") ax_1_1.text( 0.5, 0.8, "Red: 2D spline interpolation\nx: {:f}\ny: {:f}\nBlue: 1D spline interpolation\nx: {:f}\ny: {:f}" "\nBlack: center".format(x_diff, y_diff, points[0][0] - vol_size / 2, points[0][1] - vol_size / 2), fontsize=8, horizontalalignment='center', verticalalignment='center', transform=ax_1_1.transAxes) axis_title(ax_1_2, u"Cross correlation\nshifted cutout × template") ax_1_2.imshow(nccf) ax_1_2.plot([p[0] for p in npoints], [p[1] for p in npoints], fillstyle='none', **m_style) ax_1_2.plot([npoints2d[0]], [npoints2d[1]], fillstyle='none', **m_style_alt) ax_1_2.plot([vol_size / 2], [vol_size / 2], ",k") axis_title(ax_2_0, u"Zoom into red peak\nin CC cutout × template") d = 10 peak = ccf[int(points2d[0]) - d:int(points2d[0]) + d, int(points2d[1]) - d:int(points2d[1] + d)] ax_2_0.imshow(peak) axis_title( ax_2_1, u"Zoom into red peak\nin CC cutout × template\ninterpolated") ax_2_1.imshow(points2d[2]) axis_title(ax_2_2, u"Cutout\nGaussian filter σ3") import scipy ax_2_2.imshow(scipy.ndimage.gaussian_filter(patch, 3)) pp.savefig("polish_particle_{:04d}_tiltimage_{:05.2f}.png".format( particle_number, ang)) return particle_number, x_diff, y_diff, ang, 0, 0, particle_filename
def CorrectProjection_proxy(fname, new_fname, p, metadata, gs, fs, binning_factor, rotation_angle, def_grad_strip=2.5): """ """ print('Correct projection:', fname) # load the metadata #from numpy import loadtxt # Alignment parameter Tiltaxis = rotation_angle Tiltangle = metadata['TiltAngle'][p] dz1 = -1 * metadata['DefocusU'][p] dz2 = -1 * metadata['DefocusV'][p] alpha = metadata['DefocusAngle'][p] Voltage = metadata['Voltage'][p] Cs = metadata['SphericalAberration'][p] A = metadata['AmplitudeContrast'][p] Imdim = metadata['ImageSize'][p] Objectpixelsize = metadata['PixelSpacing'][p] * 0.1 * binning_factor from pytom.tompy.io import read, write from pytom.tompy.tools import paste_in_center # Load projection # Fast options are 3840, 3888, 4096 size = 3888 projInit = np.array(read(fname)) projInit = np.squeeze(projInit) # squeeze it to 2D proj = np.zeros((size, size)) proj = paste_in_center(projInit, proj) B = (proj.shape[0] - projInit.shape[0]) // 2 sx, sy = proj.shape[0] // 2, proj.shape[1] // 2 x, y = np.meshgrid(np.arange(-sx, sx), np.arange(-sx, sx)) import time s = time.time() projc = CorrectProjection2(proj, dz1, dz2, alpha + Tiltaxis, Tiltangle, Tiltaxis, dfgrad=def_grad_strip, Border=B, ObjectPixelSize=Objectpixelsize, Voltage=Voltage, CS=Cs, AmpContrast=A, x=x, y=y) print(time.time() - s) # Save projection try: mrcfile.new(new_fname, projc.T.get().astype('float32'), overwrite=True) except: mrcfile.new(new_fname, projc.T.astype('float32'), overwrite=True) #write(new_fname, projc, Tiltangles[p]) return True
iter = 10 else: iter = int(iter) if metafile and os.path.exists(metafile): metadata = loadstar(metafile, dtype=datatype) tiltAngles = metadata['TiltAngle'] else: tiltAngles = [] metafile = '' if metafile is None or not os.path.exists( metafile) else metafile # start reconstruction from pytom.tompy.io import read, write from nufft.reconstruction import fourier_2d1d_iter_reconstruct from pytom.reconstruction.reconstructionStructures import ProjectionList projections = ProjectionList() projections.loadDirectory(proj_dir, metafile=metafile) projections.sort() projs = [] tilt_angles = [] for p in projections: print(p.getTiltAngle(), p.getFilename()) projs.append(read(p.getFilename())) tilt_angles.append(p.getTiltAngle()) v = fourier_2d1d_iter_reconstruct(projs, tilt_angles, iter) write(output_filename, v)
print(helper) sys.exit() try: filename, outname, num_cycles, help = parse_script_options( sys.argv[1:], helper) except Exception as e: print(e) sys.exit() if help is True: print(helper) sys.exit() if os.path.exists(filename): data = read(filename) else: print(helper) sys.exit() if num_cycles is None: num_cycles = 0 else: num_cylces = int(num_cycles) data = read(filename) mask = zeros_like(data, dtype=int) mask[data < data.mean() - data.std()] = 1 mask = remove_small_objects(mask.astype(bool)) mask = binary_fill_holes(mask)
def alignImageUsingAlignmentResultFile(alignmentResultsFile, indexImage, weighting=None, lowpassFilter=0.9, binning=1, circleFilter=False): import pytom_freqweight from pytom_numpy import vol2npy from pytom.gui.guiFunctions import fmtAR, headerAlignmentResults, datatype, datatypeAR, loadstar from pytom.reconstruction.reconstructionStructures import Projection, ProjectionList from pytom.tompy.io import read, write, read_size from pytom.tompy.tools import taper_edges, create_circle from pytom.tompy.filter import circle_filter, ramp_filter, exact_filter, ellipse_filter import pytom.voltools as vt from pytom.gpu.initialize import xp, device # print("Create aligned images from alignResults.txt") alignmentResults = loadstar(alignmentResultsFile, dtype=datatypeAR) imageList = alignmentResults['FileName'] tilt_angles = alignmentResults['TiltAngle'] imdimX = read_size(imageList[0], 'x') imdimY = read_size(imageList[0], 'y') if binning > 1: imdimX = int(float(imdimX) / float(binning) + .5) imdimY = int(float(imdimY) / float(binning) + .5) sliceWidth = imdimX if (weighting != None) and (float(weighting) < -0.001): weightSlice = xp.fft.fftshift(ramp_filter(imdimY, imdimX)) if circleFilter: circleFilterRadiusX = imdimX // 2 circleFilterRadiusY = imdimY // 2 circleSlice = xp.fft.fftshift( ellipse_filter(imdimX, imdimY, circleFilterRadiusX, circleFilterRadiusY)) else: circleSlice = xp.ones((imdimX, imdimY)) # design lowpass filter if lowpassFilter: if lowpassFilter > 1.: lowpassFilter = 1. print("Warning: lowpassFilter > 1 - set to 1 (=Nyquist)") # weighting filter: arguments: (()dimx, dimy), cutoff radius, sigma # lpf = xp.fft.fftshift(create_circle((imdimX,imdimY),lowpassFilter*(imdim//2), sigma=0.4*lowpassFilter*(imdim//2))) projectionList = ProjectionList() for n, image in enumerate(imageList): atx = alignmentResults['AlignmentTransX'][n] aty = alignmentResults['AlignmentTransY'][n] rot = alignmentResults['InPlaneRotation'][n] mag = 1 / (alignmentResults['Magnification'][n]) projection = Projection(imageList[n], tiltAngle=tilt_angles[n], alignmentTransX=atx, alignmentTransY=aty, alignmentRotation=rot, alignmentMagnification=mag) projectionList.append(projection) imdim = min(imdimY, imdimX) for (ii, projection) in enumerate(projectionList): if not ii == indexImage: continue from pytom.tompy.transform import resize # print(f'read {projection._filename}') image = read(str(projection._filename)).squeeze() if binning > 1: image = resize(image, 1 / binning) #write(f'test/image_{ii}.mrc', image, tilt_angle=tilt_angles[ii]) tiltAngle = projection._tiltAngle # 1 -- normalize to contrast - subtract mean and norm to mean immean = image.mean() image = (image - immean) / immean # 2 -- smoothen borders to prevent high contrast oscillations image = taper_edges(image, imdim // 30)[0] # 3 -- square if needed if 0 and imdimY != imdimX: newImage = xp.zeros((imdim, imdim, 1), dtype=xp.float32) pasteCenter(image, newImage) image = newImage # 4 -- transform projection according to tilt alignment transX = projection._alignmentTransX / binning transY = projection._alignmentTransY / binning rot = float(projection._alignmentRotation) mag = float(projection._alignmentMagnification) inputImage = xp.expand_dims(image, 2).copy() outputImage = xp.zeros_like(inputImage, dtype=xp.float32) vt.transform( inputImage.astype(xp.float32), rotation=[0, 0, rot], rotation_order='rxyz', output=outputImage, center=[inputImage.shape[0] // 2, inputImage.shape[1] // 2, 0], device=device, translation=[transX, transY, 0], scale=[mag, mag, 1], interpolation='filt_bspline') del image image = outputImage.squeeze() # 5 -- Optional Low Pass Filter if lowpassFilter: from pytom.tompy.filter import bandpass_circle image = bandpass_circle( image, high=lowpassFilter * (min(imdimX, imdimY) // 2), sigma=0.4 * lowpassFilter * (min(imdimX, imdimY) // 2)) # image = xp.abs((xp.fft.ifftn(xp.fft.fftn(image) * lpf))) # 6 -- smoothen once more to avoid edges image = taper_edges(image, imdim // 30)[0] # 7 -- analytical weighting if (weighting != None) and (weighting < 0): # image = (ifft(complexRealMult(fft(image), w_func)) / (image.sizeX() * image.sizeY() * image.sizeZ())) image = xp.fft.ifftn( xp.fft.fftn(image) * weightSlice.T * circleSlice).real elif (weighting != None) and (weighting > 0): weightSlice = xp.fft.fftshift( exact_filter(tilt_angles, tiltAngle, imdim, imdim, sliceWidth)) image = xp.fft.ifftn( xp.fft.fftn(image) * weightSlice * circleSlice).real del inputImage, outputImage, circleSlice write(f'inputImage_{ii}.mrc', image) return image.astype(xp.float32)
wedgeAngle = 30 wedgeFilter = weight(wedgeAngle, 0, end - start, size, size) wedgeVolume = wedgeFilter.getWeightVolume(True) filterVolume = pytom_volume.reducedToFull(wedgeVolume) wedgeV = vol2npy(filterVolume).copy() from pytom.tompy.io import read import mrcfile print(start, end) volume = mrcfile.open('tomo.mrc', permissive=True).data.copy() volume = volume[start:end, :csize, :csize] assert wedgeV.shape == volume.shape temp = read('template.em') mask = read("mask.em") mask2 = paste_in_center(mask, np.zeros_like(volume)) from pytom.tompy.correlation import meanVolUnderMask, stdVolUnderMask import pytom.basic.correlation as corr from pytom.basic.files import read as readd from pytom.basic.files import write_em from pytom_numpy import vol2npy, npy2vol from pytom_volume import pasteCenter, vol vv = readd('tomo.mrc', subregion=[0, 0, start, 464, 464, end - start]) mm = readd('mask.em') if vv.sizeX() != mm.sizeX() or vv.sizeY() != mm.sizeY() or vv.sizeZ( ) != mm.sizeZ(): maskV = vol(vv.sizeX(), vv.sizeY(), vv.sizeZ())
def FSC(volume1, volume2, numberBands=None, mask=None, verbose=False, filename=None, num_procs=1): """ FSC - Calculates the Fourier Shell Correlation for two volumes @param volume1: volume one @type volume1: L{pytom_volume.vol} @param volume2: volume two @type volume2: L{pytom_volume.vol} @param numberBands: number of shells for FSC @type numberBands: int @param filename: write FSC to ascii file if specified @type filename: string @return: Returns a list of cc values @author: Thomas Hrabe @rtype: list[floats] """ from pytom.tompy.correlation import bandCC from pytom.basic.structures import Mask from pytom.tompy.io import read, write from pytom.tompy.tools import volumesSameSize import time t = time.time() if not volumesSameSize(volume1, volume2): raise RuntimeError('Volumes must have the same size!') numberBands = volume1.shape[0] // 2 if numberBands is None else numberBands if not mask is None: if mask.__class__ == xp.array([0]).__class__: volume1 = volume1 * mask volume2 = volume2 * mask elif mask.__class__ == Mask: mask = mask.getVolume() volume1 = volume1 * mask volume2 = volume2 * mask elif mask.__class__ == str: mask = read(mask) volume1 = volume1 * mask volume2 = volume2 * mask else: raise RuntimeError( 'FSC: Mask must be a volume OR a Mask object OR a string path to a mask!' ) fscResult = [] band = [-1, -1] increment = int(volume1.shape[0] / 2 * 1 / numberBands) import time fvolume1 = xp.fft.fftn(volume1) fvolume2 = xp.fft.fftn(volume2) for n, i in enumerate(range(0, volume1.shape[0] // 2, increment)): band[0] = i band[1] = i + increment if verbose: print('Band : ', band) res = bandCC(fvolume1, fvolume2, band, verbose) if i == 0 and increment == 1: #force a 1 for correlation of the zero frequency res = 1 if verbose: print('Correlation ', res) fscResult.append(res) if filename: f = open(filename, 'w') for item in fscResult: f.write("%s\n" % item) f.close() return fscResult
def alignImagesUsingAlignmentResultFile(alignmentResultsFile, weighting=None, lowpassFilter=0.9, binning=1, circleFilter=False): import os from pytom.basic.files import read as readCVol from pytom_numpy import vol2npy, npy2vol from pytom.gui.guiFunctions import fmtAR, headerAlignmentResults, datatype, datatypeAR, loadstar from pytom.reconstruction.reconstructionStructures import Projection, ProjectionList from pytom.tompy.io import read, write, read_size from pytom.tompy.tools import taper_edges, create_circle from pytom.tompy.filter import circle_filter, ramp_filter, exact_filter import pytom.voltools as vt from pytom.gpu.initialize import xp, device print("Create aligned images from alignResults.txt") alignmentResults = loadstar(alignmentResultsFile, dtype=datatypeAR) imageList = alignmentResults['FileName'] tilt_angles = alignmentResults['TiltAngle'] imdim = read_size(imageList[0], 'x') if binning > 1: imdim = int(float(imdim) / float(binning) + .5) else: imdim = imdim sliceWidth = imdim if (weighting != None) and (float(weighting) < -0.001): weightSlice = xp.fft.fftshift(ramp_filter(imdim, imdim)) if circleFilter: circleFilterRadius = imdim // 2 circleSlice = xp.fft.fftshift( circle_filter(imdim, imdim, circleFilterRadius)) else: circleSlice = xp.ones((imdim, imdim)) # design lowpass filter if lowpassFilter: if lowpassFilter > 1.: lowpassFilter = 1. print("Warning: lowpassFilter > 1 - set to 1 (=Nyquist)") # weighting filter: arguments: (()dimx, dimy), cutoff radius, sigma lpf = xp.fft.fftshift( create_circle((imdim, imdim), lowpassFilter * (imdim // 2), sigma=0.4 * lowpassFilter * (imdim // 2))) projectionList = ProjectionList() for n, image in enumerate(imageList): atx = alignmentResults['AlignmentTransX'][n] / binning aty = alignmentResults['AlignmentTransY'][n] / binning rot = alignmentResults['InPlaneRotation'][n] mag = 1 / alignmentResults['Magnification'][n] projection = Projection(imageList[n], tiltAngle=tilt_angles[n], alignmentTransX=atx, alignmentTransY=aty, alignmentRotation=rot, alignmentMagnification=mag) projectionList.append(projection) stack = xp.zeros((imdim, imdim, len(imageList)), dtype=xp.float32) phiStack = xp.zeros((1, 1, len(imageList)), dtype=xp.float32) thetaStack = xp.zeros((1, 1, len(imageList)), dtype=xp.float32) offsetStack = xp.zeros((1, 2, len(imageList)), dtype=xp.float32) for (ii, projection) in enumerate(projectionList): print(f'Align {projection._filename}') image = read(str(projection._filename))[::binning, ::binning].squeeze() if lowpassFilter: image = xp.abs((xp.fft.ifftn(xp.fft.fftn(image) * lpf))) tiltAngle = projection._tiltAngle # normalize to contrast - subtract mean and norm to mean immean = image.mean() image = (image - immean) / immean # smoothen borders to prevent high contrast oscillations image = taper_edges(image, imdim // 30)[0] # transform projection according to tilt alignment transX = projection._alignmentTransX / binning transY = projection._alignmentTransY / binning rot = float(projection._alignmentRotation) mag = float(projection._alignmentMagnification) inputImage = xp.expand_dims(image, 2).copy() outputImage = xp.zeros_like(inputImage, dtype=xp.float32) vt.transform(inputImage.astype(xp.float32), rotation=[0, 0, rot], rotation_order='rxyz', output=outputImage, device=device, translation=[transX, transY, 0], scale=[mag, mag, 1], interpolation='filt_bspline') image = outputImage.squeeze() # smoothen once more to avoid edges image = taper_edges(image, imdim // 30)[0] # analytical weighting if (weighting != None) and (weighting < 0): # image = (ifft(complexRealMult(fft(image), w_func)) / (image.sizeX() * image.sizeY() * image.sizeZ())) image = xp.fft.ifftn( xp.fft.fftn(image) * weightSlice * circleSlice) elif (weighting != None) and (weighting > 0): weightSlice = xp.fft.fftshift( exact_filter(tilt_angles, tiltAngle, imdim, imdim, sliceWidth)) image = xp.fft.ifftn( xp.fft.fftn(image) * weightSlice * circleSlice) thetaStack[0, 0, ii] = int(round(projection.getTiltAngle())) offsetStack[0, :, ii] = xp.array([ int(round(projection.getOffsetX())), int(round(projection.getOffsetY())) ]) stack[:, :, ii] = image arrays = [] for fname, arr in (('stack.mrc', stack), ('offsetStack.mrc', offsetStack), ('thetaStack.mrc', thetaStack), ('phiStack.mrc', phiStack)): if 'gpu' in device: arr = arr.get() import numpy as np res = npy2vol(np.array(arr, dtype='float32', order='F'), 3) arrays.append(res) # # write('stack.mrc', stack) # stack = readCVol('stack.mrc') # write('offsetstack.mrc', offsetStack) # offsetStack = readCVol('offsetstack.mrc') # write('thetastack.mrc', thetaStack) # thetaStack = readCVol('thetastack.mrc') # write('phistack.mrc', phiStack) # phiStack = readCVol('phistack.mrc') # # os.remove('stack.mrc') # os.remove('offsetstack.mrc') # os.remove('thetastack.mrc') # os.remove('psistack.mrc') return arrays
except: start, end = 0, csize wedgeAngle = 30 wedgeFilter = weight(wedgeAngle, 0, end - start, size, size) wedgeVolume = wedgeFilter.getWeightVolume(True) filterVolume = pytom_volume.reducedToFull(wedgeVolume) wedgeV = vol2npy(filterVolume).copy() from pytom.tompy.io import read import mrcfile # NDARRAYS voluNDA = mrcfile.open('tomo.mrc', permissive=True).data.copy() tempNDA = read('template.em') maskNDA = read("mask.em") sox, soy, soz = tempNDA.shape spx, spy, spz = voluNDA.shape #GPUARRAYS voluGPU = gu.to_gpu(voluNDA.astype(np.float32)) tempGPU = gu.to_gpu(tempNDA.astype(np.float32)) maskGPU = gu.to_gpu(maskNDA) #Pytom C arrays voluVOL = readd('tomo.mrc') tempVOL = readd('template.em') maskVOL = readd('mask.em')
def toProjectionStackFromAlignmentResultsFile(alignmentResultsFile, weighting=None, lowpassFilter=0.9, binning=1, circleFilter=False, num_procs=1, outdir='', prefix='sorted_aligned'): """read image and create aligned projection stack, based on the results described in the alignmentResultFile. @param alignmentResultsFile: result file generate by the alignment script. @type datatypeAR: gui.guiFunction.datatypeAR @param weighting: weighting (<0: analytical weighting, >1: exact weighting, 0/None: no weighting ) @type weighting: float @param lowpassFilter: lowpass filter (in Nyquist) @type lowpassFilter: float @param binning: binning (default: 1 = no binning). binning=2: 2x2 pixels -> 1 pixel, binning=3: 3x3 pixels -> 1 pixel, etc. @author: GvdS """ print('weighting: ', weighting) import numpy from pytom_numpy import vol2npy from pytom.basic.files import read_em, write_em from pytom.basic.functions import taper_edges from pytom.basic.transformations import general_transform2d from pytom.basic.fourier import ifft, fft from pytom.basic.filter import filter as filterFunction, bandpassFilter from pytom.basic.filter import circleFilter, rampFilter, exactFilter, fourierFilterShift, \ fourierFilterShift_ReducedComplex from pytom_volume import complexRealMult, vol, paste import pytom_freqweight from pytom.basic.transformations import resize, rotate from pytom.gui.guiFunctions import fmtAR, headerAlignmentResults, datatype, datatypeAR, loadstar from pytom.reconstruction.reconstructionStructures import Projection, ProjectionList from pytom_numpy import vol2npy import mrcfile from pytom.tompy.io import write, read_size import os print("Create aligned images from alignResults.txt") alignmentResults = loadstar(alignmentResultsFile, dtype=datatypeAR) imageList = alignmentResults['FileName'] tilt_angles = alignmentResults['TiltAngle'] imdim = int(read_size(imageList[0], 'x')) if binning > 1: imdim = int(float(imdim) / float(binning) + .5) else: imdim = imdim sliceWidth = imdim # pre-determine analytical weighting function and lowpass for speedup if (weighting != None) and (float(weighting) < -0.001): weightSlice = fourierFilterShift(rampFilter(imdim, imdim)) if circleFilter: circleFilterRadius = imdim // 2 circleSlice = fourierFilterShift_ReducedComplex( circleFilter(imdim, imdim, circleFilterRadius)) else: circleSlice = vol(imdim, imdim // 2 + 1, 1) circleSlice.setAll(1.0) # design lowpass filter if lowpassFilter: if lowpassFilter > 1.: lowpassFilter = 1. print("Warning: lowpassFilter > 1 - set to 1 (=Nyquist)") # weighting filter: arguments: (angle, cutoff radius, dimx, dimy, lpf = pytom_freqweight.weight(0.0, lowpassFilter * imdim // 2, imdim, imdim // 2 + 1, 1, lowpassFilter / 5. * imdim) # lpf = bandpassFilter(volume=vol(imdim, imdim,1),lowestFrequency=0,highestFrequency=int(lowpassFilter*imdim/2), # bpf=None,smooth=lowpassFilter/5.*imdim,fourierOnly=False)[1] projectionList = ProjectionList() imageList = [] tilt_angles = [] for n, image in enumerate(alignmentResults['FileName']): atx = alignmentResults['AlignmentTransX'][n] aty = alignmentResults['AlignmentTransY'][n] rot = alignmentResults['InPlaneRotation'][n] mag = alignmentResults['Magnification'][n] # print(image, alignmentResults['TiltAngle'][n]) # if abs(alignmentResults['TiltAngle'][n]) > 20: # continue tilt_angles.append(alignmentResults['TiltAngle'][n]) imageList.append(image) projection = Projection(imageList[-1], tiltAngle=tilt_angles[-1], alignmentTransX=atx, alignmentTransY=aty, alignmentRotation=rot, alignmentMagnification=mag) projectionList.append(projection) stack = vol(imdim, imdim, len(imageList)) stack.setAll(0.0) phiStack = vol(1, 1, len(imageList)) phiStack.setAll(0.0) thetaStack = vol(1, 1, len(imageList)) thetaStack.setAll(0.0) offsetStack = vol(1, 2, len(imageList)) offsetStack.setAll(0.0) for (ii, projection) in enumerate(projectionList): if projection._filename.split('.')[-1] == 'st': from pytom.basic.files import EMHeader, read idx = projection._index image = read(file=projection._filename, subregion=[0, 0, idx - 1, imdim, imdim, 1], sampling=[0, 0, 0], binning=[0, 0, 0]) if not (binning == 1) or (binning == None): image = resize(volume=image, factor=1 / float(binning))[0] else: # read projection files from pytom.basic.files import EMHeader, read, read_em_header image = read(str(projection._filename)) # image = rotate(image,180.,0.,0.) image = resize(volume=image, factor=1 / float(binning))[0] if lowpassFilter: filtered = filterFunction(volume=image, filterObject=lpf, fourierOnly=False) image = filtered[0] tiltAngle = projection._tiltAngle # normalize to contrast - subtract mean and norm to mean immean = vol2npy(image).mean() image = (image - immean) / immean print(ii, immean, projection._filename) # smoothen borders to prevent high contrast oscillations image = taper_edges(image, imdim // 30)[0] # transform projection according to tilt alignment transX = projection._alignmentTransX / binning transY = projection._alignmentTransY / binning rot = float(projection._alignmentRotation) mag = float(projection._alignmentMagnification) image = general_transform2d(v=image, rot=rot, shift=[transX, transY], scale=mag, order=[2, 1, 0], crop=True) # smoothen once more to avoid edges image = taper_edges(image, imdim // 30)[0] # analytical weighting if (weighting != None) and (weighting < 0): # image = (ifft(complexRealMult(fft(image), w_func)) / (image.sizeX() * image.sizeY() * image.sizeZ())) image = ifft(complexRealMult( complexRealMult(fft(image), weightSlice), circleSlice), scaling=True) elif (weighting != None) and (weighting > 0): weightSlice = fourierFilterShift( exactFilter(tilt_angles, tiltAngle, imdim, imdim, sliceWidth)) # image = (ifft(complexRealMult(fft(image), w_func)) / (image.sizeX() * image.sizeY() * image.sizeZ())) image = ifft(complexRealMult( complexRealMult(fft(image), weightSlice), circleSlice), scaling=True) thetaStack(int(round(projection.getTiltAngle())), 0, 0, ii) offsetStack(int(round(projection.getOffsetX())), 0, 0, ii) offsetStack(int(round(projection.getOffsetY())), 0, 1, ii) paste(image, stack, 0, 0, ii) fname = '{}_{:02d}.mrc'.format( prefix, int(imageList[ii].split('_')[-1].split('.')[0])) if outdir: import mrcfile # write_em(os.path.join(outdir, fname.replace('mrc', 'em')), image) write(os.path.join(outdir, fname), vol2npy(image).copy().astype('float32')) print('written file: ', fname) return [stack, phiStack, thetaStack, offsetStack]
def test(index=0): from pytom.tompy.io import read from pytom.tompy.transform import rotate3d path_raw_projection = "/data2/dschulte/BachelorThesis/Data/VPP2/03_Tomographic_Reconstruction/tomogram_000/sorted/sorted_29.em" path_aligned_projection = "/data2/dschulte/BachelorThesis/Data/VPP2/03_Tomographic_Reconstruction/tomogram_000/alignment/marker_0001_-60.0,60.0/sorted_aligned_30.em" path_template = "/data2/dschulte/BachelorThesis/Data/VPP2/05_Subtomogram_Analysis/combo_reduced.em" tilt_angle = -1.9989999533 raw_projection = read(path_raw_projection) aligned_projection = read(path_aligned_projection) template = read(path_template) dim = aligned_projection.shape[0] from pytom.basic.structures import ParticleList particlelist1 = ParticleList() particlelist1.fromXMLFile( "/data2/dschulte/BachelorThesis/Data/VPP2/04_Particle_Picking/Picked_Particles/combined_reduced_extracted/particleList_combined_reduced_tomogram_010_WBP.xml" ) align_results = (-15.3044300079, 3.7495634556, -184.3835906982, 1.0000053644) # -2 #align_results = (-1.2395387888, 4.9647006989, -184.3754882812, 1.0000000000) # 0 #pick_position = (278.12318382089245 * 8, 222.6395540890773 * 8, 268.97256780848085 * 8) #0 #pick_position = (381.21906883806 * 8, 153.61353397521387 * 8, 246.8315433927568 * 8) #74 #particle_rotation = (26.442828473505173, 44.44149544840194, 58.160958298848676) #0 #particle_rotation = (85.2456894956599, 30.815061362336394, 9.543300915975514) #74 pick_position = particlelist1[index].getPickPosition().toVector() particle_rotation = (particlelist1[index].getRotation().getZ1(), particlelist1[index].getRotation().getX(), particlelist1[index].getRotation().getZ2()) print(pick_position, particle_rotation) align_transformation, raw_position, aligned_position, template_transformation = combine_trans_projection( align_results, pick_position, particle_rotation, tilt_angle, dim, 8, template.shape[0]) d = 100 raw_patch = raw_projection[int(raw_position[0] - d):int(raw_position[0] + d), int(raw_position[1] - d):int(raw_position[1] + d)].squeeze() raw_patch = raw_patch / np.mean(raw_patch) aligned_patch = aligned_projection[int(aligned_position[0] - d):int(aligned_position[0] + d), int(aligned_position[1] - d):int(aligned_position[1] + d)].squeeze() aligned_patch = aligned_patch / (np.mean(aligned_patch)) aligned_raw = matrix_apply_to_2d(aligned_projection.squeeze(), align_transformation) aligned_raw_patch = aligned_raw[int(raw_position[0] - d):int(raw_position[0] + d), int(raw_position[1] - d):int(raw_position[1] + d)].squeeze() aligned_raw_patch = aligned_raw_patch / (np.mean(aligned_raw_patch)) transformed_template = matrix_apply_to_3d_3x3(template, template_transformation) print(np.mean(transformed_template), np.mean(template)) template_2d = transformed_template.sum(axis=2) template_2d = template_2d / np.mean(template_2d) print(template_2d.shape) template_vol = rotate3d(template, phi=particle_rotation[0], the=particle_rotation[1], psi=particle_rotation[2]) template_vol = rotate3d(template_vol, the=tilt_angle) template_vol_2d = template_vol.sum(axis=2) from pytom.reconstruction.reconstruct_local_alignment import normalised_cross_correlation_numpy, find_sub_pixel_max_value_2d raw_cc = normalised_cross_correlation_numpy(raw_patch, template_2d) rx, ry, _ = find_sub_pixel_max_value_2d(raw_cc) aligned_cc = normalised_cross_correlation_numpy(aligned_patch, template_vol_2d) tx, ty, _ = find_sub_pixel_max_value_2d(aligned_cc) import pylab as pl import scipy f, ax = pl.subplots(2, 3, figsize=(15, 10)) for i in range(2): for j in range(3): ax[i][j].axis('off') ax[0][0].set_title('Raw Data Particle') ax[0][0].imshow(scipy.ndimage.gaussian_filter(raw_patch, 3)) ax[0][1].set_title('Template Transformed to Raw Data') ax[0][1].imshow(template_2d) ax[0][2].set_title('Cross Correlation') ax[0][2].imshow(raw_cc) ax[0][2].text(0.05, 0.05, 'Peak\nx: {0:.2f}\ny: {0:.2f}'.format(rx, ry), transform=ax[0][2].transAxes, color='white') ax[1][0].set_title('Aligned Data Particle') ax[1][0].imshow(scipy.ndimage.gaussian_filter(aligned_patch, 3)) ax[1][1].set_title('Template Aligned to Aligned Data') ax[1][1].imshow(template_vol_2d) ax[1][2].set_title('Cross Correlation') ax[1][2].imshow(aligned_cc) ax[1][2].text(0.05, 0.05, 'Peak\nx: {0:.2f}\ny: {0:.2f}'.format(tx, ty), transform=ax[1][2].transAxes, color='white') f.tight_layout() pl.show()
def polish_particles(particle_list_filename, projection_directory, averaged_subtomogram, binning, offset, projections, tilt_angles, fsc_path='', peak_border=75, outputDirectory='./', create_graphics=False, number_of_particles=0, verbose=False, gpuID=-1): """ To polish a particle list based on (an) initial subtomogram(s). :param particle_list_filename: the filename of the particlelist :type particle_list_filename: str :param projection_directory: the directory of the projections :type projection_directory: str :param averaged_subtomogram: to give a path to an averaged subtomogram to be used instead of subtomograms of all particles separately :type averaged_subtomogram: str :param binning: the binning factor used :type binning: int :param offset: the offset used (x, y, z) :type offset: list(int, int, int) :param projections: a list with filenames of projections :type projections: list(str) :param tilt_angles: the list of tiltangles used :type tilt_angles: list(int) :param create_graphics: to create plots of major parts of the algorithm, mainly used for debugging and initial creation :type create_graphics: bool :param number_of_particles: to use a subset of the particles for the particle polishing :type number_of_particles: int :param skip_alignment: skips the alignment phase, does not do particle polishing :type skip_alignment: bool :return: nothing, it writes everything to disk :returntype: void """ assert number_of_particles == -1 or number_of_particles > 0 assert binning > 0 assert vol_size > 0 assert vol_size % 2 == 0 assert isinstance(projections, list) assert isinstance(vol_size, int) assert isinstance(binning, int) assert isinstance(offset, list) and len(offset) == 3 assert isinstance(offset[0], int) and isinstance( offset[1], int) and isinstance(offset[2], int) assert isinstance(tilt_angles, list) assert isinstance(particle_list_filename, str) assert isinstance(projection_directory, str) assert isinstance(create_graphics, bool) assert isinstance(averaged_subtomogram, str) assert isinstance(number_of_particles, int) assert isinstance(skip_alignment, bool) import os, time from pytom.tompy.io import read_size, read from pytom.gui.guiFunctions import fmtLAR, headerLocalAlignmentResults, LOCAL_ALIGNMENT_RESULTS import pytom.voltools as vt # load particle list from pytom.basic.structures import ParticleList particlelist = ParticleList() particlelist.fromXMLFile(particle_list_filename) particle_list_name = os.path.splitext( os.path.basename(str(particle_list_filename)))[0] if number_of_particles > 0: particlelist = particlelist[:number_of_particles] if verbose: print(len(particlelist)) print("{:s}> Creating the input array".format(gettime())) dimz = read_size(particlelist[0].getPickPosition().getOriginFilename(), 'z') * binning vol_size = 200 input_to_processes = [] data = {} for projectioname in projections: data[projectioname] = xp.array(read(projectioname)) # template1 = read(averaged_subtomogram, order='F') #template1 = mrcfile.open(averaged_subtomogram,permissive=True).data.copy().T.copy() template = vt.StaticVolume(template1, interpolation='filt_bspline', device=device) # output = [] results_file = os.path.join(outputDirectory, f"resultsPolish_{particle_list_name}.txt") results = [] for particle_number, particle in enumerate(particlelist): rot = (particle.getRotation().getZ1(), particle.getRotation().getX(), particle.getRotation().getZ2()) # loop over tiltrange, take patch and cross correlate with reprojected subtomogram for img, ang in zip(projections, tilt_angles): pick_position = particle.getPickPosition().toVector() result = run_single_tilt_angle(template, ang, offset, vol_size, pick_position, rot, particle.getFilename(), particle_number, binning, data, create_graphics, fsc_path, dimz, peak_border, img, averaged_subtomogram) results.append(tuple(result)) try: np.savetxt(results_file, np.array(results, dtype=LOCAL_ALIGNMENT_RESULTS), fmt=fmtLAR, header=headerLocalAlignmentResults) except Exception as e: print(e) for res in results: print('{:7d} {:15.3f} {:15.3f} {:15.3f} {:15.3f} {:15.10f} {:s}'. format(*res)) break if verbose: print("{:s}> Ran the processes".format(gettime()))