def mapfile_threshold(input_filename, output_filename, threshold=0, normalize=False, zero=True): """ Threshold the map Args: input_filename (str): The input map filename output_filename (str): The output map filename threshold (float): The threshold value normalize (bool): Normalize the map before thresholding zero (bool): Shift the data to zero """ # Open the input file infile = read(input_filename) # Get data data = infile.data.copy() # Apply the threshold data = array_threshold(data, threshold=threshold, normalize=normalize, zero=zero) # Write the output file write(output_filename, data, infile=infile)
def mapfile_cc(input_map_filename1, input_map_filename2=None, output_map_filename=None): """ Compute the CC between two maps Args: input_map_filename1 (str): The input map filename input_map_filename2 (str): The input map filename output_map_filename (str): The output cc filename """ # Open the input file infile1 = read(input_map_filename1) # Get the data data1 = infile1.data if input_map_filename2 is not None: infile2 = read(input_map_filename2) data2 = infile2.data data2 = reorder(data2, read_axis_order(infile2), read_axis_order(infile1)) else: data2 = None # Compute the cc cc = array_cc(data1, data2) # Write the output file write(output_map_filename, cc.astype("float32"), infile=infile1)
def mapfile_segment( input_map_filename, output_map_filename=None, output_mask_filename=None, num_objects=1, ): """ Segment the map Args: input_map_filename (str): The input map filename output_map_filename (str): The output map filename output_mask_filename (str): The output mask filename num_objects (int): The number of objects """ # Open the input file infile = read(input_map_filename) # Get data data = infile.data # Segment the data mask = array_segment(data, num_objects=num_objects) # Write the output file if output_mask_filename is not None: write(output_mask_filename, mask, infile=infile) if output_map_filename is not None: write(output_map_filename, maptools.mask(data, mask), infile=infile)
def crop( input_filename, output_filename, roi=None, ): """ Crop the map Args: input_filename (str): The input map filename output_filename (str): The output map filename roi (list): The region of interest """ # Open the input file infile = read(input_filename) # Get the roi if roi is not None: z0, y0, x0, z1, y1, x1 = roi else: z0, y0, x0 = 0, 0, 0 z1, y1, x1 = infile.data.shape assert z1 > z0 assert y1 > y0 assert x1 > x0 # Get the subset of data logger.info("Cropping map with roi: %s" % list(roi)) data = infile.data[z0:z1, y0:y1, x0:x1] # Write the output file write(output_filename, data, infile=infile)
def mapfile_rebin(input_map_filename, output_map_filename, shape=None): """ Rebin the map Args: input_map_filename (str): The input map filename output_map_filename (str): The output map filename shape (tuple): The new shape of the map """ # Open the input file infile = read(input_map_filename) # Get the data data = infile.data # Get the subset of data logger.info("Resampling map from shape %s to %s" % (data.shape, tuple(shape))) data = array_rebin(data, shape) # Write the output file outfile = write(output_map_filename, data, infile=infile) # Update the voxel size outfile.voxel_size = ( outfile.voxel_size["z"] * infile.data.shape[0] // shape[0], outfile.voxel_size["y"] * infile.data.shape[1] // shape[1], outfile.voxel_size["x"] * infile.data.shape[2] // shape[2], )
def mapfile_reorder(input_filename, output_filename, axis_order=None): """ Reorder the data axes Args: input_filename (str): The input map filename output_filename (str): The output map filename axis_order (list): The axis order """ # Open the input file infile = read(input_filename) # Get the axis order original_order = read_axis_order(infile) assert tuple(sorted(axis_order)) == (0, 1, 2) # Reorder the axes data = array_reorder(infile.data, original_order, axis_order) # Write the output file outfile = write(output_filename, data, infile=infile) write_axis_order(outfile, axis_order) outfile.update_header_stats()
def fft(input_map_filename, output_map_filename, mode=None, shift=True, normalize=True): """ Compute the FFT of the map Args: input_map_filename (str): The input map filename output_map_filename (str): The output map filename mode (str): The component to output shift (bool): Shift the fourier components normalize (bool): Normalize before computing FFT """ # Open the input file infile = read(input_map_filename) # Get the subset of data logger.info("Computing FFT (%s)" % mode) # The data data = infile.data # Normalize if necessary if normalize: data = (data - numpy.mean(data)) / numpy.std(data) # Compute FFT data = { "real": lambda x: numpy.real(x), "imaginary": lambda x: numpy.imag(x), "amplitude": lambda x: numpy.abs(x), "phase": lambda x: numpy.angle(x), "power": lambda x: numpy.abs(x)**2, }[mode](numpy.fft.fftn(data).astype("complex64")) # Shift if necessary if shift: data = numpy.fft.fftshift(data) # Write the output file write(output_map_filename, data, infile=infile)
def mapfile_filter( input_filename, output_filename, filter_type="lowpass", filter_shape="gaussian", resolution=None, ): """ Filter the map Args: input_filename (str): The input map filename output_filename (str): The output map filename filter_type (str): The filter type filter_shape (str): The filter shape resolution (list): The resolution """ # Check the input assert filter_type in ["lowpass", "highpass", "bandpass", "bandstop"] assert filter_shape in ["square", "gaussian"] # Open the input file infile = read(input_filename) # Get the voxel size voxel_size = ( infile.voxel_size["z"], infile.voxel_size["y"], infile.voxel_size["x"], ) # Filter the data data = array_filter( infile.data, filter_type=filter_type, filter_shape=filter_shape, resolution=resolution, voxel_size=voxel_size, ) # Write the output file write(output_filename, data, infile=infile)
def mapfile_rescale( input_filename, output_filename, mean=None, sdev=None, vmin=None, vmax=None, scale=None, offset=None, ): """ Rescale the map Args: input_filename (str): The input map filename output_filename (str): The output map filename mean (float): The desired mean value sdev (float): The desired sdev value vmin (float): The desired min value vmax (float): The desired max value scale (float): The scale offset (float): The offset """ # Open the input file infile = read(input_filename) # Get the data data = infile.data # Rescale the map data = array_rescale(data, mean=mean, sdev=sdev, vmin=vmin, vmax=vmax, scale=scale, offset=offset) # Write the output file write(output_filename, data, infile=infile)
def mapfile_transform( input_filename, output_filename, offset=None, rotation=(0, 0, 0), translation=(0, 0, 0), deg=False, ): """ Transform the map Args: input_filename (str): The input map filename output_filename (str): The output map filename offset = (array): The offset to rotate about rotation (array): The rotation vector translation (array): The translation vector deg (bool): Is the rotation in degrees """ # Open the input file infile = read(input_filename) # Get the axis order axis_order = read_axis_order(infile) # Get data data = infile.data # Do the transform data = array_transform( data, axis_order=axis_order, offset=offset, rotation=rotation, translation=translation, deg=deg, ) # Write the output file write(output_filename, data, infile=infile)
def mapfile_fsc3d( input_filename1, input_filename2, output_filename=None, kernel=9, resolution=None ): """ Compute the local FSC of the map Args: input_filename1 (str): The input map filename input_filename2 (str): The input map filename output_filename (str): The output map filename kernel (int): The kernel size resolution (float): The resolution limit """ # Open the input files infile1 = read(input_filename1) infile2 = read(input_filename2) # Get the data data1 = infile1.data data2 = infile2.data # Reorder input arrays data1 = reorder(data1, read_axis_order(infile1), (0, 1, 2)) data2 = reorder(data2, read_axis_order(infile2), (0, 1, 2)) # Compute the local FSC fsc = fsc3d( data1, data2, kernel=kernel, resolution=resolution, voxel_size=infile1.voxel_size, ) # Reorder output array fsc = reorder(fsc, (0, 1, 2), read_axis_order(infile1)) # Write the output file write(output_filename, fsc.astype("float32"), infile=infile1)
def mapfile_segment(input_filename, output_filename, num_objects=1): """ Segment the map Args: input_filename (str): The input map filename output_filename (str): The output map filename num_objects (int): The number of objects """ # Open the input file infile = read(input_filename) # Get data data = infile.data.copy() # Apply the segment data = array_segment(data, num_objects=num_objects) # Write the output file write(output_filename, data, infile=infile)
def mapfile_mask( input_filename, output_filename, mask_filename=None, fourier_space=False, shift=False, ): """ Mask the map Args: input_filename (str): The input map filename output_filename (str): The output map filename mask_filename (str): The mask filename space (str): Apply in real space or fourier space shift (bool): Shift the mask """ # Open the input file infile = read(input_filename) # Open the mask file maskfile = read(mask_filename) # Apply the mask data = infile.data mask = maskfile.data # Reorder the maskfile axes to match the data mask = reorder(mask, read_axis_order(maskfile), read_axis_order(infile)) # Apply the mask data = array_mask(data, mask, fourier_space=fourier_space, shift=shift) # Write the output file write(output_filename, data.astype("float32"), infile=infile)
def rotate(input_filename, output_filename, axes=(0, 1), num=1): """ Rotate the map Args: input_filename (str): The input map filename output_filename (str): The output map filename axes (tuple): The axis to rotate around num (int): The number of times to rotate by 90 degrees """ # Open the input file infile = read(input_filename) # Get data data = infile.data.copy() # Apply the threshold logger.info("Rotating %d times around axes %s" % (num, axes)) data = numpy.rot90(data, k=num, axes=axes) # Write the output file write(output_filename, data, infile=infile)
def mapfile_dilate(input_map_filename, output_map_filename, kernel=3, num_iter=1): """ Dilate the map Args: input_map_filename (str): The input map filename output_map_filename (str): The output map filename kernel (tuple): The kernel size num_iter (int): The number of iterations """ # Open the input file infile = read(input_map_filename) # Get the subset of data logger.info("Dilating map") data = array_dilate(infile.data, kernel=kernel, num_iter=num_iter) # Write the output file write(output_map_filename, data.astype("uint8"), infile=infile)