def colorwheel_RGB(rad): """Makes a 4-quadrant RGB color-wheel as a np array to be inserted into the color-image Args: rad (int): (`optional`) Radius of color-wheel in pixels. (default None -> height/16) Set rad = 0 to remove color-wheel. Returns: ``ndarray``: Numpy array of shape (2*rad, 2*rad). """ # make black -> white gradients dim = rad * 2 grad_x = np.array([np.arange(dim) - rad for _ in range(dim)]) / rad grad_y = grad_x.T # make the binary mask tr = dist(dim, dim, shift=True) * dim circ = np.where(tr > rad, 0, 1) # magnitude of RGB values (equiv to value in HSV) bmag = np.sqrt((grad_x**2 + grad_y**2)) # remove 0 to divide, make other grad distributions bmag = np.where(bmag != 0, bmag, 1) cang = grad_x / bmag sang = np.sqrt(1 - cang * cang) # define the quadrants q1 = ((grad_x >= 0) * (grad_y <= 0)).astype(int) q2 = ((grad_x < 0) * (grad_y < 0)).astype(int) q3 = ((grad_x <= 0) * (grad_y >= 0)).astype(int) q4 = ((grad_x > 0) * (grad_y > 0)).astype(int) # Apply to colors green = q1 * bmag * np.abs(sang) green = green + q2 * bmag green = green + q3 * bmag * np.abs(cang) red = q1 * bmag red = red + q2 * bmag * np.abs(sang) red = red + q4 * bmag * np.abs(cang) blue = (q3 + q4) * bmag * np.abs(sang) # apply masks green = green * circ red = red * circ blue = blue * circ # stack into one image and fix center from divide by 0 error cwheel = np.dstack((red, green, blue)) cwheel[rad, rad] = [0, 0, 0] cwheel = np.array(cwheel / np.max(cwheel)) return cwheel
def sim_images(mphi=None, ephi=None, pscope=None, isl_shape=None, del_px=1, def_val=0, add_random=False, save_path=None, save_name=None, isl_thk=20, isl_xip0=50, mem_thk=50, mem_xip0=1000, v=1, Filter=True): """Simulate LTEM images for a given electron phase shift through a sample. This function returns LTEM images simulated for in-focus and at +/- def_val for comparison to experimental data and reconstruction. It was primarily written for simulating images of magnetic island structures, and as such the sample is defined in two parts: a uniform support membrane across the region and islands of magnetic material defined by an array isl_shape. The magnetization is defined with 2D arrays corresponding to the x- and y-components of the magnetization vector. There are many required parameters here that must be set to account for the support membrane. The default values apply to 20nm permalloy islands on a 50nm SiN membrane window. There is a known bug where sharp edges in the ephi creates problems with the image simulations. As a workaround, this function applies a light gaussian filter (sigma = 1 pixel) to the ephi and isl_shape arrays. This can be controlled with the ``filter`` argument. Args: mphi (2D array): Numpy array of size (M, N), magnetic phase shift ephi (2D array): Numpy array of size (M, N), Electrostatic phase shift pscope (``Microscope`` object): Contains all microscope parameters as well as methods for propagating electron wave functions. isl_shape (2D/3D array): Array of size (z,y,x) or (y,x). If 2D the thickness will be taken as the isl_shape values multiplied by isl_thickness. If 3D, the isl_shape array will be summed along the z-axis becoming and multiplied by isl_thickness. (Default) None -> uniform flat material with thickness = isl_thk. del_px (Float): Scale factor (nm/pixel). Default = 1. def_val (Float): The defocus values at which to calculate the images. add_random (Float): Whether or not to add amorphous background to the simulation. True or 1 will add a default background, any other value will be multiplied to scale the additional phase term. save_path: String. Will save a stack [underfocus, infocus, overfocus] as well as (mphi+ephi) as tiffs along with a params.text file. (Default) None -> Does not save. save_name (str): Name prepended to saved files. v (int): Verbosity. Set v=0 to suppress print statements. isl_thk (float): Island thickness (nm). Default 20 (nm). isl_xip0 (float): Island extinction distance (nm). Default 50 (nm). mem_thk (float): Support membrane thickness (nm). Default 50 (nm). mem_xip0 (float): Support membrane extinction distance (nm). Default 1000 (nm). Filter (Bool): Apply a light gaussian filter to ephi and isl_shape. Returns: tuple: (Tphi, im_un, im_in, im_ov) - Tphi (`2D array`) -- Numpy array of size (M,N). Total electron phase shift (ephi+mphi). - im_un (`2D array`) -- Numpy array of size (M,N). Simulated image at delta z = -def_val. - im_in (`2D array`) -- Numpy array of size (M,N). Simulated image at zero defocus. - im_ov (`2D array`) -- Numpy array of size (M,N). Simulated image at delta z = +def_val. """ vprint = print if v>=1 else lambda *a, **k: None if Filter: ephi = gaussian_filter(ephi, sigma=1) Tphi = mphi + ephi vprint(f'Total fov is ({np.shape(Tphi)[1]*del_px:.3g},{np.shape(Tphi)[0]*del_px:.3g}) nm') dy, dx = Tphi.shape if add_random: if type(add_random) == bool: add_random = 1.0 ran_phi = np.random.uniform(low = -np.pi/128*add_random, high = np.pi/128*add_random, size=[dy,dx]) if np.max(ephi) > 1: # scale by ephi only if it's given and relevant ran_phi *= np.max(ephi) Tphi += ran_phi #amplitude if isl_shape is None: thk_map = np.ones(Tphi.shape)*isl_thk else: if type(isl_shape) != np.ndarray: isl_shape = np.array(isl_shape) if isl_shape.ndim == 3: thk_map = np.sum(isl_shape, axis=0)*isl_thk elif isl_shape.ndim == 2: thk_map = isl_shape*isl_thk else: vprint(textwrap.dedent(f""" Mask given must be 2D (y,x) or 3D (z,y,x) array. It was given as a {isl_shape.ndim} dimension array.""")) sys.exit(1) if Filter: thk_map = gaussian_filter(thk_map, sigma=1) Amp = np.exp((-np.ones([dy,dx]) * mem_thk / mem_xip0) - (thk_map / isl_xip0)) ObjWave = Amp * (np.cos(Tphi) + 1j * np.sin(Tphi)) # compute unflipped images qq = dist(dy, dx, shift=True) pscope.defocus = 0.0 im_in = pscope.getImage(ObjWave,qq,del_px) pscope.defocus = -def_val im_un = pscope.getImage(ObjWave,qq,del_px) pscope.defocus = def_val im_ov = pscope.getImage(ObjWave,qq,del_px) if save_path is not None: vprint(f'saving to {save_path}') im_stack = np.array([im_un, im_in, im_ov]) if not os.path.exists(save_path): os.makedirs(save_path) res = 1/del_px tifffile.imsave(os.path.join(save_path, f'{save_name}_align.tiff'), im_stack.astype('float32'), imagej = True, resolution = (res, res), metadata={'unit': 'nm'}) tifffile.imsave(os.path.join(save_path, f'{save_name}_phase.tiff'), Tphi.astype('float32'), imagej = True, resolution = (res, res), metadata={'unit': 'nm'}) with io.open(os.path.join(save_path, f'{save_name}_params.txt'), 'w') as text: text.write(f"def_val (nm) \t{def_val:g}\n") text.write(f"del_px (nm/pix) \t{del_px:g}\n") text.write(f"scope En. (V) \t{pscope.E:g}\n") text.write(f"im_size (pix) \t({dy:g},{dx:g})\n") text.write(f"sample_thk (nm) \t{isl_thk:g}\n") text.write(f"sample_xip0 (nm) \t{isl_xip0:g}\n") text.write(f"mem_thk (nm) \t{mem_thk:g}\n") text.write(f"mem_xip0 (nm) \t{mem_xip0:g}\n") text.write(f"add_random \t{add_random:g}\n") return (Tphi, im_un, im_in, im_ov)
def SITIE(image=None, defval=None, scale=1, E=200e3, ptie=None, i=-1, flipstack=False, pscope=None, data_loc='', dataname='', sym=False, qc=None, save=False, v=1): """Uses a modified derivative to get the magnetic phase shift with TIE from a single image. This technique is only applicable to uniformly thin samples from which the only source of contrast is magnetic Fresnel contrast. All other sources of contrast including sample contamination, thickness variation, and diffraction contrast will give false magnetic inductions. For more information please refer to: Chess, J. J. et al. Ultramicroscopy 177, 78–83 (2018). This function has two ways of picking which image to use. First, if an image is given directly along with a defocus value, it will use that. You should also be sure to specify the scale of the image and accelerating voltage of the microscope (default 200kV). You can also choose to pass it an image from a ``TIE_params`` object, in which case you need specify only whether to choose from the imstack or flipstack and the index of the image to use. It's possible that in the future this method of selecting an image will be removed or moved to a separate function. Args: image (2D array): Input image to reconstruct. defval (float): Defocus value corresponding to ``image``. scale (float): Scale (nm/pixel) corresponding to ``image``. E (float): Accelerating voltage of microscope that produced ``image``. ptie (``TIE_params`` object): Object containing the image. From TIE_params.py i (int): Index of `the ptie.imstack` or `ptie.flipstack` to reconstruct. This is not the defocus index like in TIE. Default value is -1 which corresponds to the most overfocused image. flipstack (bool): (`optional`) Whether to pull the image from ptie.imstack[i] or ptie.flipstack[i]. Default is False, calls image from imstack. pscope (``Microscope`` object): Should have same accelerating voltage as the microscope that took the images. dataname (str): The output filename to be used for saving the images. sym (bool): (`optional`) Fourier edge effects are marginally improved by symmetrizing the images before reconstructing. Default False. qc (float/str): (`optional`) The Tikhonov frequency to use as filter. Default None. If you use a Tikhonov filter the resulting phase shift and induction is no longer quantitative. save (bool/str): Whether you want to save the output. =========== ============ input value saved images =========== ============ True All images 'b' bx, by, and color image 'color' Color image False None =========== ============ Files will be saved as ptie.data_loc/images/dataname_<defval>_<key>.tiff, where <key> is the key for the returned dictionary that corresponds to the image. v (int): (`optional`) Verbosity. === ======== v print output === ======== 0 No output 1 Default output 2 Extended output for debugging. === ======== Returns: dict: A dictionary of image arrays ========= ============== key value ========= ============== 'byt' y-component of integrated magnetic induction 'bxt' x-component of integrated magnetic induction 'bbt' Magnitude of integrated magnetic induction 'phase_m' Magnetic phase shift (radians) 'color_b' RGB image of magnetization ========= ============== """ results = { 'byt': None, 'bxt': None, 'bbt': None, 'phase_m': None, 'color_b': None } # turning off the print function if v=0 vprint = print if v >= 1 else lambda *a, **k: None if image is not None and defval is not None: vprint( f"Running with given image, defval = {defval:g}nm, and scale = {scale:.3g}nm/pixel" ) ptie = TIE_params(imstack=[image], defvals=[defval], data_loc=data_loc, v=0) ptie.set_scale(scale) dim_y, dim_x = image.shape if pscope is None: pscope = Microscope(E=E) else: # selecting the right defocus value for the image if i >= ptie.num_files: print("i given outside range.") sys.exit(1) else: if ptie.num_files > 1: unders = list(reversed([-1 * i for i in ptie.defvals])) defvals = unders + [0] + ptie.defvals defval = defvals[i] else: defval = ptie.defvals[0] vprint(f'SITIE defocus: {defval:g} nm') right, left = ptie.crop['right'], ptie.crop['left'] bottom, top = ptie.crop['bottom'], ptie.crop['top'] dim_y = bottom - top dim_x = right - left vprint(f"Reconstructing with ptie image {i} and defval {defval}") if flipstack: print("Reconstructing with single flipped image.") image = ptie.flipstack[i].data[top:bottom, left:right] else: image = ptie.imstack[i].data[top:bottom, left:right] if sym: print("Reconstructing with symmetrized image.") dim_y *= 2 dim_x *= 2 # setup the inverse frequency distribution q = dist(dim_y, dim_x) q[0, 0] = 1 if qc is not None and qc is not False: # add Tikhonov filter print("Reconstructing with Tikhonov value: {:}".format(qc)) qi = q**2 / (q**2 + qc**2)**2 else: # normal laplacian method print("Reconstructing with normal Laplacian method") qi = 1 / q**2 qi[0, 0] = 0 ptie.qi = qi # saves the freq dist # constructing "infocus" image infocus = np.ones(np.shape(image)) * np.mean(image) # calculate "derivative" and normalize dIdZ = 2 * (image - infocus) dIdZ -= np.sum(dIdZ) / np.size(infocus) ### Now calling the phase reconstruct in the normal way print('Calling SITIE solver\n') resultsB = phase_reconstruct(ptie, infocus, dIdZ, pscope, defval, sym=sym) results['byt'] = resultsB['ind_y'] results['bxt'] = resultsB['ind_x'] results['bbt'] = np.sqrt(resultsB['ind_x']**2 + resultsB['ind_y']**2) results['phase_m'] = resultsB['phase'] results['color_b'] = color_im(resultsB['ind_x'], resultsB['ind_y'], hsvwheel=True, background='black') if v >= 1: show_im(results['color_b'], "B field color, HSV colorhweel", cbar=False, scale=scale) # save the images if save: save_results(defval, results, ptie, dataname, sym, qc, save, v, directory="SITIE") print('Phase reconstruction completed.') return results
def TIE(i=-1, ptie=None, pscope=None, dataname='', sym=False, qc=None, save=False, hsv=True, long_deriv=False, v=1): """Sets up the TIE reconstruction and calls phase_reconstruct. This function calculates the necessary arrays, derivatives, etc. and then passes them to phase_reconstruct which solve the TIE. Args: i (int): Index of ptie.defvals to use for reconstruction. Default value is -1 which corresponds to the most defocused images for a central difference method derivative. i is ignored if using a longitudinal derivative. ptie (``TIE_params`` object): Object containing the images and other data parameters. From TIE_params.py pscope (``Microscope`` object): Should have same accelerating voltage as the microscope that took the images. dataname (str): The output filename to be used for saving the images. sym (bool): (`optional`) Fourier edge effects are marginally improved by symmetrizing the images before reconstructing. Default False. qc (float/str): (`optional`) The Tikhonov frequency to use as filter. Default None. If you use a Tikhonov filter the resulting phase shift and induction is no longer quantitative. save (bool/str): Whether you want to save the output. =========== ============ input value saved images =========== ============ True All images 'b' bx, by, and color image 'color' Color image False None =========== ============ Files will be saved as ptie.data_loc/images/dataname_<defval>_<key>.tiff, where <key> is the key for the results dictionary that corresponds to the image. hsv (bool): Whether to use the hsv colorwheel (True) or the 4-fold colorwheel (False). long_deriv (bool): Whether to use the longitudinal derivative (True) or central difference method (False). Default False. v (int): (`optional`) Verbosity. === ======== v print output === ======== 0 No output 1 Default output 2 Extended output for debugging. === ======== Returns: dict: A dictionary of image arrays ========= ============== key value ========= ============== 'byt' y-component of integrated magnetic induction 'bxt' x-component of integrated magnetic induction 'bbt' Magnitude of integrated magnetic induction 'phase_m' Magnetic phase shift (radians) 'phase_e' Electrostatic phase shift (if using flip stack) (radians) 'dIdZ_m' Intensity derivative for calculating phase_m 'dIdZ_e' Intensity derivative for calculating phase_e (if using flip stack) 'color_b' RGB image of magnetization 'inf_im' In-focus image ========= ============== """ results = { 'byt': None, 'bxt': None, 'bbt': None, 'phase_e': None, 'phase_m': None, 'dIdZ_m': None, 'dIdZ_e': None, 'color_b': None, 'inf_im': None } # turning off the print function if v=0 vprint = print if v >= 1 else lambda *a, **k: None if long_deriv: unders = list(reversed([-1 * ii for ii in ptie.defvals])) defval = unders + [0] + ptie.defvals if ptie.flip: vprint('Aligning with complete longitudinal derivatives:\n', defval, '\nwith both flip/unflip tfs.') else: vprint('Aligning with complete longitudinal derivatives:\n', defval, '\nwith only unflip tfs.') else: defval = ptie.defvals[i] if ptie.flip: vprint( f'Aligning for defocus value: {defval:g}, with both flip/unflip tfs.' ) else: vprint( f'Aligning for defocus value: {defval:g}, with only unflip tfs.' ) right, left = ptie.crop['right'], ptie.crop['left'] bottom, top = ptie.crop['bottom'], ptie.crop['top'] dim_y = bottom - top dim_x = right - left tifs = select_tifs(i, ptie, long_deriv) if sym: vprint("Reconstructing with symmetrized image.") dim_y *= 2 dim_x *= 2 # make the inverse laplacian, uses python implementation of IDL dist funct q = dist(dim_y, dim_x) q[0, 0] = 1 if qc is not None and qc is not False: vprint("Reconstructing with Tikhonov value: {:}".format(qc)) qi = q**2 / (q**2 + qc**2)**2 else: # normal Laplacian method vprint("Reconstructing with normal Laplacian method") qi = 1 / q**2 qi[0, 0] = 0 ptie.qi = qi # saves the freq dist # If rotation and translation to be applied if ptie.rotation != 0 or ptie.x_transl != 0 or ptie.y_transl != 0: rotate, x_shift, y_shift = ptie.rotation, ptie.x_transl, ptie.y_transl for ii in range(len(tifs)): tifs[ii] = scipy.ndimage.rotate(tifs[ii], rotate, reshape=False, order=0) tifs[ii] = scipy.ndimage.shift(tifs[ii], (-y_shift, x_shift), order=0) mask = scipy.ndimage.rotate(ptie.mask, rotate, reshape=False, order=0) mask = scipy.ndimage.shift(mask, (-y_shift, x_shift), order=0) # crop images and apply mask if ptie.rotation == 0 and ptie.x_transl == 0 and ptie.y_transl == 0: mask = ptie.mask[top:bottom, left:right] else: mask = mask[top:bottom, left:right] # crop images and apply mask # mask = ptie.mask[top:bottom, left:right] for ii in range(len(tifs)): tifs[ii] = tifs[ii][top:bottom, left:right] tifs[ii] *= mask # Normalizing, scaling the images scaled_tifs = scale_stack(tifs) scaled_tifs += 1e-9 # get the infocus image if long_deriv and ptie.flip: inf_unflip = scaled_tifs[len(tifs) // 4] inf_flip = scaled_tifs[3 * len(tifs) // 4] inf_im = (inf_unflip + inf_flip) / 2 else: inf_im = scaled_tifs[len(tifs) // 2] # Inverting masked areas on infocus image because we divide by it inf_im += 1 - mask # Make sure there are no zeros left: inf_im = np.where(scaled_tifs[len(tifs) // 2] == 0, 0.001, inf_im) results['inf_im'] = inf_im if v >= 2: print("""\nScaled images (+- = unflip/flip, +- = over/underfocus) in order [ +- , -- , 0 , ++ , -+ ]""") for im in scaled_tifs: print("max: {:.3f}, min: {:.2f}, total intensity: {:.4f}".format( np.max(im), np.min(im), np.sum(im))) print() # Calculate derivatives if long_deriv: # have to renormalize each stack unflip_stack = tifs[:ptie.num_files] unflip_stack = scale_stack(unflip_stack) + 1e-9 flip_stack = tifs[ptie.num_files:] flip_stack = scale_stack(flip_stack) + 1e-9 vprint('Computing the longitudinal derivative.') unflip_deriv = polyfit_deriv(unflip_stack, defval, v) if ptie.flip: vprint('Computing the flip stack longitudinal derivative.') flip_deriv = polyfit_deriv(flip_stack, defval, v) dIdZ_m = (unflip_deriv - flip_deriv) / 2 dIdZ_e = (unflip_deriv + flip_deriv) / 2 else: dIdZ_m = unflip_deriv else: # three point derivative, default. if ptie.flip: dIdZ_m = 1 / 2 * (scaled_tifs[3] - scaled_tifs[0] - (scaled_tifs[4] - scaled_tifs[1])) dIdZ_e = 1 / 2 * (scaled_tifs[3] - scaled_tifs[0] + (scaled_tifs[4] - scaled_tifs[1])) else: dIdZ_m = scaled_tifs[2] - scaled_tifs[0] # Set derivatives to have 0 total "energy" dIdZ_m *= mask totm = np.sum(dIdZ_m) / np.sum(mask) dIdZ_m -= totm dIdZ_m *= mask results['dIdZ_m'] = dIdZ_m if ptie.flip: dIdZ_e *= mask tote = np.sum(dIdZ_e) / np.sum(mask) dIdZ_e -= tote dIdZ_e *= mask results['dIdZ_e'] = dIdZ_e ### Now time to call phase_reconstruct, first for E if we have a flipped tfs vprint('Calling TIE solver\n') if ptie.flip: resultsE = phase_reconstruct(ptie, inf_im, dIdZ_e, pscope, defval, sym=sym, long_deriv=long_deriv) # We only care about the E phase. results['phase_e'] = resultsE['phase'] ### Now run for B, resultsB = phase_reconstruct(ptie, inf_im, dIdZ_m, pscope, defval, sym=sym, long_deriv=long_deriv) results['byt'] = resultsB['ind_y'] results['bxt'] = resultsB['ind_x'] results['bbt'] = np.sqrt(resultsB['ind_x']**2 + resultsB['ind_y']**2) results['phase_m'] = resultsB['phase'] results['color_b'] = color_im(resultsB['ind_x'], resultsB['ind_y'], hsvwheel=hsv, background='black') if v >= 1: show_im(results['color_b'], "B-field color HSV colorwheel", cbar=False, scale=ptie.scale) # save the images if save: save_results(defval, results, ptie, dataname, sym, qc, save, v, long_deriv=long_deriv) vprint('Phase reconstruction completed.') return results
def SITIE(ptie=None, pscope=None, dataname='', sym=False, qc=None, save=True, i=-1, flipstack=False, v=1): """Uses a modified derivative to get the magnetic phase shift with TIE from a single image. This technique is only appplicable to uniformly thin samples from which the only source of contrast is magnetic Fresnel contrast. All other sources of contrast including dirt on the sample, thickness variation, and diffraction contrast will give false magnetic inductions. For more information please refer to: Chess, J. J. et al. Ultramicroscopy 177, 78–83 (2018). Args: ptie: TIE_params object. Object containing the image from TIE_params.py pscope : microscope object. Should have correct accelerating voltage as the microscope that took the images. dataname : String. The output filename to be used for saving the images. Files will be saved ptie.data_loc/images/dataname_<defval>_<key>.tiff sym: Boolean. Fourier edge effects are marginally improved by symmetrizing the images before reconstructing (image reconstructed is 4x as large). Default False. qc: Float. The Tikhonov frequency to use as filter, or "percent" to use 15% of q, Default None. save: Bool or string. Whether you want to save the output. Default False. save = True -> saves all images. save = 'b' -> save just bx, by, and color_b save = 'color' -> saves just color_b save = False -> don't save. Saves the images to ptie.data_loc/images/ long_deriv: Bool. Whether to use the longitudinal derivative (True) or central difference method (False). Default False. i: Int. index of __the ptie.imstack or ptie.flipstack__ to reconstruct. This is not the defocus index like in TIE. Default value is -1 which corresponds to the most overfocused image. flipstack: Bool. Whether to pull the image from the ptie.dmrstack[i] or ptie.flipstack[i]. Default is False, calls image from imstack. v: Int. Verbosity. 0 : ##TODO no output 1 : Default output 2 : Extended output for debugging. Returns: A dictionary of arrays. results = { 'byt' : y-component of integrated magnetic induction, 'bxt' : x-copmonent of integrated magnetic induction, 'bbt' : magnitude of integrated magnetic induction, 'phase_m' : magnetic phase shift (radians), 'color_b' : RGB image of magnetization, } """ results = { 'byt' : None, 'bxt' : None, 'bbt' : None, 'phase_m' : None, 'color_b' : None} # turning off the print function if v=0 vprint = print if v>=1 else lambda *a, **k: None # selecting the right defocus value for the image if i >= ptie.num_files: print("i given outside range.") sys.exit(1) else: if ptie.num_files > 1: unders = list(reversed([-1*i for i in ptie.defvals])) defvals = unders + [0] + ptie.defvals defval = defvals[i] else: defval = ptie.defvals[0] vprint(f'SITIE defocus: {defval} nm') right, left = ptie.crop['right'] , ptie.crop['left'] bottom, top = ptie.crop['bottom'] , ptie.crop['top'] dim_y = bottom - top dim_x = right - left if flipstack: print("Reconstructing with single flipped image.") image = ptie.flipstack[i].data[top:bottom, left:right] else: image = ptie.imstack[i].data[top:bottom, left:right] if sym: print("Reconstructing with symmetrized image.") dim_y *= 2 dim_x *= 2 # setup the inverse frequency distribution q = dist(dim_y,dim_x) q[0, 0] = 1 if qc is not None and qc is not False: # add Tikhonov filter if qc == 'percent': print("Reconstructing with Tikhonov percentage: 15%") qc = 0.15 * q * ptie.scale**2 else: qc = qc print("Reconstructing with Tikhonov value: {:}".format(qc)) qi = q**2 / (q**2 + qc**2)**2 else: # normal laplacian method print("Reconstructing with normal Laplacian method") qi = 1 / q**2 qi[0, 0] = 0 ptie.qi = qi # saves the freq dist # constructing "infocus" image infocus = np.ones(np.shape(image))*np.mean(image) # calculate "derivative" and normalize dIdZ = 2 * (image - infocus) dIdZ -= np.sum(dIdZ)/np.size(infocus) ### Now calling the phase reconstruct in the normal way print('Calling SITIE solver\n') resultsB = phase_reconstruct(ptie, infocus, dIdZ, pscope, defval, sym = sym) results['byt'] = resultsB['ind_y'] results['bxt'] = resultsB['ind_x'] results['bbt'] = np.sqrt(resultsB['ind_x']**2 + resultsB['ind_y']**2) results['phase_m'] = resultsB['phase'] results['color_b'] = color_im(resultsB['ind_x'], resultsB['ind_y'], hsvwheel=True, background='black') if v >= 1: show_im(results['color_b'], "B field color, HSV colorhweel") # save the images if save: save_results(defval, results, ptie, dataname, sym, qc, save, v, directory = "SITIE") print('Phase reconstruction completed.') return results
def TIE(i=-1, ptie=None, pscope=None, dataname='', sym=False, qc=None, save=False, long_deriv=False, v=1): """Sets up the TIE reconstruction and calls phase_reconstruct. This function calculates the necessary arrays, derivatives, etc. and then calls passes them to phase_reconstruct which solve the TIE. Args: i: Int. index of ptie.defvals to use for reconstruction. Default value is -1 which corresponds to the most defocused images for a central difference method derivative. i is ignored if using a longitudinal derivative. ptie: TIE_params object. Object containing the image from TIE_params.py pscope : microscope object. Should have correct accelerating voltage as the microscope that took the images. dataname : String. The output filename to be used for saving the images. Files will be saved ptie.data_loc/images/dataname_<defval>_<key>.tiff sym: Boolean. Fourier edge effects are marginally improved by symmetrizing the images before reconstructing (image reconstructed is 4x as large). Default False. qc: Float. The Tikhonov frequency to use as filter, or "percent" to use 15% of q, Default None. If you use a Tikhonov filter the resulting magnetization is no longer quantitative! save: Bool or string. Whether you want to save the output. Default False. save = True -> saves all images. save = 'b' -> save just bx, by, and color_b save = 'color' -> saves just color_b save = False -> don't save. Saves the images to ptie.data_loc/images/ long_deriv: Bool. Whether to use the longitudinal derivative (True) or central difference method (False). Default False. __Currently has bugs__. Qualitatively looks alright but quantitatively is not accurate. v: Int. Verbosity. 0 : no output 1 : Default output 2 : Extended output for debugging. Returns: A dictionary of arrays. results = { 'byt' : y-component of integrated magnetic induction, 'bxt' : x-copmonent of integrated magnetic induction, 'bbt' : magnitude of integrated magnetic induction, 'phase_m' : magnetic phase shift (radians), 'phase_e' : electrostatic phase shift (if using flip stack) (radians), 'dIdZ_m' : intensity derivative for calculating phase_m, 'dIdZ_e' : intensity derivative for calculating phase_e (if using flip stack), 'color_b' : RGB image of magnetization, 'inf_im' : the in-focus image } """ results = { 'byt' : None, 'bxt' : None, 'bbt' : None, 'phase_e' : None, 'phase_m' : None, 'dIdZ_m' : None, 'dIdZ_e' : None, 'color_b' : None, 'inf_im' : None} # turning off the print function if v=0 vprint = print if v>=1 else lambda *a, **k: None if long_deriv: unders = list(reversed([-1*ii for ii in ptie.defvals])) defval = unders + [0] + ptie.defvals if ptie.flip: vprint('Aligning with complete longitudinal derivates:\n', defval, '\nwith both flip/unflip tfs.') else: vprint('Aligning with complete longitudinal derivates:\n', defval, '\nwith only unflip tfs.') else: defval = ptie.defvals[i] if ptie.flip: vprint('Aligning for defocus value: ', defval, ' with both flip/unflip tfs.') else: vprint('Aligning for defocus value: ', defval, ' with only unflip tfs.') right, left = ptie.crop['right'] , ptie.crop['left'] bottom, top = ptie.crop['bottom'] , ptie.crop['top'] dim_y = bottom - top dim_x = right - left tifs = select_tifs(i, ptie, long_deriv) if sym: vprint("Reconstructing with symmetrized image.") dim_y *= 2 dim_x *= 2 # make the inverse laplacian, uses python implementation of IDL dist funct q = dist(dim_y,dim_x) q[0, 0] = 1 if qc is not None and qc is not False: if qc == 'percent': vprint("Reconstructing with Tikhonov percentage: 15%") qc = 0.15 * q * ptie.scale**2 else: qc = qc vprint("Reconstructing with Tikhonov value: {:}".format(qc)) qi = q**2 / (q**2 + qc**2)**2 else: # normal laplacian method vprint("Reconstructing with normal Laplacian method") qi = 1 / q**2 qi[0, 0] = 0 ptie.qi = qi # saves the freq dist # crop images and apply mask mask = ptie.mask[top:bottom, left:right] for ii in range(len(tifs)): tifs[ii] = tifs[ii][top:bottom, left:right] tifs[ii] *= mask # Normalizing, scaling the images scaled_tifs = scale_stack(tifs) # very small offset from 0, affects uniform magnetizations # but can be compensated for (if 0) by symmetrizing the image. scaled_tifs += 1e-9 # get the infocus image if long_deriv and ptie.flip: inf_unflip = scaled_tifs[len(tifs)//4] inf_flip = scaled_tifs[3*len(tifs)//4] inf_im = (inf_unflip+inf_flip)/2 else: inf_im = scaled_tifs[len(tifs)//2] # Inverting masked areas on infocus image because we divide by it inf_im += 1 - mask # Make sure there are no zeros left: inf_im = np.where(scaled_tifs[len(tifs)//2] == 0, 0.001, inf_im) results['inf_im'] = inf_im if v >= 2: print("""\nScaled images (+- = unflip/flip, +- = over/underfocus) in order [ +- , -- , 0 , ++ , -+ ]""") for im in scaled_tifs: print("max: {:.3f}, min: {:.2f}, total intensity: {:.4f}".format( np.max(im), np.min(im), np.sum(im))) print() # Calculate derivatives if long_deriv: unflip_stack = tifs[:ptie.num_files] flip_stack = tifs[ptie.num_files:] if long_deriv == 'multi': vprint('Computing the longitudinal derivative with Multiprocessing.') unflip_deriv = polyfit_deriv_multiprocess(unflip_stack, defval) else: vprint('Computing the longitudinal derivative normally.') unflip_deriv = polyfit_deriv(unflip_stack, defval, v) if ptie.flip: if long_deriv == 'multi': vprint('Computing the flip stack longitudinal derivative with Multiprocessing.') flip_deriv = polyfit_deriv_multiprocess(flip_stack, defval) else: vprint('Computing the flip stack longitudinal derivative normally.') flip_deriv = polyfit_deriv(flip_stack, defval, v) dIdZ_m = (unflip_deriv - flip_deriv)/2 dIdZ_e = (unflip_deriv + flip_deriv)/2 else: dIdZ_m = unflip_deriv else: if ptie.flip: dIdZ_m = 1/2 * (scaled_tifs[3] - scaled_tifs[0] - (scaled_tifs[4] - scaled_tifs[1])) dIdZ_e = 1/2 * (scaled_tifs[3] - scaled_tifs[0] + (scaled_tifs[4] - scaled_tifs[1])) else: dIdZ_m = scaled_tifs[2] - scaled_tifs[0] # Set derivatives to have 0 total "energy" dIdZ_m *= mask totm = np.sum(dIdZ_m)/np.sum(mask) dIdZ_m -= totm dIdZ_m *= mask results['dIdZ_m'] = dIdZ_m if ptie.flip: dIdZ_e *= mask tote = np.sum(dIdZ_e)/np.sum(mask) dIdZ_e -= tote dIdZ_e *= mask results['dIdZ_e'] = dIdZ_e ### Now time to call phase_reconstruct, first for E if we have a flipped tfs vprint('Calling TIE solver\n') if ptie.flip: resultsE = phase_reconstruct(ptie, inf_im, dIdZ_e, pscope, defval, sym = sym, long_deriv = long_deriv) # We only care about the E phase. results['phase_e'] = resultsE['phase'] ### Now run for B, resultsB = phase_reconstruct(ptie, inf_im, dIdZ_m, pscope, defval, sym = sym, long_deriv = long_deriv) results['byt'] = resultsB['ind_y'] results['bxt'] = resultsB['ind_x'] results['bbt'] = np.sqrt(resultsB['ind_x']**2 + resultsB['ind_y']**2) results['phase_m'] = resultsB['phase'] results['color_b'] = color_im(resultsB['ind_x'], resultsB['ind_y'], hsvwheel=True, background='black') if v >= 1: show_im(results['color_b'], "B-field color HSV colorwheel") # save the images if save: save_results(defval, results, ptie, dataname, sym, qc, save, v, long_deriv = long_deriv) vprint('Phase reconstruction completed.') return results