def transform_scalars(dataset, resampling_factor=[1, 1, 1]): """Resample dataset""" from tomviz import utils import scipy.ndimage import numpy as np array = utils.get_array(dataset) # Transform the dataset. result_shape = utils.zoom_shape(array, resampling_factor) result = np.empty(result_shape, array.dtype, order='F') scipy.ndimage.interpolation.zoom(array, resampling_factor, output=result) # Set the result as the new scalars. utils.set_array(dataset, result) # Update tilt angles if dataset is a tilt series. if resampling_factor[2] != 1: try: tilt_angles = utils.get_tilt_angles(dataset) result_shape = utils.zoom_shape(tilt_angles, resampling_factor[2]) result = np.empty(result_shape, array.dtype, order='F') scipy.ndimage.interpolation.zoom(tilt_angles, resampling_factor[2], output=result) utils.set_tilt_angles(dataset, result) except: # noqa # TODO What exception are we ignoring? pass
def transform_scalars(self, dataset, N=25): """Add Poisson noise to tilt images""" self.progress.maximum = 1 tiltSeries = utils.get_array(dataset).astype(float) if tiltSeries is None: raise RuntimeError("No scalars found!") Ndata = tiltSeries.shape[0] * tiltSeries.shape[1] self.progress.maximum = tiltSeries.shape[2] step = 0 for i in range(tiltSeries.shape[2]): if self.canceled: return tiltImage = tiltSeries[:, :, i].copy() tiltImage = tiltImage / np.sum(tiltSeries[:, :, i]) * (Ndata * N) tiltImage = np.random.poisson(tiltImage) tiltImage = tiltImage * np.sum(tiltSeries[:, :, i]) / (Ndata * N) tiltSeries[:, :, i] = tiltImage.copy() step += 1 self.progress.value = step utils.set_array(dataset, tiltSeries)
def transform_scalars(dataset): """Downsample volume by a factor of 2""" from tomviz import utils import scipy.ndimage import numpy as np array = utils.get_array(dataset) # Downsample the dataset x2 using order 1 spline (linear) # Calculate out array shape zoom = (0.5, 0.5, 0.5) result_shape = utils.zoom_shape(array, zoom) result = np.empty(result_shape, array.dtype, order='F') scipy.ndimage.interpolation.zoom(array, zoom, output=result, order=1, mode='constant', cval=0.0, prefilter=False) # Set the result as the new scalars. utils.set_array(dataset, result) # Update tilt angles if dataset is a tilt series. try: tilt_angles = utils.get_tilt_angles(dataset) result_shape = utils.zoom_shape(tilt_angles, 0.5) result = np.empty(result_shape, array.dtype, order='F') tilt_angles = scipy.ndimage.interpolation.zoom(tilt_angles, 0.5, output=result) utils.set_tilt_angles(dataset, result) except: # noqa # TODO What exception are we ignoring? pass
def transform_scalars(dataset): """Downsample tilt images by a factor of 2""" from tomviz import utils import scipy.ndimage import numpy as np import warnings array = utils.get_array(dataset) zoom = (0.5, 0.5, 1) result_shape = utils.zoom_shape(array, zoom) result = np.empty(result_shape, array.dtype, order='F') # Downsample the dataset x2 using order 1 spline (linear) warnings.filterwarnings('ignore', '.*output shape of zoom.*') scipy.ndimage.interpolation.zoom(array, zoom, output=result, order=1, mode='constant', cval=0.0, prefilter=False) # Set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(dataset, SHIFT=None, rotation_angle=90.0): from tomviz import utils from scipy import ndimage import numpy as np data_py = utils.get_array(dataset) # Get data as numpy array. if data_py is None: #Check if data exists raise RuntimeError("No data array found!") if SHIFT is None: SHIFT = np.zeros(len(data_py.shape), dtype=np.int) data_py_return = np.empty_like(data_py) ndimage.interpolation.shift(data_py, SHIFT, order=0, output=data_py_return) rotation_axis = 2 # This operator always assumes the rotation axis is Z if rotation_angle == []: # If tilt angle not given, assign it to 90 degrees. rotation_angle = 90 axis1 = (rotation_axis + 1) % 3 axis2 = (rotation_axis + 2) % 3 axes = (axis1, axis2) shape = utils.rotate_shape(data_py_return, rotation_angle, axes=axes) data_py_return2 = np.empty(shape, data_py_return.dtype, order='F') ndimage.interpolation.rotate( data_py_return, rotation_angle, output=data_py_return2, axes=axes) utils.set_array(dataset, data_py_return2)
def transform_scalars(self, dataset): """Automatically align tilt images by center of mass method""" self.progress.maximum = 1 tiltSeries = utils.get_array(dataset).astype(float) self.progress.maximum = tiltSeries.shape[2] step = 1 offsets = np.zeros((tiltSeries.shape[2], 2)) for i in range(tiltSeries.shape[2]): if self.canceled: return self.progress.message = 'Processing tilt image No.%d/%d' % ( i + 1, tiltSeries.shape[2]) offsets[i, :], tiltSeries[:, :, i] = centerOfMassAlign( tiltSeries[:, :, i] ) step += 1 self.progress.value = step utils.set_array(dataset, tiltSeries) # Create a spreadsheet data set from table data column_names = ["X Offset", "Y Offset"] offsetsTable = utils.make_spreadsheet(column_names, offsets) # Set up dictionary to return operator results returnValues = {} returnValues["alignments"] = offsetsTable return returnValues
def transform_scalars(dataset): '''For each tilt image, the method uses average pixel value of selected region as the background level and subtracts it from the image.''' '''It does NOT set negative pixels to zero.''' from tomviz import utils import numpy as np #----USER SPECIFIED VARIABLES-----# ###XRANGE### ###YRANGE### ###ZRANGE### #---------------------------------# data_bs = utils.get_array(dataset) # Get data as numpy array. data_bs = data_bs.astype(np.float32) # Change tilt series type to float. if data_bs is None: #Check if data exists raise RuntimeError("No data array found!") for i in range(ZRANGE[0], ZRANGE[1]): a = data_bs[:, :, i] - np.average(data_bs[XRANGE[0]:XRANGE[1], YRANGE[0]:YRANGE[1], i]) data_bs[:, :, i] = a utils.set_array(dataset, data_bs)
def transform_scalars(dataset, rotation_angle=90.0, rotation_axis=0): from tomviz import utils import numpy as np from scipy import ndimage data_py = utils.get_array(dataset) #get data as numpy array if data_py is None: #Check if data exists raise RuntimeError("No data array found!") if rotation_axis == []: #If tilt axis is not given, assign one. # Find the smallest array dimension, assume it is the tilt angle axis. if data_py.ndim >= 2: rotation_axis = np.argmin(data_py.shape) else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") if rotation_angle == []: # If tilt angle not given, assign it to 90 degrees. rotation_angle = 90 print('Rotating Dataset...') axis1 = (rotation_axis + 1) % 3 axis2 = (rotation_axis + 2) % 3 data_py_return = ndimage.interpolation.rotate(data_py, rotation_angle, axes=(axis1, axis2)) utils.set_array(dataset, data_py_return) print('Rotation Complete')
def transform_scalars(dataset): """Downsample volume by a factor of 2""" from tomviz import utils import scipy.ndimage array = utils.get_array(dataset) # Downsample the dataset x2 using order 1 spline (linear) result = scipy.ndimage.interpolation.zoom(array, (0.5, 0.5, 0.5), output=None, order=1, mode='constant', cval=0.0, prefilter=False) # Set the result as the new scalars. utils.set_array(dataset, result) # Update tilt angles if dataset is a tilt series. try: tilt_angles = utils.get_tilt_angles(dataset) tilt_angles = scipy.ndimage.interpolation.zoom(tilt_angles, 0.5) utils.set_tilt_angles(dataset, tilt_angles) except: # noqa # TODO What exception are we ignoring? pass
def transform_scalars(dataset): #----USER SPECIFIED VARIABLES-----# ###ROT_AXIS### #Specify Tilt Axis Dimensions x=0, y=1, z=2 ###ROT_ANGLE### #Rotate the dataset by an Angle (in degrees) #---------------------------------# from tomviz import utils import numpy as np from scipy import ndimage data_py = utils.get_array(dataset) #get data as numpy array if data_py is None: #Check if data exists raise RuntimeError("No data array found!") if ROT_AXIS == []: #If tilt axis is not given, assign one. #Find smallest array dimension, assume it is the tilt angle axis if data_py.ndim >= 2: ROT_AXIS = np.argmin(data_py.shape) else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") if ROT_ANGLE == []: #If tilt axis is not given, assign it to 90 degrees. ROT_ANGLE = 90 print('Rotating Dataset...') data_py_return = ndimage.interpolation.rotate(data_py, ROT_ANGLE, axes=((ROT_AXIS + 1) % 3, (ROT_AXIS + 2) % 3)) utils.set_array(dataset, data_py_return) print('Rotation Complete')
def transform_scalars(dataset, threshold=None): """Remove bad pixels in tilt series.""" from tomviz import utils import scipy.ndimage import numpy as np tiltSeries = utils.get_array(dataset).astype(np.float32) for i in range(tiltSeries.shape[2]): I = tiltSeries[:, :, i] I_pad = np.lib.pad(I, (1, 1), 'edge') # calculate standard deviation in a 3 x 3 window averageI2 = scipy.ndimage.filters.uniform_filter(I_pad**2) averageI = scipy.ndimage.filters.uniform_filter(I_pad) std = np.sqrt(abs(averageI2 - averageI**2))[1:-1, 1:-1] medianI = scipy.ndimage.filters.median_filter(I_pad, 2)[1:-1, 1:-1] #identiy bad pixels badPixelsMask = abs(I - medianI) > std * threshold I[badPixelsMask] = medianI[badPixelsMask] tiltSeries[:, :, i] = I # Set the result as the new scalars. utils.set_array(dataset, tiltSeries)
def transform_scalars(dataset, threshold=None): """Remove bad pixels in tilt series.""" from tomviz import utils import scipy.ndimage import numpy as np tiltSeries = utils.get_array(dataset).astype(np.float32) for i in range(tiltSeries.shape[2]): I = tiltSeries[:, :, i] I_pad = np.lib.pad(I, (1, 1), 'edge') # calculate standard deviation in a 3 x 3 window averageI2 = scipy.ndimage.filters.uniform_filter(I_pad ** 2) averageI = scipy.ndimage.filters.uniform_filter(I_pad) std = np.sqrt(abs(averageI2 - averageI**2))[1:-1, 1:-1] medianI = scipy.ndimage.filters.median_filter(I_pad, 2)[1:-1, 1:-1] #identiy bad pixels badPixelsMask = abs(I - medianI) > std * threshold I[badPixelsMask] = medianI[badPixelsMask] tiltSeries[:, :, i] = I # Set the result as the new scalars. utils.set_array(dataset, tiltSeries)
def transform_scalars(dataset): """3D Reconstruct from a tilt series using Algebraic Reconstruction Technique (ART)""" ###Niter### #Get Tilt angles tiltAngles = utils.get_tilt_angles(dataset) #Get Tilt Series tiltSeries = utils.get_array(dataset) (Nslice, Nray, Nproj) = tiltSeries.shape if tiltSeries is None: raise RuntimeError("No scalars found!") #Generate measurement matrix A = parallelRay(Nray, 1.0, tiltAngles, Nray, 1.0) #A is a sparse matrix recon = np.zeros((Nslice, Nray, Nray)) art3(A.todense(), tiltSeries, recon, Niter) # set the result as the new scalars. utils.set_array(dataset, recon) # Mark dataset as volume utils.mark_as_volume(dataset)
def transform_scalars(dataset): '''For each tilt image, the method uses average pixel value of selected region as the background level and subtracts it from the image.''' '''It does NOT set negative pixels to zero.''' from tomviz import utils import numpy as np #----USER SPECIFIED VARIABLES-----# ###XRANGE### ###YRANGE### ###ZRANGE### #---------------------------------# data_bs = utils.get_array(dataset) # Get data as numpy array. data_bs = data_bs.astype(np.float32) # Change tilt series type to float. if data_bs is None: #Check if data exists raise RuntimeError("No data array found!") for i in range(ZRANGE[0],ZRANGE[1]): a = data_bs[:,:,i] - np.average(data_bs[XRANGE[0]:XRANGE[1],YRANGE[0]:YRANGE[1],i]) data_bs[:,:,i] = a utils.set_array(dataset, data_bs)
def transform_scalars(dataset): """3D Reconstruct from a tilt series using Algebraic Reconstruction Technique (ART)""" ###Niter### # Get Tilt angles tiltAngles = utils.get_tilt_angles(dataset) # Get Tilt Series tiltSeries = utils.get_array(dataset) (Nslice,Nray,Nproj) = tiltSeries.shape if tiltSeries is None: raise RuntimeError("No scalars found!") # Generate measurement matrix A = parallelRay(Nray,1.0,tiltAngles,Nray,1.0) #A is a sparse matrix recon = np.zeros((Nslice,Nray,Nray)) art3(A.todense(),tiltSeries,recon,Niter) # Set the result as the new scalars. utils.set_array(dataset, recon) # Mark dataset as volume utils.mark_as_volume(dataset)
def transform_scalars(dataset): """Generate Tilt Series from Volume""" from tomviz import utils import numpy as np import scipy.ndimage #----USER SPECIFIED VARIABLES-----# ###startAngle### #Starting angle ###angleIncrement### #Angle increment ###Nproj### #Number of tilts #---------------------------------# # Generate Tilt Angles angles = np.linspace(startAngle,startAngle+(Nproj-1)*angleIncrement,Nproj); array = utils.get_array(dataset) N = array.shape[0]; Nslice = array.shape[2]; #Number of slices along rotation axis tiltSeries = np.zeros((Nslice, N ,Nproj)) for i in range(Nproj): #Rotate volume rotatedArray = scipy.ndimage.interpolation.rotate(array, angles[i],axes=(0,1),reshape=False) #Calculate Projection tiltSeries[:,:,i] = np.sum(rotatedArray,axis=0).transpose() # set the result as the new scalars. utils.set_array(dataset, tiltSeries) # Mark dataset as tilt series utils.mark_as_tiltseries(dataset) # Save tilt angles utils.set_tilt_angles(dataset, angles)
def set_array_from_itk_image(dataset, itk_image): """Set dataset array from an ITK image.""" itk_output_image_type = type(itk_image) # Save the VTKGlue optimization for later #------------------------------------------ # Export the ITK image to a VTK image. No copying should take place. #export_filter = itk.ImageToVTKImageFilter[itk_output_image_type].New() #export_filter.SetInput(itk_image_data) #export_filter.Update() # Get scalars from the temporary image and copy them to the data set #result_image = export_filter.GetOutput() #filter_array = result_image.GetPointData().GetArray(0) # Make a new instance of the array that will stick around after this # filters in this script are garbage collected #new_array = filter_array.NewInstance() #new_array.DeepCopy(filter_array) # Should be able to shallow copy? #new_array.SetName(name) #------------------------------------------ import itk from . import utils result = itk.PyBuffer[ itk_output_image_type].GetArrayFromImage(itk_image) result = result.copy() utils.set_array(dataset, result, isFortran=False)
def transform_scalars(dataset): """3D Reconstruct from a tilt series using constraint-based Direct Fourier Method""" from tomviz import utils import numpy as np ###Niter### ###Niter_update_support### ###supportSigma### ###supportThreshold### #percent supportThreshold = supportThreshold/100.0 nonnegativeVoxels = True tilt_angles = utils.get_tilt_angles(dataset) #Get Tilt angles tilt_images = utils.get_array(dataset) if tilt_images is None: raise RuntimeError("No scalars found!") #Direct Fourier recon without constraints (recon,recon_F) = dfm3(tilt_images,tilt_angles,np.size(tilt_images,0)*2) kr_cutoffs = np.linspace(0.05,0.5,10); I_data = radial_average(tilt_images,kr_cutoffs) #average Fourier magnitude of tilt series as a function of kr #Search for solutions that satisfy additional constraints recon = difference_map_update(recon_F,nonnegativeVoxels,I_data,kr_cutoffs,Niter,Niter_update_support,supportSigma,supportThreshold) print('Reconsruction Complete') # Set the result as the new scalars. utils.set_array(dataset, recon) # Mark dataset as volume utils.mark_as_volume(dataset)
def transform_scalars(dataset, clipNum=5): """Set values outside a cirular range to minimum(dataset) to remove reconstruction artifacts""" from tomviz import utils import numpy as np array = utils.get_array(dataset) # Constant values numX = array.shape[1] numY = array.shape[2] minVal = array.min() # Find the values to be clipped maxR = min([numX, numY]) / 2 - clipNum XX, YY = np.mgrid[0:numX, 0:numY] RR = np.sqrt((XX - numX / 2) ** 2 + (YY - numY / 2) ** 2) clipThese = np.where(RR >= maxR) # Apply the mask along the original tilt axis direction # (always the first direction in the array) for ii in range(0, array.shape[0]): curImage = array[ii, :, :] # points to the relevant 2D part of the array curImage[clipThese] = minVal # Return to tomviz utils.set_array(dataset, array)
def transform_scalars(dataset): """Resample dataset""" from tomviz import utils import numpy as np import scipy.ndimage #----USER SPECIFIED VARIABLES-----# #resampingFactor = [1,1,1] #Specify the shifts (x,y,z) applied to data ###resampingFactor### #---------------------------------# array = utils.get_array(dataset) # Transform the dataset. result = scipy.ndimage.interpolation.zoom(array, resampingFactor) # Set the result as the new scalars. utils.set_array(dataset, result) # Update tilt angles if dataset is a tilt series. if resampingFactor[2] != 1: try: tilt_angles = utils.get_tilt_angles(dataset) tilt_angles = scipy.ndimage.interpolation.zoom(tilt_angles, resampingFactor[2]) utils.set_tilt_angles(dataset, tilt_angles) except: pass
def transform_scalars(dataset): """3D Reconstruct from a tilt series using Weighted Back-projection Method""" from tomviz import utils import numpy as np interpolation_methods = ('linear','nearest','spline','cubic') filter_methods = ('none','ramp','shepp-logan','cosine','hamming','hann') ###Nrecon### ###filter### ###interp### #Get Tilt angles tilt_angles = utils.get_tilt_angles(dataset) data_py = utils.get_array(dataset) if data_py is None: raise RuntimeError("No scalars found!") recon = wbp3(data_py,tilt_angles,Nrecon,filter_methods[filter],interpolation_methods[interp]) print('Reconsruction Complete') # set the result as the new scalars. utils.set_array(dataset, recon) # Mark dataset as volume utils.mark_as_volume(dataset)
def transform_scalars(dataset): """3D Reconstruct from a tilt series using Weighted Back-projection Method""" from tomviz import utils import numpy as np interpolation_methods = ('linear', 'nearest', 'spline', 'cubic') filter_methods = ('none', 'ramp', 'shepp-logan', 'cosine', 'hamming', 'hann') ###Nrecon### ###filter### ###interp### # Get Tilt angles tilt_angles = utils.get_tilt_angles(dataset) data_py = utils.get_array(dataset) if data_py is None: raise RuntimeError("No scalars found!") recon = wbp3(data_py, tilt_angles, Nrecon, filter_methods[filter], interpolation_methods[interp]) print('Reconsruction Complete') # Set the result as the new scalars. utils.set_array(dataset, recon) # Mark dataset as volume. utils.mark_as_volume(dataset)
def transform_scalars(dataset): """Delete Slices in Dataset""" from tomviz import utils import numpy as np axis = 0; #----USER SPECIFIED VARIABLES-----# ###firstSlice### ###lastSlice### ###axis### #Axis along which to delete the subarray #---------------------------------# # Get the current dataset. array = utils.get_array(dataset) # Get indices of the slices to be deleted. indices = np.linspace(firstSlice,lastSlice,lastSlice-firstSlice+1).astype(int) # Delete the specified slices. array = np.delete(array,indices,axis) # Set the result as the new scalars. utils.set_array(dataset, array) # Delete corresponding tilt anlges if dataset is a tilt series. if axis == 2: try: tilt_angles = utils.get_tilt_angles(dataset) tilt_angles = np.delete(tilt_angles,indices) utils.set_tilt_angles(dataset, tilt_angles) except: pass
def transform_scalars(dataset, firstSlice=None, lastSlice=None, axis=2): """Delete Slices in Dataset""" from tomviz import utils import numpy as np # Get the current dataset. array = utils.get_array(dataset) # Get indices of the slices to be deleted. indices = np.linspace(firstSlice, lastSlice, lastSlice - firstSlice + 1).astype(int) # Delete the specified slices. array = np.delete(array, indices, axis) # Set the result as the new scalars. utils.set_array(dataset, array) # Delete corresponding tilt anlges if dataset is a tilt series. if axis == 2: try: tilt_angles = utils.get_tilt_angles(dataset) tilt_angles = np.delete(tilt_angles, indices) utils.set_tilt_angles(dataset, tilt_angles) except: # noqa # TODO what exception are we ignoring here? pass
def transform_scalars(dataset): from tomviz import utils import numpy as np data_py = utils.get_array(dataset) #get data as numpy array if data_py is None: #Check if data exists raise RuntimeError("No data array found!") (Nx, Ny, Nz) = data_py.shape #----USER SPECIFIED VARIABLES-----# #START_CROP= [0,0,0] #Specify start and end point of crop cube #END_CROP = [Nx-1,Ny-1,Nz-1] # <-- Default will keep all data in range ###START_CROP### ###END_CROP### #---------------------------------# #crop the data data_cropped = data_py[START_CROP[0]:END_CROP[0], START_CROP[1]:END_CROP[1], START_CROP[2]:END_CROP[2]] #set the data back into tomviz utils.set_array(dataset, data_cropped) print('Data has been cropped.')
def transform_scalars(dataset): """Generate Tilt Series from Volume""" from tomviz import utils import numpy as np import scipy.ndimage #----USER SPECIFIED VARIABLES-----# ###startAngle### #Starting angle ###angleIncrement### #Angle increment ###Nproj### #Number of tilts #---------------------------------# # Generate Tilt Angles. angles = np.linspace(startAngle,startAngle+(Nproj-1)*angleIncrement,Nproj); array = utils.get_array(dataset) N = array.shape[0]; Nslice = array.shape[2]; # Number of slices along rotation axis. tiltSeries = np.zeros((Nslice, N ,Nproj)) for i in range(Nproj): # Rotate the volume. rotatedArray = scipy.ndimage.interpolation.rotate(array, angles[i],axes=(0,1),reshape=False) # Calculate projection. tiltSeries[:,:,i] = np.sum(rotatedArray,axis=0).transpose() # Set the result as the new scalars. utils.set_array(dataset, tiltSeries) # Mark dataset as tilt series. utils.mark_as_tiltseries(dataset) # Save tilt angles. utils.set_tilt_angles(dataset, angles)
def transform_scalars(self, dataset, Nrecon=None, filter=None, interp=None): """ 3D Reconstruct from a tilt series using Weighted Back-projection Method """ self.progress.maximum = 1 from tomviz import utils interpolation_methods = ('linear', 'nearest', 'spline', 'cubic') filter_methods = ('none', 'ramp', 'shepp-logan', 'cosine', 'hamming', 'hann') # Get Tilt angles tilt_angles = utils.get_tilt_angles(dataset) tiltSeries = utils.get_array(dataset) if tiltSeries is None: raise RuntimeError("No scalars found!") Nslice = tiltSeries.shape[0] self.progress.maximum = Nslice step = 0 recon = np.empty([Nslice, Nrecon, Nrecon], dtype=float, order='F') t0 = time.time() counter = 1 etcMessage = 'Estimated time to complete: n/a' for i in range(Nslice): if self.canceled: return self.progress.message = 'Slice No.%d/%d. ' % (i + 1, Nslice) + etcMessage recon[i, :, :] = wbp2(tiltSeries[i, :, :], tilt_angles, Nrecon, filter_methods[filter], interpolation_methods[interp]) step += 1 self.progress.value = step timeLeft = (time.time() - t0) / counter * (Nslice - counter) counter += 1 timeLeftMin, timeLeftSec = divmod(timeLeft, 60) timeLeftHour, timeLeftMin = divmod(timeLeftMin, 60) etcMessage = 'Estimated time to complete: %02d:%02d:%02d' % ( timeLeftHour, timeLeftMin, timeLeftSec) # Set up the output dataset from vtk import vtkImageData recon_dataset = vtkImageData() recon_dataset.CopyStructure(dataset) utils.set_array(recon_dataset, recon) utils.mark_as_volume(recon_dataset) returnValues = {} returnValues["reconstruction"] = recon_dataset return returnValues
def transform_scalars(dataset): from tomviz import utils import numpy as np # Get the current volume as a numpy array. array = utils.get_array(dataset) # Save the type input_dtype = array.dtype array = array.astype(np.float32) # Create 3D hanning window. for axis, axis_size in enumerate(array.shape): # Set up shape for numpy broadcasting. filter_shape = [ 1, ] * array.ndim filter_shape[axis] = axis_size window = np.hanning(axis_size).reshape(filter_shape) array *= window # Recast the data to the input type result = array.astype(input_dtype) utils.set_array(dataset, result)
def transform_scalars(dataset, SHIFT=None, rotation_angle=90.0): from tomviz import utils from scipy import ndimage import numpy as np data_py = utils.get_array(dataset) # Get data as numpy array. if data_py is None: #Check if data exists raise RuntimeError("No data array found!") if SHIFT is None: SHIFT = np.zeros(len(data_py.shape), dtype=np.int) data_py_return = np.empty_like(data_py) ndimage.interpolation.shift(data_py, SHIFT, order=0, output=data_py_return) rotation_axis = 2 # This operator always assumes the rotation axis is Z if rotation_angle == []: # If tilt angle not given, assign it to 90 degrees. rotation_angle = 90 axis1 = (rotation_axis + 1) % 3 axis2 = (rotation_axis + 2) % 3 axes = (axis1, axis2) shape = utils.rotate_shape(data_py_return, rotation_angle, axes=axes) data_py_return2 = np.empty(shape, data_py_return.dtype, order='F') ndimage.interpolation.rotate(data_py_return, rotation_angle, output=data_py_return2, axes=axes) utils.set_array(dataset, data_py_return2)
def transform_scalars(dataset): """Delete Slices in Dataset""" from tomviz import utils import numpy as np axis = 0; #----USER SPECIFIED VARIABLES-----# ###firstSlice### ###lastSlice### ###axis### #Axis along which to delete the subarray #---------------------------------# #get current dataset array = utils.get_array(dataset) #Get indices of the slices to be deleted indices = np.linspace(firstSlice,lastSlice,lastSlice-firstSlice+1).astype(int) # delete slices array = np.delete(array,indices,axis) #set the result as the new scalars. utils.set_array(dataset, array) #Delete corresponding tilt anlges if dataset is a tilt series if axis == 2: try: tilt_angles = utils.get_tilt_angles(dataset) tilt_angles = np.delete(tilt_angles,indices) utils.set_tilt_angles(dataset, tilt_angles) except: pass
def transform_scalars(dataset, resampling_factor=[1, 1, 1]): """Resample dataset""" from tomviz import utils import scipy.ndimage import numpy as np array = utils.get_array(dataset) # Transform the dataset. result_shape = utils.zoom_shape(array, resampling_factor) result = np.empty(result_shape, array.dtype, order='F') scipy.ndimage.interpolation.zoom(array, resampling_factor, output=result) # Set the result as the new scalars. utils.set_array(dataset, result) # Update tilt angles if dataset is a tilt series. if resampling_factor[2] != 1: try: tilt_angles = utils.get_tilt_angles(dataset) result_shape = utils.zoom_shape(tilt_angles, resampling_factor[2]) result = np.empty(result_shape, array.dtype, order='F') scipy.ndimage.interpolation.zoom( tilt_angles, resampling_factor[2], output=result) utils.set_tilt_angles(dataset, result) except: # noqa # TODO What exception are we ignoring? pass
def transform_scalars(dataset): """Resample dataset""" from tomviz import utils import numpy as np import scipy.ndimage #----USER SPECIFIED VARIABLES-----# #resampingFactor = [1,1,1] #Specify the shifts (x,y,z) applied to data ###resampingFactor### #---------------------------------# array = utils.get_array(dataset) # transform the dataset result = scipy.ndimage.interpolation.zoom(array, resampingFactor) # set the result as the new scalars. utils.set_array(dataset, result) #Update tilt angles if dataset is a tilt series if resampingFactor[2] != 1: try: tilt_angles = utils.get_tilt_angles(dataset) tilt_angles = scipy.ndimage.interpolation.zoom(tilt_angles, resampingFactor[2]) utils.set_tilt_angles(dataset, tilt_angles) except: pass
def transform_scalars(dataset, clipNum=5): """Set values outside a cirular range to minimum(dataset) to remove reconstruction artifacts""" from tomviz import utils import numpy as np array = utils.get_array(dataset) # Constant values numX = array.shape[1] numY = array.shape[2] minVal = array.min() # Find the values to be clipped maxR = min([numX, numY]) / 2 - clipNum XX, YY = np.mgrid[0:numX, 0:numY] RR = np.sqrt((XX - numX / 2)**2 + (YY - numY / 2)**2) clipThese = np.where(RR >= maxR) # Apply the mask along the original tilt axis direction # (always the first direction in the array) for ii in range(0, array.shape[0]): curImage = array[ ii, :, :] # points to the relevant 2D part of the array curImage[clipThese] = minVal # Return to tomviz utils.set_array(dataset, array)
def transform_scalars(dataset): #----USER SPECIFIED VARIABLES-----# ###ROT_AXIS### #Specify Tilt Axis Dimensions x=0, y=1, z=2 ###ROT_ANGLE### #Rotate the dataset by an Angle (in degrees) #---------------------------------# from tomviz import utils import numpy as np from scipy import ndimage data_py = utils.get_array(dataset) #get data as numpy array if data_py is None: #Check if data exists raise RuntimeError("No data array found!") if ROT_AXIS == []: #If tilt axis is not given, assign one. #Find smallest array dimension, assume it is the tilt angle axis if data_py.ndim >= 2: ROT_AXIS = np.argmin( data_py.shape ) else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") if ROT_ANGLE == []: #If tilt axis is not given, assign it to 90 degrees. ROT_ANGLE = 90; print('Rotating Images...') data_py_return = ndimage.interpolation.rotate( data_py, ROT_ANGLE, axes=((ROT_AXIS+1)%3, (ROT_AXIS+2)%3) ) utils.set_array(dataset, data_py_return) print('Rotate Complete')
def transform_scalars(dataset): """Pad dataset""" from tomviz import utils import numpy as np #----USER SPECIFIED VARIABLES-----# ###padWidthX### ###padWidthY### ###padWidthZ### ###padMode_index### #---------------------------------# padModes = ['constant','edge','wrap','minimum','median'] padMode = padModes[padMode_index] array = utils.get_array(dataset) #get data as numpy array if array is None: #Check if data exists raise RuntimeError("No data array found!") pad_width = (padWidthX,padWidthY,padWidthZ) # pad the data. array = np.lib.pad(array, pad_width, padMode) # Set the data so that it is visible in the application. utils.set_array(dataset, array) # If dataset is marked as tilt series, update tilt angles if padWidthZ[0]+padWidthZ[1] >0: try: tilt_angles = utils.get_tilt_angles(dataset) tilt_angles = np.lib.pad(tilt_angles,padWidthZ, padMode) utils.set_tilt_angles(dataset, tilt_angles) except: pass
def transform_scalars(dataset): from tomviz import utils import numpy as np #----USER SPECIFIED VARIABLES-----# TILT_AXIS = [] #Specify the tilt axis, if none is specified #it assume it is the smallest dimension ANGLES = [] #Specify the angles used in the tiltseries #For example, ANGLES = np.linspace(0,140,70) #---------------------------------# data_py = utils.get_array(dataset) if data_py is None: raise RuntimeError("No scalars found!") if TILT_AXIS == []: #If tilt axis is not given, find it #Find smallest array dimension, assume it is the tilt angle axis if data_py.ndim == 3: TILT_AXIS = np.argmin( data_py.shape ) elif data_py.ndim == 2: raise RuntimeError("Data Array is 2 dimensions, it should be 3!") else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") if ANGLES == []: #If angles are not given, assume 2 degree tilts angles = np.linspace(0,146,74) dimx = np.size(data_py,0) #IN THE FUTURE THIS SHOULD NOT BE ASSUMED result3D = dfm3(data_py,angles,dimx) # set the result as the new scalars. utils.set_array(dataset, result3D) print('Reconsruction Complete')
def transform_scalars(self, dataset): """Automatically align tilt images by cross-correlation""" self.progress.maximum = 1 tiltSeries = utils.get_array(dataset).astype(float) tiltAngles = utils.get_tilt_angles(dataset) # determine reference image index zeroDegreeTiltImage = np.where(tiltAngles == 0)[0] if zeroDegreeTiltImage: referenceIndex = zeroDegreeTiltImage[0] else: referenceIndex = tiltSeries.shape[2] // 2 # create Fourier space filter filterCutoff = 4 (Ny, Nx, Nproj) = tiltSeries.shape ky = np.fft.fftfreq(Ny) kx = np.fft.fftfreq(Nx) [kX, kY] = np.meshgrid(kx, ky) kR = np.sqrt(kX**2 + kY**2) kFilter = (kR <= (0.5 / filterCutoff)) * \ np.sin(2 * filterCutoff * np.pi * kR)**2 # create real sapce filter to remove edge discontinuities y = np.linspace(1, Ny, Ny) x = np.linspace(1, Nx, Nx) [X, Y] = np.meshgrid(x, y) rFilter = (np.sin(np.pi * X / Nx) * np.sin(np.pi * Y / Ny))**2 self.progress.maximum = tiltSeries.shape[2] - 1 step = 1 for i in range(referenceIndex, Nproj - 1): if self.canceled: return self.progress.message = 'Processing tilt image No.%d/%d' % (step, Nproj) tiltSeries[:, :, i + 1] = crossCorrelationAlign(tiltSeries[:, :, i + 1], tiltSeries[:, :, i], rFilter, kFilter) step += 1 self.progress.value = step for i in range(referenceIndex, 0, -1): if self.canceled: return self.progress.message = 'Processing tilt image No.%d/%d' % (step, Nproj) tiltSeries[:, :, i - 1] = crossCorrelationAlign(tiltSeries[:, :, i - 1], tiltSeries[:, :, i], rFilter, kFilter) step += 1 self.progress.value = step utils.set_array(dataset, tiltSeries)
def transform_scalars(self, dataset, Niter=None, stepSize=None, updateMethodIndex=None): """ 3D Reconstruct from a tilt series using Simultaneous Iterative Reconstruction Techniques (SIRT)""" self.progress.maximum = 1 update_methods = ('landweber', 'cimmino', 'component averaging') #reference """L. Landweber, Amer. J. Math., 73 (1951), pp. 615–624""" """G. Cimmino, La Ric. Sci., XVI, Ser. II, Anno IX, 1 (1938), pp. 326–333 """ """Y. Censor et al, Parallel Comput., 27 (2001), pp. 777–808""" # Get Tilt angles tiltAngles = utils.get_tilt_angles(dataset) #remove zero tilt anlges if np.count_nonzero(tiltAngles) < tiltAngles.size: tiltAngles = tiltAngles + 0.001 # Get Tilt Series tiltSeries = utils.get_array(dataset) (Nslice, Nray, Nproj) = tiltSeries.shape if tiltSeries is None: raise RuntimeError("No scalars found!") # Generate measurement matrix self.progress.message = 'Generating measurement matrix' A = parallelRay(Nray, 1.0, tiltAngles, Nray, 1.0) #A is a sparse matrix recon = np.zeros((Nslice, Nray, Nray)) self.progress.maximum = Nslice + 1 step = 0 #create a reconstruction object r = SIRT(A, update_methods[updateMethodIndex]) r.initialize() step += 1 self.progress.value = step for s in range(Nslice): if self.canceled: return b = tiltSeries[s, :, :].transpose().flatten() self.progress.message = 'Slice No.%d/%d' % (s + 1, Nslice) recon[s, :, :] = r.recon2(b, Niter, stepSize).reshape((Nray, Nray)) step += 1 self.progress.value = step # Set the result as the new scalars. utils.set_array(dataset, recon) # Mark dataset as volume utils.mark_as_volume(dataset)
def transform_scalars(self, dataset, Nrecon=None, filter=None, interp=None): """ 3D Reconstruct from a tilt series using Weighted Back-projection Method """ self.progress.maximum = 1 from tomviz import utils interpolation_methods = ('linear', 'nearest', 'spline', 'cubic') filter_methods = ('none', 'ramp', 'shepp-logan', 'cosine', 'hamming', 'hann') # Get Tilt angles tilt_angles = utils.get_tilt_angles(dataset) tiltSeries = utils.get_array(dataset) if tiltSeries is None: raise RuntimeError("No scalars found!") Nslice = tiltSeries.shape[0] self.progress.maximum = Nslice step = 0 recon = np.empty([Nslice, Nrecon, Nrecon], dtype=float, order='F') t0 = time.time() counter = 1 etcMessage = 'Estimated time to complete: n/a' for i in range(Nslice): if self.canceled: return self.progress.message = 'Slice No.%d/%d. ' % ( i + 1, Nslice) + etcMessage recon[i, :, :] = wbp2(tiltSeries[i, :, :], tilt_angles, Nrecon, filter_methods[filter], interpolation_methods[interp]) step += 1 self.progress.value = step timeLeft = (time.time() - t0) / counter * (Nslice - counter) counter += 1 timeLeftMin, timeLeftSec = divmod(timeLeft, 60) timeLeftHour, timeLeftMin = divmod(timeLeftMin, 60) etcMessage = 'Estimated time to complete: %02d:%02d:%02d' % ( timeLeftHour, timeLeftMin, timeLeftSec) # Set up the output dataset from vtk import vtkImageData recon_dataset = vtkImageData() recon_dataset.CopyStructure(dataset) utils.set_array(recon_dataset, recon) utils.mark_as_volume(recon_dataset) returnValues = {} returnValues["reconstruction"] = recon_dataset return returnValues
def transform_scalars(dataset): #----USER SPECIFIED VARIABLES-----# TILT_AXIS = [] #Specify Tilt Axis Dimensions x=0, y=1, z=2 #---------------------------------# from tomviz import utils import numpy as np data_py = utils.get_array(dataset) #get data as numpy array if data_py is None: # Check if data exists raise RuntimeError("No data array found!") if TILT_AXIS == []: # If tilt axis is not given, find it # Find the smallest array dimension, assume it is the tilt angle axis. if data_py.ndim == 3: TILT_AXIS = np.argmin( data_py.shape ) elif data_py.ndim == 2: raise RuntimeError("Data Array is 2 dimensions, it should be 3!") else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") print('Aligning Images by Cross Correlation') for i in range(1,np.size(data_py,TILT_AXIS)): # Align image to previous if TILT_AXIS == 2: im0 = np.fft.fft2(data_py[:,:,i-1]) im1 = np.fft.fft2(data_py[:,:,i]) xcor = abs(np.fft.ifft2((im0 * im1.conjugate()))) shift = np.unravel_index(xcor.argmax(), xcor.shape) print( shift ) data_py[:,:,i] = np.roll( data_py[:,:,i], shift[0], axis = 0) data_py[:,:,i] = np.roll( data_py[:,:,i], shift[1], axis = 1) elif TILT_AXIS == 1: im0 = np.fft.fft2(data_py[:,i-1,:]) im1 = np.fft.fft2(data_py[:,i,:]) xcor = abs(np.fft.ifft2((im0 * im1.conjugate()))) print( np.amax(xcor) ) shift = np.unravel_index(xcor.argmax(), xcor.shape) print( shift ) data_py[:,i,:] = np.roll( data_py[:,i,:], shift[0], axis = 0) data_py[:,i,:] = np.roll( data_py[:,i,:], shift[2], axis = 2) elif TILT_AXIS == 0: im0 = np.fft.fft2(data_py[i-1,:,:]) im1 = np.fft.fft2(data_py[i,:,:]) xcor = abs(np.fft.ifft2((im0 * im1.conjugate()))) print( np.amax(xcor) ) shift = np.unravel_index(xcor.argmax(), xcor.shape) print( shift ) data_py[i,:,:] = np.roll( data_py[i,:,:], shift[1], axis = 1) data_py[i,:,:] = np.roll( data_py[i,:,:], shift[2], axis = 2) else: raise RuntimeError("Python Transform Error: Unknown TILT_AXIS.") utils.set_array(dataset, data_py) print('Align Images Complete')
def transform_scalars(dataset): #----USER SPECIFIED VARIABLES-----# TILT_AXIS = [] #Specify Tilt Axis Dimensions x=0, y=1, z=2 #---------------------------------# from tomviz import utils import numpy as np data_py = utils.get_array(dataset) #get data as numpy array if data_py is None: #Check if data exists raise RuntimeError("No data array found!") if TILT_AXIS == []: #If tilt axis is not given, find it #Find smallest array dimension, assume it is the tilt angle axis if data_py.ndim == 3: TILT_AXIS = np.argmin( data_py.shape ) elif data_py.ndim == 2: raise RuntimeError("Data Array is 2 dimensions, it should be 3!") else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") print('Aligning Images by Cross Correlation') for i in range(1,np.size(data_py,TILT_AXIS)):#Align image to previous if TILT_AXIS == 2: im0 = np.fft.fft2(data_py[:,:,i-1]) im1 = np.fft.fft2(data_py[:,:,i]) xcor = abs(np.fft.ifft2((im0 * im1.conjugate()))) shift = np.unravel_index(xcor.argmax(), xcor.shape) print( shift ) data_py[:,:,i] = np.roll( data_py[:,:,i], shift[0], axis = 0) data_py[:,:,i] = np.roll( data_py[:,:,i], shift[1], axis = 1) elif TILT_AXIS == 1: im0 = np.fft.fft2(data_py[:,i-1,:]) im1 = np.fft.fft2(data_py[:,i,:]) xcor = abs(np.fft.ifft2((im0 * im1.conjugate()))) print( np.amax(xcor) ) shift = np.unravel_index(xcor.argmax(), xcor.shape) print( shift ) data_py[:,i,:] = np.roll( data_py[:,i,:], shift[0], axis = 0) data_py[:,i,:] = np.roll( data_py[:,i,:], shift[2], axis = 2) elif TILT_AXIS == 0: im0 = np.fft.fft2(data_py[i-1,:,:]) im1 = np.fft.fft2(data_py[i,:,:]) xcor = abs(np.fft.ifft2((im0 * im1.conjugate()))) print( np.amax(xcor) ) shift = np.unravel_index(xcor.argmax(), xcor.shape) print( shift ) data_py[i,:,:] = np.roll( data_py[i,:,:], shift[1], axis = 1) data_py[i,:,:] = np.roll( data_py[i,:,:], shift[2], axis = 2) else: raise RuntimeError("Python Transform Error: Unknown TILT_AXIS.") utils.set_array(dataset, data_py) print('Align Images Complete')
def transform_scalars(self, dataset): """Automatically align tilt images by cross-correlation""" self.progress.maximum = 1 tiltSeries = utils.get_array(dataset).astype(float) tiltAngles = utils.get_tilt_angles(dataset) # determine reference image index zeroDegreeTiltImage = np.where(tiltAngles == 0)[0] if zeroDegreeTiltImage: referenceIndex = zeroDegreeTiltImage[0] else: referenceIndex = tiltSeries.shape[2] // 2 # create Fourier space filter filterCutoff = 4 (Ny, Nx, Nproj) = tiltSeries.shape ky = np.fft.fftfreq(Ny) kx = np.fft.fftfreq(Nx) [kX, kY] = np.meshgrid(kx, ky) kR = np.sqrt(kX**2 + kY**2) kFilter = (kR <= (0.5 / filterCutoff)) * \ np.sin(2 * filterCutoff * np.pi * kR)**2 # create real sapce filter to remove edge discontinuities y = np.linspace(1, Ny, Ny) x = np.linspace(1, Nx, Nx) [X, Y] = np.meshgrid(x, y) rFilter = (np.sin(np.pi * X / Nx) * np.sin(np.pi * Y / Ny)) ** 2 self.progress.maximum = tiltSeries.shape[2] - 1 step = 0 for i in range(referenceIndex, Nproj - 1): if self.canceled: return self.progress.message = 'Processing tilt image No.%d/%d' % ( i + 1, Nproj) tiltSeries[:, :, i + 1] = crossCorrelationAlign( tiltSeries[:, :, i + 1], tiltSeries[:, :, i], rFilter, kFilter) step += 1 self.progress.value = step for i in range(referenceIndex, 0, -1): if self.canceled: return self.progress.message = 'Processing tilt image No.%d/%d' % ( i, Nproj) tiltSeries[:, :, i - 1] = crossCorrelationAlign( tiltSeries[:, :, i - 1], tiltSeries[:, :, i], rFilter, kFilter) step += 1 self.progress.value = step utils.set_array(dataset, tiltSeries)
def transform_scalars(dataset): """Set negative voxels to zero""" from tomviz import utils data = utils.get_array(dataset) data[data < 0] = 0 # Set negative voxels to zero # Set the result as the new scalars. utils.set_array(dataset, data)
def transform_scalars(self, dataset): """Automatic align the tilt axis to the center of images""" self.progress.maximum = 1 from tomviz import utils # Get Tilt angles tilt_angles = utils.get_tilt_angles(dataset) tiltSeries = utils.get_array(dataset) if tiltSeries is None: raise RuntimeError("No scalars found!") Nx, Ny, Nz = tiltSeries.shape shifts = (np.linspace(-20, 20, 41)).astype('int') numberOfSlices = 5 # number of slices used for recon # randomly choose slices with top 50% total intensities tiltSeriesSum = np.sum(tiltSeries, axis=(1, 2)) temp = tiltSeriesSum.argsort()[Nx // 2:] slices = temp[np.random.permutation(temp.size)[:numberOfSlices]] print('Reconstruction slices:') print(slices) I = np.zeros(shifts.size) self.progress.maximum = shifts.size - 1 step = 0 for i in range(shifts.size): if self.canceled: return shiftedTiltSeries = np.roll(tiltSeries[slices, :, :, ], shifts[i], axis=1) for s in range(numberOfSlices): self.progress.message = ('Reconstructing slice No.%d with %d ' 'pixels shift' % (slices[s], shifts[i])) recon = wbp2(shiftedTiltSeries[s, :, :], tilt_angles, Ny, 'ramp', 'linear') I[i] = I[i] + np.amax(recon) step += 1 self.progress.value = step print('shift: %d' % shifts[np.argmax(I)]) result = np.roll(tiltSeries, shifts[np.argmax(I)], axis=1) result = np.asfortranarray(result) # Set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(self, dataset): """Automatic align the tilt axis to the center of images""" self.progress.maximum = 1 from tomviz import utils # Get Tilt angles tilt_angles = utils.get_tilt_angles(dataset) tiltSeries = utils.get_array(dataset) if tiltSeries is None: raise RuntimeError("No scalars found!") Nx, Ny, Nz = tiltSeries.shape shifts = (np.linspace(-20, 20, 41)).astype('int') numberOfSlices = 5 # number of slices used for recon # randomly choose slices with top 50% total intensities tiltSeriesSum = np.sum(tiltSeries, axis=(1, 2)) temp = tiltSeriesSum.argsort()[Nx // 2:] slices = temp[np.random.permutation(temp.size)[:numberOfSlices]] print('Reconstruction slices:') print(slices) I = np.zeros(shifts.size) self.progress.maximum = shifts.size - 1 step = 0 for i in range(shifts.size): if self.canceled: return shiftedTiltSeries = np.roll( tiltSeries[slices, :, :, ], shifts[i], axis=1) for s in range(numberOfSlices): self.progress.message = ('Reconstructing slice No.%d with %d ' 'pixels shift' % (slices[s], shifts[i])) recon = wbp2(shiftedTiltSeries[s, :, :], tilt_angles, Ny, 'ramp', 'linear') I[i] = I[i] + np.amax(recon) step += 1 self.progress.value = step print('shift: %d' % shifts[np.argmax(I)]) result = np.roll(tiltSeries, shifts[np.argmax(I)], axis=1) result = np.asfortranarray(result) # Set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(dataset): from tomviz import utils import numpy as np #----USER SPECIFIED VARIABLES-----# TILT_AXIS = [] #Specify Tilt Axis Dimensions x=0, y=1, z=2 SHIFT_EXP = 0.10 #Specify the Expected (mean) Random % Image Shift (0-1) SHIFT_STDDEV = 0.05 #Specify the Standard Deviation as % of Image (0-1) np.random.seed(12) #Set a new seed to get different random alignments #---------------------------------# data_py = utils.get_array(dataset) #get data as numpy array if data_py is None: #Check if data exists raise RuntimeError("No data array found!") if TILT_AXIS == []: #If tilt axis is not given, find it #Find smallest array dimension, assume it is the tilt angle axis if data_py.ndim == 3: TILT_AXIS = np.argmin( data_py.shape ) elif data_py.ndim == 2: raise RuntimeError("Data Array is 2 dimensions, it should be 3!") else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") for i in range(0,np.size(data_py,TILT_AXIS)-1): if TILT_AXIS == 2: shift_mu = np.size(data_py,0)*SHIFT_EXP shift_sigma = np.size(data_py,0)*SHIFT_STDDEV shift0 = int( np.random.normal(shift_mu, shift_sigma) ) shift1 = int( np.random.normal(shift_mu, shift_sigma) ) data_py[:,:,i] = np.roll( data_py[:,:,i], shift0, axis = 0) data_py[:,:,i] = np.roll( data_py[:,:,i], shift1, axis = 1) elif TILT_AXIS == 1: shift_mu = np.size(data_py,0)*SHIFT_EXP shift_sigma = np.size(data_py,0)*SHIFT_STDDEV shift0 = int( np.random.normal(shift_mu, shift_sigma) ) shift1 = int( np.random.normal(shift_mu, shift_sigma) ) data_py[:,i,:] = np.roll( data_py[:,i,:], shift0, axis = 0) data_py[:,i,:] = np.roll( data_py[:,i,:], shift2, axis = 2) elif TILT_AXIS == 0: shift_mu = np.size(data_py,1)*SHIFT_EXP shift_sigma = np.size(data_py,1)*SHIFT_STDDEV shift0 = int( np.random.normal(shift_mu, shift_sigma) ) shift1 = int( np.random.normal(shift_mu, shift_sigma) ) data_py[i,:,:] = np.roll( data_py[i,:,:], shift1, axis = 1) data_py[i,:,:] = np.roll( data_py[i,:,:], shift2, axis = 2) else: raise RuntimeError("Python Transform Error: Unknown TILT_AXIS.") utils.set_array(dataset, data_py) print('Misalign Images Complete')
def transform_scalars(dataset): from tomviz import utils import numpy as np #----USER SPECIFIED VARIABLES-----# TILT_AXIS = [] # Specify Tilt Axis Dimensions x=0, y=1, z=2 SHIFT_EXP = 0.10 # Specify the Expected (mean) Random % Image Shift (0-1) SHIFT_STDDEV = 0.05 # Specify the Standard Deviation as % of Image (0-1) np.random.seed(12) # Set a new seed to get different random alignments #---------------------------------# data_py = utils.get_array(dataset) # Get data as numpy array. if data_py is None: # Check if data exists. raise RuntimeError("No data array found!") if TILT_AXIS == []: # If tilt axis is not given, find it. # Find the smallest array dimension, assume it is the tilt angle axis. if data_py.ndim == 3: TILT_AXIS = np.argmin(data_py.shape) elif data_py.ndim == 2: raise RuntimeError("Data Array is 2 dimensions, it should be 3!") else: raise RuntimeError("Data Array is not 2 or 3 dimensions!") for i in range(0, np.size(data_py, TILT_AXIS) - 1): if TILT_AXIS == 2: shift_mu = np.size(data_py, 0) * SHIFT_EXP shift_sigma = np.size(data_py, 0) * SHIFT_STDDEV shift0 = int(np.random.normal(shift_mu, shift_sigma)) shift1 = int(np.random.normal(shift_mu, shift_sigma)) data_py[:, :, i] = np.roll(data_py[:, :, i], shift0, axis=0) data_py[:, :, i] = np.roll(data_py[:, :, i], shift1, axis=1) elif TILT_AXIS == 1: shift_mu = np.size(data_py, 0) * SHIFT_EXP shift_sigma = np.size(data_py, 0) * SHIFT_STDDEV shift0 = int(np.random.normal(shift_mu, shift_sigma)) shift1 = int(np.random.normal(shift_mu, shift_sigma)) data_py[:, i, :] = np.roll(data_py[:, i, :], shift0, axis=0) data_py[:, i, :] = np.roll(data_py[:, i, :], shift1, axis=1) elif TILT_AXIS == 0: shift_mu = np.size(data_py, 1) * SHIFT_EXP shift_sigma = np.size(data_py, 1) * SHIFT_STDDEV shift0 = int(np.random.normal(shift_mu, shift_sigma)) shift1 = int(np.random.normal(shift_mu, shift_sigma)) data_py[i, :, :] = np.roll(data_py[i, :, :], shift0, axis=0) data_py[i, :, :] = np.roll(data_py[i, :, :], shift1, axis=1) else: raise RuntimeError("Python Transform Error: Unknown TILT_AXIS.") utils.set_array(dataset, data_py) print('Misalign Images Complete')
def transform_scalars(dataset): """Apply a Laplace filter to dataset.""" from tomviz import utils import scipy.ndimage array = utils.get_array(dataset) # Transform the dataset result = scipy.ndimage.filters.laplace(array) # Set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(dataset): """Apply a Laplace filter to dataset.""" from tomviz import utils import numpy as np import scipy.ndimage array = utils.get_array(dataset) # Transform the dataset result = scipy.ndimage.filters.laplace(array) # Set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(dataset): """Calculate 3D gradient magnitude using Sobel operator""" from tomviz import utils import numpy as np import scipy.ndimage array = utils.get_array(dataset) array = array.astype(np.float32) # Transform the dataset result = scipy.ndimage.filters.generic_gradient_magnitude(array, scipy.ndimage.filters.sobel) # Set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(dataset): """Downsample dataset by a factor of 2""" from tomviz import utils import numpy as np import scipy.ndimage array = utils.get_array(dataset) # transform the dataset result = scipy.ndimage.interpolation.zoom(array, (0.5, 0.5, 0.5)) # set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(dataset, shift=[0, 0, 0]): from tomviz import utils import numpy as np data_py = utils.get_array(dataset) # Get data as numpy array. if data_py is None: #Check if data exists raise RuntimeError("No data array found!") data_py[:] = np.roll(data_py, shift[0], axis=0) data_py[:] = np.roll(data_py, shift[1], axis=1) data_py[:] = np.roll(data_py, shift[2], axis=2) utils.set_array(dataset, data_py) print('Data has been shifted uniformly.')
def transform_scalars(dataset): """Downsample dataset by a factor of 2""" from tomviz import utils import numpy as np import scipy.ndimage array = utils.get_array(dataset) # Downsample the dataset x2 using order 1 spline (linear) result = scipy.ndimage.interpolation.zoom(array, (0.5, 0.5, 0.5),output=None, order=1, mode='constant', cval=0.0, prefilter=False) # Set the result as the new scalars. utils.set_array(dataset, result)
def transform_scalars(dataset, XRANGE=None, YRANGE=None, ZRANGE=None): """Define this method for Python operators that transform input scalars""" from tomviz import utils import numpy as np array = utils.get_array(dataset) if array is None: raise RuntimeError("No scalars found!") # Transform the dataset. result = np.copy(array) result[XRANGE[0]:XRANGE[1], YRANGE[0]:YRANGE[1], ZRANGE[0]:ZRANGE[1]] = 0 # Set the result as the new scalars. utils.set_array(dataset, result)