Beispiel #1
0
def stack_to_tif(stack_path, compress=1, wipe=False):
    """
    :param stack_path: string, full path of .stack file to be converted to .tif
    :param compress: int, compression level to use for tif file
    :param wipe: bool, if True stack file will be deleted after saving as tif
    :return:
    """
    from numpy import array_equal
    from os import remove
    from os.path import split, sep
    from numpy import fromfile
    import volTools as volt
    from skimage.external import tifffile as tif

    dims = volt.getStackDims(split(stack_path)[0] + sep)

    im = fromfile(stack_path, dtype='int16')
    im = im.reshape(dims[-1::-1])

    tif_path = stack_path.split('.')[0] + '.tif'
    tif.imsave(tif_path, im, compress=compress)

    if wipe:
        check_file = tif.imread(tif_path)
        if array_equal(check_file, im):
            print('Deleting {0}...'.format(stack_path))
            remove(stack_path)
        else:
            print('{0} and {1} differ... something went wrong!'.format(stack_path, tif_path))
def save_TiffStack(dataset,filename="image",outputPath="./"):
    filename = filename.rstrip(".tiff")
    filename = filename.rstrip(".tif")
    outputFile = outputPath + filename + ".tiff"
    print("saving ... : " + outputFile)
    skTiff.imsave(outputFile,dataset)
    print("save complete: " + outputFile)
Beispiel #3
0
def save_tiff(img_stack, pwd):
    if pwd.endswith('.tif'):
        tiff.imsave(pwd, img_stack) 
    else:
        for z,frame in enumerate(img_stack):
            fname = pwd + '_%03d' % (z+1) + '.tif'
            dir, file = os.path.split(fname)
            if not os.path.exists(dir):
                os.makedirs(dir)
            tiff.imsave(fname, frame)
def save_frame_to_tif(timestep, label_image, options):
    if options.is_groundtruth:
        filename = options.output_dir + '/man_track' + format(timestep, "0{}".format(options.filename_zero_padding)) + '.tif'
    else:
        filename = options.output_dir + '/mask' + format(timestep, "0{}".format(options.filename_zero_padding)) + '.tif'
    # label_image = np.swapaxes(label_image, 0, 1)
    if len(label_image.shape) == 2: # 2d
        vigra.impex.writeImage(label_image.astype('uint16'), filename)
    else: # 3D
        label_image = np.transpose(label_image, axes=[2, 0, 1])
        tifffile.imsave(filename, label_image.astype('uint16'))
    def save_log(self):

        if self.display_length is None:
            self.clear()
            raise LookupError("Please display sequence first!")

        if self.file_name is None:
            self._get_file_name()

        if self.keep_display == True:
            self.file_name += '-complete'
        elif self.keep_display == False:
            self.file_name += '-incomplete'

        # set up log object
        directory = os.path.join(self.log_dir, 'visual_display_log')
        if not (os.path.isdir(directory)):
            os.makedirs(directory)

        logFile = dict(self.seq_log)
        displayLog = dict(self.__dict__)
        displayLog.pop('seq_log')
        displayLog.pop('sequence')
        logFile.update({'presentation': displayLog})

        file_name = self.file_name + ".pkl"

        # generate full log dictionary
        path = os.path.join(directory, file_name)
        ft.saveFile(path, logFile)
        print("\nLog file generated successfully. Log file path: ")
        print('{}'.format(path))
        if self.is_save_sequence:
            tf.imsave(os.path.join(directory, self.file_name + '.tif'),
                      self.sequence.astype(np.float32))
            print('\nSequence file generated successfully. File path: ')
            print('{}'.format(os.path.join(directory, self.file_name + '.tif')))

        backupFileFolder = self._get_backup_folder()
        if backupFileFolder is not None:
            if not (os.path.isdir(backupFileFolder)):
                os.makedirs(backupFileFolder)
            backupFilePath = os.path.join(backupFileFolder, file_name)
            ft.saveFile(backupFilePath, logFile)

            if self.is_save_sequence:
                tf.imsave(os.path.join(backupFileFolder, self.file_name + '.tif'),
                          self.sequence.astype(np.float32))
            print("\nBackup log file generated successfully. Backup log file path: ")
            print('{}'.format(backupFilePath))
        else:
            print("\nDid not find backup path, no backup was saved.")
def transform(f):
    path = f
    city_dir_name = f.split("/")[-3]
    image = tifffile.imread(path)
    bands = []
    for band in range(8):
        bands.append(equalize_adapthist(image[..., band]) * 2047)
    img = np.array(np.stack(bands, axis=-1), dtype="uint16")
    clahe_city_dir = os.path.join(wdata_dir, city_dir_name)
    os.makedirs(clahe_city_dir, exist_ok=True)
    mul_dir = os.path.join(clahe_city_dir, 'CLAHE-MUL-PanSharpen')
    os.makedirs(mul_dir, exist_ok=True)
    tifffile.imsave(os.path.join(mul_dir, f.split("/")[-1]), img, planarconfig='contig')
Beispiel #7
0
 def SaveTopographImage(self, FileName=None):
     if FileName is None or FileName == False:
         # Set the default filename to the type of image (SumImage, etc...)
         FileName = os.path.join(self.Defaults['DefaultFileDialogDir'],
                                 str(self.comboTopograph.itemData(self.comboTopograph.currentIndex())) + '.tif')
         Opts = QtWidgets.QFileDialog.Option(0x40)  # QtWidgets.QFileDialog.HideNameFilterDetails
         FileName, _ = QtWidgets.QFileDialog.getSaveFileName(self, caption='Save Topograph Image.', directory=FileName,
                                                      filter='TIF image (*.tif);;All files(*.*)', options=Opts)
     if FileName != '':
         # Store the default path now that the user has selected a file.
         self.Defaults['DefaultFileDialogDir'], _ = os.path.split(str(FileName))
         # Write the image file to disk.
         imsave(FileName, self.canvasTopograph.ImageData[:].astype('float32'))
 def _save_frame_to_tif(self, timestep, label_image, output_dir, filename_zero_padding=3):
     """
     Save a single frame to a 2D or 3D tif
     """
     filename = os.path.join(output_dir, f"mask{timestep:0{filename_zero_padding}}.tif")
     # import ipdb; ipdb.set_trace()
     label_image = np.swapaxes(label_image.squeeze(), 0, 1)
     if len(label_image.shape) == 2: # 2d
         vigra.impex.writeImage(label_image.astype('uint16'), filename)
     elif len(label_image.shape) == 3: # 3D
         label_image = np.transpose(label_image, axes=[2, 0, 1])
         tifffile.imsave(filename, label_image.astype('uint16'))
     else:
         raise ValueError("Image had the wrong dimensions, can only save 2 or 3D images with a single channel")
Beispiel #9
0
def stack_writer(out_dir="",file_name="",stack=[],metadata=""):
    stack_data=np.array(stack)
    md_name=file_name+".html"
    file_name+=".tif"
    full_save_path=os.path.join(out_dir,file_name)
    full_md_save_path=os.path.join(out_dir,md_name)
    imsave(full_save_path,stack_data)
    if metadata:
        if isinstance(metadata,str):
            with open(full_md_save_path,"w") as md_file:
                md_file.write(metadata)
        elif isinstance(metadata, list):
            metadata_str="<html>%s</html>" % "<br>".join(metadata)
            with open(full_md_save_path,"w") as md_file:
                md_file.write(metadata_str)
Beispiel #10
0
def stack_to_tif(stack_path):
    """
    :param stack_path: string, full path of .stack file to be converted to .tif
    :return:
    """

    from os.path import split, sep
    from numpy import fromfile
    import volTools as volt
    from skimage.external import tifffile as tif

    dims = volt.getStackDims(split(stack_path)[0] + sep)

    im = fromfile(stack_path, dtype='int16')
    im = im.reshape(dims[-1::-1])

    tif_path = stack_path.split('.')[0] + '.tif'
    tif.imsave(tif_path, im, compress=1)
def imsave_al(image, im, path):

    dic = oib.image_info(im)
    if dic['time_interval'] == None:
        t = 0
    else:
        t = float(dic['time_interval'])
    sx = (1/float(dic['xsize']))

    filename = [os.path.splitext(filename)[0] for filename in os.listdir(path) if filename.endswith(('.nd2'))]
    filename
    i = 0
    for img in image:
        i+=1
        filename_save = (path+ '/' + ('%s%i' %(filename[0], i)) + '.tif')
        filename_save
        if os.path.isfile(filename_save) == True:
            print 'the file already exist'
        else:
            tifffile.imsave(filename_save, img.transpose(0,1,4,2,3), imagej=True, resolution = (sx,sx), metadata = {'mode' : 'color', 'finterval' : t, 'unit' : 'micron'})
Beispiel #12
0
def file_writer(filename, signal, **kwds):
    """Writes data to tif using Christoph Gohlke's tifffile library

        Parameters
        ----------
        filename: str
        signal: a Signal instance

    """
    data = signal.data
    if signal.is_rgbx is True:
        data = rgb_tools.rgbx2regular_array(data)
        photometric = "rgb"
    else:
        photometric = "minisblack"
    if description not in kwds:
        if signal.metadata.General.title:
            kwds['description'] = signal.metadata.General.title

    imsave(filename, data,
           software="hyperspy",
           photometric=photometric,
           **kwds)
def importRawJCamF(path,
                   saveFolder=None,
                   dtype=np.dtype('<u2'),
                   headerLength=116,
                   tailerLength=218,
                   column=2048,
                   row=2048,
                   frame=None,  # how many frame to read
                   crop=None):
    if frame:
        data = np.fromfile(path, dtype=dtype, count=frame * column * row + headerLength)
        header = data[0:headerLength]
        tailer = []
        mov = data[headerLength:].reshape((frame, column, row))
    else:
        data = np.fromfile(path, dtype=dtype)
        header = data[0:headerLength]
        tailer = data[len(data) - tailerLength:len(data)]
        frame = (len(data) - headerLength - tailerLength) / (column * row)
        mov = data[headerLength:len(data) - tailerLength].reshape((frame, column, row))

    if saveFolder:
        if crop:
            try:
                mov = mov[:, crop[0]:crop[1], crop[2]:crop[3]]
                fileName = path.split('\\')[-1] + '_cropped.tif'
            except Exception as e:
                print 'importRawJCamF: Can not understant the paramenter "crop":' + str(
                    crop) + '\ncorp should be: [rowStart,rowEnd,colStart,colEnd]'
                print '\nTrace back: \n' + e
        else:
            fileName = path.split('\\')[-1] + '.tif'

        tf.imsave(os.path.join(saveFolder, fileName), mov)

    return mov, header, tailer
Beispiel #14
0
else:
    ims = axs2[1].imshow(
        (np.abs(pupil)),
        extent=[-Kextent * n, Kextent * n, -Kextent * n,
                Kextent * n])  #plot the phase of the pupil
    axs2[1].set_title('|Pupil|')

# finally, render the figures
plt.show()

############################
##### Save Psf to .tif file

if SaveData:

    wavelength = 0.520  #um  #you may want to specify a wavelength to save a calibrated PSF

    from skimage.external import tifffile as tif
    psf16 = np.transpose(np.abs(PSF), (2, 0, 1))
    psf16 = (psf16 * (2**16 - 1) / np.amax(psf16)).astype(
        'uint16')  #normalize and convert to 16 bit
    psf16.shape = 1, N, 1, N, N, 1  # dimensions in TZCYXS order
    sampling = pixel_size / n * wavelength
    tif.imsave('psf.tif',
               psf16,
               imagej=True,
               resolution=(1.0 / sampling, 1.0 / sampling),
               metadata={
                   'spacing': sampling,
                   'unit': 'um'
               })
Beispiel #15
0
def write_ometiff(output_path, array, omexml_string):
    tifffile.imsave(output_path,
                    array,
                    photometric='minisblack',
                    description=omexml_string,
                    metadata={'axes': 'TZCXY'})
Beispiel #16
0
def tif_writer(numpy_array="",path="",md_string=""):
    imsave("%s.tif" % path,numpy_array)
    if md_string:
        with open("%s.html" % path,"w") as md_file:
            md_file.write(md_string)
    zyx = load_np(converted_points)
    zyx = np.asarray([
        str((int(xx[0]), int(xx[1]), int(xx[2])))
        for xx in load_np(converted_points)
    ])
    from collections import Counter
    zyx_cnt = Counter(zyx)

    #manually call transformix..
    c_rfe = '/home/wanglab/wang/pisano/tracing_output/antero_4x/20170115_tp_bl6_lob6a_1000r_02/20170115_tp_bl6_lob6a_1000r_647_010na_z7d5um_125msec_10povlp_resized_ch00_resampledforelastix.tif'
    transformed_dst = '/home/wanglab/wang/pisano/tracing_output/antero_4x/20170115_tp_bl6_lob6a_1000r_02/3dunet_output/transformed_points'
    transformfile = '/home/wanglab/wang/pisano/tracing_output/antero_4x/20170115_tp_bl6_lob6a_1000r_02/elastix/TransformParameters.1.txt'
    transformix_command_line_call(c_rfe, transformed_dst, transformfile)

    #cell_registered channel
    cell_reg = tifffile.imread(
        '/home/wanglab/wang/pisano/tracing_output/antero_4x/20170115_tp_bl6_lob6a_1000r_02/3dunet_output/transformed_points/result.tif'
    )
    cell_cnn = np.zeros_like(cell_reg)
    for zyx, v in zyx_cnt.iteritems():
        z, y, x = [
            int(xx) for xx in zyx.replace(
                '(',
                '',
            ).replace(')', '').split(',')
        ]
        cell_cnn[z, y, x] = v * 100
    merged = np.stack([cell_cnn, cell_reg, np.zeros_like(cell_reg)], -1)
    tifffile.imsave('/home/wanglab/Downloads/merged.tif', merged)
    #out = np.concatenate([cell_cnn, cell_reg, ], 0)
                        '(',
                        '',
                    ).replace(')', '').split(',')
                ]
                try:
                    cnn_cellvolloaded[z, y, x] = v * 100
                except Exception as e:
                    print(e)
            merged = np.stack([
                cnn_cellvolloaded, cellvolloaded,
                np.zeros_like(cellvolloaded)
            ], -1)
            merged = np.swapaxes(merged, 0, 2)  #reorient to horizontal
            tifffile.imsave(
                os.path.join(
                    dst,
                    'generate_downsized_overlay_{}_points_merged_resampled_for_elastix.tif'
                    .format(os.path.basename(fld))), merged)

        #EXAMPLE USING LIGHTSHEET - assumes marking centers in the 'raw' full sized cell channel. This will transform those centers into "atlas" space (in this case the moving image)
        #in this case the "inverse transform has the atlas as the moving image in the first step, and the autofluorescence channel as the moving image in the second step
        r2s0 = [
            xx for xx in listall(cellvol.inverse_elastixfld,
                                 'reg2sig_TransformParameters.0.txt')
            if 'cellch' in xx
        ][0]
        r2s1 = [
            xx for xx in listall(cellvol.inverse_elastixfld,
                                 'reg2sig_TransformParameters.1.txt')
            if 'cellch' in xx
        ][0]
Beispiel #19
0
        self.stack = self.stack.astype(np.uint8)
            
        
        
        
        
        
        
        
# test

s = AlignStack('C:/Users/ad245339/Desktop/images/Dissolution Mesbah-Tocino 2011/AM39-FDA-suivi disso X5000')
s.run4()
s.cropage()
imsave('test.tif', s.stackAligne)
""" 
"""      
        
        
        
        
        
        
        
        
        
        
        
        
        
Beispiel #20
0
def build_iscat_training(bf_filepaths, iscat_filepaths, sampling=4):
    """Creates iscat training data and target in data/iscat_seg/[REF_FRAMES / MASKS] for the iSCAT cell segmentation task
    
        ARGS:
            bf_filepaths (list(str)): filepaths of all the bright field images to input as returned by utilitiues.load_data_paths()            
            iscat_filepaths (list(str)): filepaths of all the iscat images to input as returned by utilitiues.load_data_paths()
            sampling (int): sampling interval of the saved images (lower storage footprint)
    """

    OUT_PATH = DATA_PATH + 'iscat_seg/'
    os.makedirs(os.path.join(OUT_PATH, 'REF_FRAMES/'), exist_ok=True)
    os.makedirs(os.path.join(OUT_PATH, 'MASKS/'), exist_ok=True)

    # Range of non filtered elements [px]
    min_size, max_size = 1, 13

    iscat_stacks = (utilities.load_imgs(path) for path in iscat_filepaths)
    bf_stacks = (utilities.load_imgs(path) for path in bf_filepaths)

    # Returns the metadata of the exwperiments such as frame rate
    metadatas = get_experiments_metadata(iscat_filepaths)

    if torch.cuda.is_available():
        device = torch.cuda.current_device()
        torch.cuda.set_device(device)
        print("Running on: {:s}".format(torch.cuda.get_device_name(device)))
        cuda = torch.device('cuda')
    else:
        # Doesn't run on CPU only machines comment if no GPU
        print("No CUDA device found")
        sys.exit(1)

    unet = UNetCell(1, 1, device=cuda, bilinear_upsampling=False)
    unet.load_state_dict(torch.load('outputs/saved_models/bf_unet.pth'))

    for i, (bf_stack, iscat_stack,
            metadata) in enumerate(zip(bf_stacks, iscat_stacks, metadatas)):
        if i < 45: continue

        bf_stack = bf_stack.astype('float32')
        print(bf_stack.shape)
        if bf_stack.shape[1:] != iscat_stack.shape[1:]:
            bf_stack = processing.coregister(bf_stack, 1.38)
            print(bf_stack.shape)

        normalize(bf_stack)

        # Samples iscat image to correct for the difference in framefate
        iscat_stack = iscat_stack[::sampling * int(metadata['iscat_fps'] /
                                                   metadata['tirf_fps'])]

        torch_stack = torch.from_numpy(bf_stack).unsqueeze(1).cuda()
        mask = unet.predict_stack(
            torch_stack).detach().squeeze().cpu().numpy() > 0.05
        mask = morphology.grey_erosion(mask * 255,
                                       structure=processing.structural_element(
                                           'circle', (3, 5, 5)))
        mask = morphology.grey_closing(mask,
                                       structure=processing.structural_element(
                                           'circle', (3, 7, 7)))
        mask = (mask > 50).astype('uint8')

        # Median filtering and normalization
        iscat_stack = processing.image_correction(iscat_stack)

        # Contrast enhancement
        iscat_stack = processing.enhance_contrast(iscat_stack,
                                                  'stretching',
                                                  percentile=(1, 99))

        # Fourier filtering of image
        iscat_stack = processing.fft_filtering(iscat_stack, min_size, max_size,
                                               True)
        iscat_stack = processing.enhance_contrast(iscat_stack,
                                                  'stretching',
                                                  percentile=(3, 97))

        for j in range(0, min(iscat_stack.shape[0], mask.shape[0]), sampling):
            if iscat_stack[j].shape == mask[j].shape:
                # Doesn't save images without detected cells
                if mask[j].max() == 0: continue

                print("\rSaving to stack_{}_{}.png".format(i + 1, j + 1),
                      end=' ' * 5)
                tifffile.imsave(
                    os.path.join(OUT_PATH, 'REF_FRAMES/',
                                 "stack_{}_{}.png".format(i + 1, j + 1)),
                    rescale(iscat_stack[j]))
                tifffile.imsave(
                    os.path.join(OUT_PATH, 'MASKS/',
                                 "mask_{}_{}.png".format(i + 1, j + 1)),
                    mask[j] * 255)
            else:
                print("Error, shape: {}, {}".format(iscat_stack[j].shape,
                                                    mask[j].shape))
                break

        print('')
Beispiel #21
0
    def test(self):
        del self.WGANVGG
        # load
        self.WGANVGG_G = WGAN_VGG_generator().to(self.device)
        self.load_model()

        # compute PSNR, SSIM, RMSE
        ori_psnr_avg, ori_ssim_avg = 0, 0
        pred_psnr_avg, pred_ssim_avg = 0, 0

        with torch.no_grad():
            num_total_img = len(self.test_list)
            for img_idx, img_path in enumerate(self.test_list):
                img_name = os.path.basename(img_path)
                img_path = os.path.abspath(img_path)
                print("[{}/{}] processing {}".format(
                    img_idx, num_total_img, os.path.abspath(img_path)))

                gt_img_path = self.test_gt_list[img_idx]
                gt_img = imread(gt_img_path)
                input_img = imread(img_path)
                img_patch_dataset = ImageDataset(self.opt, input_img)
                img_patch_dataloader = DataLoader(
                    dataset=img_patch_dataset,
                    batch_size=self.opt.batch_size,
                    shuffle=False)

                img_shape = img_patch_dataset.get_img_shape()
                pad_img_shape = img_patch_dataset.get_padded_img_shape()

                out_list = []

                for i, x in enumerate(img_patch_dataloader):

                    x = x.float().to(self.device)

                    pred = self.WGANVGG_G(x)
                    pred = pred.to('cpu').detach().numpy()
                    out_list.append(pred)

                out = np.concatenate(out_list, axis=0)
                out = out.squeeze()

                img_name = 'out-' + img_name
                base_name = os.path.basename(self.opt.checkpoint_dir)
                test_result_dir = os.path.join(self.opt.test_result_dir,
                                               base_name)
                if not os.path.exists(test_result_dir):
                    os.makedirs(test_result_dir)
                dst_img_path = os.path.join(test_result_dir, img_name)

                out_img = mp.recon_patches(out, pad_img_shape[1],
                                           pad_img_shape[0],
                                           self.opt.patch_size,
                                           self.opt.patch_offset)
                out_img = mp.unpad_img(out_img, self.opt.patch_offset,
                                       img_shape)

                input_img = torch.Tensor(input_img)
                out_img = torch.Tensor(out_img)
                gt_img = torch.Tensor(gt_img)
                input_img = self.trunc(
                    self.denormalize_(input_img).cpu().detach())
                out_img = self.trunc(self.denormalize_(out_img).cpu().detach())
                gt_img = self.trunc(self.denormalize_(gt_img).cpu().detach())

                # x = self.trunc(self.denormalize_(x))
                # out_img = self.trunc(self.denormalize_(out_img))
                # gt_img = self.trunc(self.denormalize_(gt_img))

                data_range = self.trunc_max - self.trunc_min

                original_result, pred_result = compute_measure(
                    input_img, gt_img, out_img, data_range)

                op, oos, _ = original_result
                pp, ps, _ = pred_result

                ori_psnr_avg += op
                ori_ssim_avg += oos
                pred_psnr_avg += pp
                pred_ssim_avg += ps

                out_img = self.normalize_(out_img)
                out_img = out_img.cpu().numpy()
                imsave(dst_img_path, out_img)

            aop = ori_psnr_avg / (img_idx + 1)
            aos = ori_ssim_avg / (img_idx + 1)
            app = pred_psnr_avg / (img_idx + 1)
            aps = pred_ssim_avg / (img_idx + 1)
            print(
                "((ORIGIN)) PSNR : {:.5f}, SSIM : {:.5f}, ((PREP)) PSNR : {:.5f}, SSIM : {:.5f}"
                .format(aop, aos, app, aps))
Beispiel #22
0
    b = []
    x_range = np.arange(0, 100, 1)
    y_range = np.arange(0, 100, 1)
    z_range = np.arange(40, 43, 3)
    try:
        a, b = fastScan(piStage,
                        ps,
                        n_captures=3000,
                        x_range=x_range,
                        y_range=y_range,
                        z_range=z_range)

        print('TotalTime:', time.time() - start0)

        print(piStage.CloseConnection())
        ps.close()

        imsave('dataA.tif', a)
        imsave('dataB.tif', a)
        from pylab import *
        matshow(a[0])
        show(0)
    except:
        traceback.print_exc()
        print(piStage.CloseConnection())
        ps.close()

#plot(dataA)
#plot(dataB)
#show(0)
as of march 2019 numpy and scikit-image need updating to newer versions using conda
	conda install -c anaconda numpy=1.16.0
	conda install -c anaconda scikit-image=0.14.2
as does tensor flow gpu  - the version installed by flowdec have a dll load error. 
watch out for cuda / tensorflow versions compatabiliries. 
	conda install -c anaconda tensorflow-gpu    
I got a load dll error before this install, but tensor flow updated to v1.13 tested ok
"""

from skimage.external.tifffile import imsave, imread
from flowdec import data as fd_data
from flowdec import restoration as fd_restoration

# Load test image from same dir as we execute in
raw = imread('C1-YeastTNA1_1516_conv_RG_26oC_003.tif')

# Load psf kernel image from same dir
kernel = imread('gpsf_3D_1514_a3_001_WF-sub105.tif')

# Run the deconvolution process and note that deconvolution initialization is best kept separate from 
# execution since the "initialize" operation corresponds to creating a TensorFlow graph, which is a 
# relatively expensive operation and should not be repeated across multiple executions
n_iter = 500
algo = fd_restoration.RichardsonLucyDeconvolver(raw.ndim).initialize()
res = algo.run(fd_data.Acquisition(data=raw, kernel=kernel), niter=n_iter).data

# save the result,
print('Saving result image TIFF file')
# using skimage.external.tifffile.imsave
imsave(('result' + str(n_iter) + 'iterations.tif'), res)
from skimage.external import tifffile

print(sys.argv)
print(os.environ["SLURM_ARRAY_TASK_ID"])
jobid = int(os.environ["SLURM_ARRAY_TASK_ID"])

src = "/jukebox/scratch/kellyms"

pths = [
    os.path.join(src, xx) for xx in os.listdir(src) if "m6" in xx or "f6" in xx
]

if jobid > len(pths) + 1:
    print("array jobs greater than number of brains")
else:
    print("processing brain: {}".format(pths[jobid]))

    arrpth = os.path.join(
        pths[jobid], "transformed_annotations/transformed_annotations.npy")
    dst = os.path.join(pths[jobid], "annotations_as_single_tifs")
    if not os.path.exists(dst): os.mkdir(dst)
    arr = np.lib.format.open_memmap(arrpth, dtype="uint16", mode="r")

    print("\nfile with shape: {}".format(arr.shape))

    for z in range(arr.shape[0]):
        tifffile.imsave(os.path.join(
            dst, "annotation_Z{}.tif".format(str(z).zfill(4))),
                        arr[z],
                        compress=6)
        print("\nmade z plane # {}".format(z))
Beispiel #25
0
    mm = stat.readDataGroup(mm_du_heatmaps)
    fm = stat.readDataGroup(fm_du_heatmaps)
    mf = stat.readDataGroup(mf_du_heatmaps)

    #find mean and standard deviation of heatmap in each group
    mm_mean = np.mean(mm, axis=0)
    mm_std = np.std(mm, axis=0)

    fm_mean = np.mean(fm, axis=0)
    fm_std = np.std(fm, axis=0)

    mf_mean = np.mean(mf, axis=0)
    mf_std = np.std(mf, axis=0)

    #write mean and standard dev maps to destination
    tifffile.imsave(os.path.join(pvaldst, "mm_mean.tif"),
                    np.transpose(mm_mean, [1, 0, 2]).astype("float32"))
    tifffile.imsave(os.path.join(pvaldst, "mm_std.tif"),
                    np.transpose(mm_std, [1, 0, 2]).astype("float32"))

    tifffile.imsave(os.path.join(pvaldst, "fm_mean.tif"),
                    np.transpose(fm_mean, [1, 0, 2]).astype("float32"))
    tifffile.imsave(os.path.join(pvaldst, "fm_std.tif"),
                    np.transpose(fm_std, [1, 0, 2]).astype("float32"))

    tifffile.imsave(os.path.join(pvaldst, "mf_mean.tif"),
                    np.transpose(mf_mean, [1, 0, 2]).astype("float32"))
    tifffile.imsave(os.path.join(pvaldst, "mf_std.tif"),
                    np.transpose(mf_std, [1, 0, 2]).astype("float32"))

    #Generate the p-values map
    ##########################
def generate_patch(**params):
    """
    Function to patch up data and make into memory mapped array
    
    Inputs
    -----------
    src = folder containing tiffs
    patch_dst = location to save memmap array
    patchlist = list of patches generated from make_indices function
    stridesize = (90,90,30) - stride size in 3d ZYX
    patchsize = (180,180,60) - size of window ZYX
    mode = "folder" #"folder" = list of files where each patch is a file, "memmap" = 4D array of patches by Z by Y by X

    Returns
    ------------
    location of patched memory mapped array of shape (patches, patchsize_z, patchsize_y, patchsize_x)

    """
    #load array
    input_arr = load_memmap_arr(
        os.path.join(params["data_dir"], "input_memmap_array.npy"))

    #set patch destination
    patch_dst = os.path.join(params["data_dir"], "input_chnks")

    #set variables
    if patch_dst[-4:] == ".npy": patch_dst = patch_dst[:-4]
    if not os.path.exists(patch_dst): os.mkdir(patch_dst)
    window = params["window"]
    patchsize = params["patchsz"]

    jobid = int(params["jobid"])  #set patch no. to run through cnn
    #select the file to process for this array job
    if jobid > len(params["patchlist"]) - 1:
        sys.stdout.write("\njobid {} > number of files".format(jobid))
        sys.stdout.flush()
    else:
        #patch
        for i, p in enumerate(params["patchlist"]):
            if i == jobid:
                v = input_arr[p[0]:p[0] + patchsize[0],
                              p[1]:p[1] + patchsize[1],
                              p[2]:p[2] + patchsize[2]]
                #padding to prevent cnn erros
                if v.shape[0] < window[0]:
                    pad = np.zeros(
                        (window[0] - v.shape[0], v.shape[1], v.shape[2]))
                    v = np.append(v, pad, axis=0)
                if v.shape[1] < window[1]:
                    pad = np.zeros(
                        (v.shape[0], window[1] - v.shape[1], v.shape[2]))
                    v = np.append(v, pad, axis=1)
                if v.shape[2] < window[2]:
                    pad = np.zeros(
                        (v.shape[0], v.shape[1], window[2] - v.shape[2]))
                    v = np.append(v, pad, axis=2)
                #saving out
                tifffile.imsave(os.path.join(
                    patch_dst, "patch_{}.tif".format(str(i).zfill(10))),
                                v.astype("float32"),
                                compress=1)
                if params["verbose"]:
                    print("{} of {}".format(i, len(params["patchlist"])))
    #return
    return patch_dst
Beispiel #27
0
#run_list = ['scenes_run1','scenes_run2','scenes_run3','scenes_run3','scenes_run4','scenes_run5','scenes_run6','scenes_run7','scenes_run8','scenes_run9','scenes_run10']
#figure out directories to search
dst_dir = os.path.join(rootdir, animalid, session, acquisition, 'all_combined',
                       'block_reduced')
if not os.path.isdir(dst_dir):
    os.makedirs(dst_dir)

for run in run_list:
    #run = run_list[0]
    data_dir = os.path.join(rootdir, animalid, session, acquisition, run)

    raw_dir = glob.glob(os.path.join(data_dir, 'raw*'))[0]
    print(raw_dir)
    src_dir = os.path.join(raw_dir, '*.tif')

    for fn in glob.glob(src_dir):

        i0 = findOccurrences(fn, '/')[-1]
        i1 = findOccurrences(fn, '_')[-1]

        new_fn = '%s_%s_%s' % (acquisition, run, fn[i1 + 1:])
        print(new_fn)

        stack0 = imread(fn)

        stack1 = block_mean_stack(stack0, (2, 2))

        print(stack1.shape)

        imsave(os.path.join(dst_dir, new_fn), stack1)
requires installation of python and other python packlages, 
which are included in the anaconda python release.
pyCUDAdecon and instructions to install and use are at  
https://github.com/tlambert03/pycudadecon
"""

#import required packages
from pycudadecon import decon, make_otf
from skimage.external.tifffile import imsave

# set input a and output file paths
image_path = 'C1-YeastTNA1_1516_conv_RG_26oC_003.tif'
psf_path = 'gpsf_3D_1514_a3_001_WF-sub105.tif'
otfOutPath = 'otf.tif'

# do the deconvolution on GPU
numIters = 30
result = decon(image_path, psf_path, n_iters=numIters)
print("result data type is " + str(result.dtype))
print('results numpy array shape is ')
print(result.shape)

# save the result,
print('Saving result image TIFF file')
# using skimage.external.tifffile.imsave
imsave(('result' + str(numIters) + 'iterations.tif'), result) #, imagej)

# save otf tiff file from PSF image tiff.
print('making otf')
make_otf(psf_path, otfOutPath, dzpsf=0.15, dxpsf=0.05, wavelength=510, na=1.3, nimm=1.333, otf_bgrd=None, krmax=0, fixorigin=10, cleanup_otf=True, max_otf_size=60000)
Beispiel #29
0
    labels = np.unique(fov_ins_array[fov_ins_array > 0])
    i = 0
    for label in labels:
        i += 1
        if i > 5: break
        fov_seg_array = closing(fov_ins_array == label, ball(1))
        fov_label_array = skimage.measure.label(fov_seg_array)
        fov_labels = np.unique(fov_label_array[fov_label_array > 0])

        label_sel = fov_labels[np.argmax(
            [np.sum(fov_label_array == x) for x in fov_labels])]

        fov_seg_array = fov_label_array == label_sel
        if np.sum(fov_seg_array) < 50:
            continue
        fov_skel_array, skel = skel_cal(fov_seg_array)

        skels_array[fov_skel_array > 0] = 1

        ends, vecs = ends_cal(skel)
        ends_array[ends[:, 0], ends[:, 1], ends[:, 2]] = 1

    fname = osp.splitext(osp.basename(fov_ins_path))[0]
    fpath_ends = osp.join(osp.dirname(fov_ins_path),
                          "{}_ends.tif".format(fname))
    fpath_skels = osp.join(osp.dirname(fov_ins_path),
                           "{}_skels.tif".format(fname))

    tifffile.imsave(fpath_ends, ends_array)
    tifffile.imsave(fpath_skels, skels_array)
Beispiel #30
0
def main():

    # Initialize common configurations
    common_config = Config("../../config/common.config")

    # Get image sequence path and filename
    path = common_config["Image Sequence"]["Path"]
    filename = common_config["Image Sequence"]["Filename"]

    try:
        input_folder = sys.argv[1]
        make_legend = True
    except:
        # Get output folder
        output_folder = os.path.join("..", "..", "output", "tracking/", common_config["Output"]["Folder"])
        # Get latest folder
        latest_results = get_latest_folder(output_folder)
        # Make input folder
        input_folder = os.path.join(output_folder, latest_results)
        # Do not make legend
        make_legend = False

    print "Input folder:", input_folder

    # Read trajectories
    filenames = filter(lambda fn: fn.lower().endswith(".zip"), os.listdir(input_folder))
    labels = map(lambda fn: os.path.splitext(fn)[0], filenames)

    # Upload trajectories
    contours = {label : unzip_csv(os.path.join(input_folder, filename)) for filename, label in zip(filenames, labels)}
    contours_n = len(contours)

    # Read image sequence
    input_sequence = np.squeeze(imread(os.path.join(path, filename))).astype(np.float32)
    input_sequence /= input_sequence.max()

    frame_n = len(input_sequence)

    try:
        fns, colors = colors_from_csv(os.path.join(input_folder, "colors.csv"))
        color_map = {fn: clr for fn, clr in zip(fns, colors)}
    except:
        colors = get_random_colors(contours_n, "hsv")
        color_map = {fn: clr for fn, clr in zip(labels, colors)}

    rgb_stack = []
    filaments_mask = np.zeros_like(input_sequence[0], dtype=np.uint16)

    for frame_i in xrange(frame_n):
        sys.stdout.write("\r Frame: " + str(frame_i))
        image_rgb = np.dstack([input_sequence[frame_i]] * 3)
        for filament_i, filament_data in enumerate(contours.items()):
            tname, tcoords = filament_data
            try:
                fiber_color = color_map[tname]
            except:
                fiber_color = colors[fiber_color]
            cv2.polylines(image_rgb, [tcoords[frame_i].astype(np.int32)], False, fiber_color, 1, 8)
            cv2.polylines(filaments_mask[frame_i], [tcoords[frame_i].astype(np.int32)], False, filament_i + 1)

        rgb_stack.append((image_rgb * 255).astype(np.uint8))

    sys.stdout.write("\r Finished.\n")
    imsave(os.path.join(input_folder, "overlay.tif"), np.asarray(rgb_stack))
    imsave(os.path.join(input_folder, "index.tif"), filaments_mask)

    # Make legend
    if make_legend:
        labels = contours.keys()
        filament = [contour[0] for contour in contours.values()]

        legend = gen_legend(filament, labels, colors, input_sequence[0])
        # Save legend
        imsave(os.path.join(input_folder, "legend.tif"), (legend * 255).astype(np.uint8))
Beispiel #31
0
                                         p2=swc_array[i + 1, 2:5][::-1],
                                         size=shape)
            else:
                print("The line {} have error. s: {}".format(i, s))
                break

        mask[line > 0] = label
    mask = dilation(mask, ball(1))
    return mask


if __name__ == "__main__":
    # test()
    #    m = Connect_2_points(p1=[173, 140, 10], p2=[173, 139, 9])
    #    m = Connect_2_points(p1=[172, 136, 3], p2=[173, 138, 4])
    # m = Connect_2_points(p1=[0, 0, 3], p2=[0, 0, 8])
    # print(m.sum())
    # connect_2_points_()

    swc_path = r"C:\Users\Administrator\Desktop\Syn_chaos_300_5_2_4_6_000\swcs\Syn_chaos_300_5_2_4_6_000_4.swc"
    path, name = os.path.split(swc_path)
    label = str_to_float(name.split('.')[0].split('_')[-1])
    swc_num = np.array(psc(path, name.split('.')[0]))
    c_e = find_cross_end(swc_num)

    mask = sparse2dense_Loop(swc_num, shape=[300, 300, 300], label=label)

    tifffile.imsave(os.path.join(path,
                                 name.split('.')[0] + '.tif'),
                    (mask > 0).astype(np.float32))
    print('')
array = labelled [0]
# array = array.astype(np.uint8)

# calculating frequency of label numbers 
unique, counts = np.unique(array, return_counts=True)

#threshold frequency(volume) 
volume_thres = 400

# list of objects smaller than threshold 
rmv = []

for i in range(len(counts)):
    if counts[i] < volume_thres:
        rmv.append(i)
        
        
#%% 
        
for i in range(50):
    image = array[i]
    image = vol_filter(image)
    imsave('00000' + str(i) + '.tif', image)        

        
## single image of stack 
#filtered = np.zeros(stack.shape,dtype = np.uint8)
#for idx, frame in tqdm(enumerate(array)):
#    filtered[idx] = vol_filter(frame)
#save_path = r'\Users\aishw\Desktop\ImgProc\zstack\PythonVer\Ver2\Filtered.tif'
#imsave(save_path, filtered)
Beispiel #33
0
    def toarray(f):
        with open(f) as fid:
            return frombuffer(fid.read(), dtype).reshape(dims, order='F')

    os.system('mkdir neurofinder.%s/images-tif' % name)
    if downsample:
        for i in range(len(files) / 4):
            if i * 4 + 4 <= len(files):
                tmp = zeros(dims)
                for j in range(4):
                    im = toarray(files[i * 4 + j])
                    im = im.clip(0, im.max()).astype('uint16')
                    tmp += im
                tmp = (tmp / 4.0).astype('uint16')
                tifffile.imsave(
                    'neurofinder.%s/images-tif/image%05g.tiff' % (name, i), im)
    else:
        for i, f in enumerate(files):
            im = toarray(f)
            im = im.clip(0, im.max()).astype('uint16')
            tifffile.imsave(
                'neurofinder.%s/images-tif/image%05g.tiff' % (name, i), im)
    os.system('rm -rf neurofinder.%s/images' % name)
    os.system('mv neurofinder.%s/images-tif neurofinder.%s/images' %
              (name, name))
else:
    print('skipping tiff conversion\n\n')

print('creating zip\n\n')
os.system('zip -r neurofinder.%s.zip neurofinder.%s' % (name, name))
Beispiel #34
0
def identify_structures_w_contours(jobid,
                                   cores=5,
                                   make_color_images=False,
                                   overlay_on_original_data=False,
                                   consider_only_multipln_contours=False,
                                   **kwargs):
    '''function to take 3d detected contours and apply elastix transform
    '''
    #######################inputs and setup#################################################
    ###inputs
    kwargs = load_kwargs(**kwargs)
    outdr = kwargs['outputdirectory']
    vols = kwargs['volumes']
    reg_vol = [xx for xx in vols if xx.ch_type == 'regch'][0]

    ###get rid of extra jobs
    if jobid >= len([xx for xx in vols if xx.ch_type != 'regch'
                     ]):  ###used to end jobs if too many are called
        print('jobid({}) >= volumes {}'.format(
            jobid, len([xx for xx in vols if xx.ch_type != 'regch'])))
        return

    ###volumes to process: each job represents a different contour volume
    vol_to_process = [xx for xx in vols if xx.ch_type != 'regch'][jobid]
    ch = vol_to_process.channel
    print(vol_to_process.ch_type)

    #find appropriate folders for contours
    if vol_to_process.ch_type == 'cellch':
        detect3dfld = reg_vol.celldetect3dfld
        coordinatesfld = reg_vol.cellcoordinatesfld
    elif vol_to_process.ch_type == 'injch':
        detect3dfld = reg_vol.injdetect3dfld
        coordinatesfld = reg_vol.injcoordinatesfld

    #set scale and atlas
    xscl, yscl, zscl = reg_vol.xyz_scale  ###micron/pixel
    zmx, ymx, xmx = reg_vol.fullsizedimensions
    AtlasFile = reg_vol.atlasfile
    print('Using {} CORES'.format(cores))
    try:
        p
    except NameError:
        p = mp.Pool(cores)
    resizefactor = kwargs['resizefactor']
    brainname = reg_vol.brainname

    ############################################################################################################
    #######################use regex to sort np files by ch and then by zpln####################################
    ############################################################################################################
    fl = [f for f in os.listdir(detect3dfld)
          if '.p' in f and 'ch' in f]  #sorted for raw files
    reg = re.compile(r'(.*h+)(?P<ch>\d{2})(.*)(.p)')
    matches = map(reg.match, fl)

    ##load .np files
    sys.stdout.write(
        '\njobid({}), loading ch{} .p files to extract contour_class objects....'
        .format(jobid, ch))
    contour_class_lst = []
    for fl in [
            os.path.join(detect3dfld, ''.join(xx.groups())) for xx in matches
            if xx.group('ch')[-2:] in ch
    ]:
        tmpkwargs = {}
        pckl = open(fl, 'rb')
        tmpkwargs.update(pickle.load(pckl))
        pckl.close()
        if consider_only_multipln_contours == False:
            tmplst = tmpkwargs['single']
            [tmplst.append(xx) for xx in tmpkwargs['multi']]
        elif consider_only_multipln_contours == True:
            tmplst = tmpkwargs['multi']
        [contour_class_lst.append(xx) for xx in tmplst]
    sys.stdout.write('\ndone loading contour_class objects.\n')

    #check for successful loading
    if len(contour_class_lst) == 0:
        print('Length of contours in ch{} was {}, ending process...'.format(
            jobid, len(contour_class_lst)))
        try:
            p.terminate()
        except:
            1
        return

    ############################################################################################################
    ##############################make color files##############################################################
    ############################################################################################################
    if make_color_images == True:
        sys.stdout.write('\nmaking 3d planes...')
        sys.stdout.flush()
        valid_plns = range(0, zmx + 1)
        svlc = os.path.join(outdr, 'ch{}_3dcontours'.format(ch))
        removedir(svlc)
        if overlay_on_original_data == False:
            ovly = False
        elif overlay_on_original_data == True:
            ovly = True
        iterlst = []
        [
            iterlst.append(
                (ch, svlc, contour_class_lst, valid_plns, outdr,
                 vol_to_process, resizefactor, contour_class_lst,
                 consider_only_multipln_contours, ovly, core, cores))
            for core in range(cores)
        ]
        p.starmap(ovly_3d, iterlst)
        lst = os.listdir(svlc)
        lst1 = [os.path.join(svlc, xx) for xx in lst]
        lst1.sort()
        del lst
        del iterlst
        ###load ims and return dct of keys=str(zpln), values=np.array
        sys.stdout.write(
            '\n3d planes made, saved in {},\nnow compressing into single tifffile'
            .format(svlc))
        imstack = tifffile.imread(lst1)
        del lst1
        if len(imstack.shape) > 3:
            imstack = np.squeeze(imstack)
        try:  ###check for orientation differences, i.e. from horiztonal scan to sagittal for atlas registration
            imstack = np.swapaxes(imstack, *kwargs['swapaxes'])
        except:
            pass
        tiffstackpth = os.path.join(
            outdr, '3D_contours_ch{}_{}'.format(ch, brainname))
        tifffile.imsave(tiffstackpth, imstack.astype('uint16'))
        del imstack
        gc.collect()
        shutil.rmtree(svlc)
        sys.stdout.write('\ncolor image stack made for ch{}'.format(ch))
    else:
        sys.stdout.write('\nmake_color_images=False, not creating images')
    ############################################################################################################
    ######################apply point transform and make transformix input file#################################
    ############################################################################################################
    ###find centers and add 1's to make nx4 array for affine matrix multiplication to account for downsizing
    ###everything is in PIXELS
    contourarr = np.empty((len(contour_class_lst), 3))
    for i in range(len(contour_class_lst)):
        contourarr[i, ...] = contour_class_lst[
            i].center  ###full sized dimensions: if 3x3 tiles z(~2000),y(7680),x(6480) before any rotation
    try:
        contourarr = swap_cols(
            contourarr, *kwargs['swapaxes']
        )  ###change columns to account for orientation changes between brain and atlas: if horizontal to sagittal==>x,y,z relative to horizontal; zyx relative to sagittal
        z, y, x = swap_cols(np.array([
            vol_to_process.fullsizedimensions
        ]), *kwargs['swapaxes'])[
            0]  ##convert full size cooridnates into sagittal atlas coordinates
        sys.stdout.write('\nSwapping Axes')
    except:  ###if no swapaxes then just take normal z,y,x dimensions in original scan orientation
        z, y, x = vol_to_process.fullsizedimensions
        sys.stdout.write('\nNo Swapping of Axes')
    d1, d2 = contourarr.shape
    nx4centers = np.ones((d1, d2 + 1))
    nx4centers[:, :-1] = contourarr
    ###find resampled elastix file dim

    print(os.listdir(outdr))
    print([xx.channel for xx in vols if xx.ch_type == 'regch'])
    with tifffile.TiffFile([
            os.path.join(outdr, f) for f in os.listdir(outdr)
            if 'resampledforelastix' in f and 'ch{}'.format(
                [xx.channel for xx in vols if xx.ch_type == 'regch'][0]) in f
    ][0]) as tif:
        zr = len(tif.pages)
        yr, xr = tif.pages[0].shape
        tif.close()
    ####create transformmatrix
    trnsfrmmatrix = np.identity(4) * (
        zr / z, yr / y, xr / x, 1)  ###downscale to "resampledforelastix size"
    sys.stdout.write('trnsfrmmatrix:\n{}\n'.format(trnsfrmmatrix))
    #nx4 * 4x4 to give transform
    trnsfmdpnts = nx4centers.dot(trnsfrmmatrix)  ##z,y,x
    sys.stdout.write('first three transformed pnts:\n{}\n'.format(
        trnsfmdpnts[0:3]))
    #create txt file, with elastix header, then populate points
    txtflnm = '{}_zyx_transformedpnts_ch{}.txt'.format(brainname, ch)
    pnts_fld = os.path.join(outdr, 'transformedpoints_pretransformix')
    makedir(pnts_fld)
    transforminput = os.path.join(pnts_fld, txtflnm)
    removedir(transforminput)  ###prevent adding to an already made file
    writer(pnts_fld, 'index\n{}\n'.format(len(trnsfmdpnts)), flnm=txtflnm)
    sys.stdout.write(
        '\nwriting centers to transfomix input points text file: {}....'.
        format(transforminput))
    stringtowrite = '\n'.join([
        '\n'.join(['{} {} {}'.format(i[2], i[1], i[0])]) for i in trnsfmdpnts
    ])  ####this step converts from zyx to xyz*****
    writer(pnts_fld, stringtowrite, flnm=txtflnm)
    #[writer(pnts_fld, '{} {} {}\n'.format(i[2],i[1],i[0]), flnm=txtflnm, verbose=False) for i in trnsfmdpnts] ####this step converts from zyx to xyz*****
    sys.stdout.write('...done writing centers.')
    sys.stdout.flush()
    del trnsfmdpnts, trnsfrmmatrix, nx4centers, contourarr
    gc.collect()
    ############################################################################################################
    ####################################elastix for inverse transform###########################################
    ############################################################################################################
    transformfile = make_inverse_transform(vol_to_process, cores, **kwargs)
    assert os.path.exists(transformfile)
    sys.stdout.write(
        '\n***Elastix Inverse Transform File: {}***'.format(transformfile))
    ############################################################################################################
    ####################################transformix#############################################################
    ############################################################################################################
    if make_color_images != False:
        #apply transform to 3d_tiffstack:
        transformimageinput = tiffstackpth
        elastixpth = os.path.join(outdr, 'elastix')
        trnsfrm_outpath = os.path.join(
            elastixpth, '3D_contours_ch{}_{}'.format(ch, brainname))
        makedir(trnsfrm_outpath)
        writer(trnsfrm_outpath, '\nProcessing ch{} 3D...'.format(ch))
        #transformfiles=[os.path.join(elastixpth, xx) for xx in os.listdir(os.path.join(outdr, 'elastix')) if "TransformParameters" in xx]; mxx=max([xx[-5] for xx in transformfiles])
        #transformfile=os.path.join(elastixpth, 'TransformParameters.{}.txt'.format(mxx))
        trnsfrm_out_file = os.path.join(trnsfrm_outpath,
                                        'result.tif')  #output of transformix
        transformimageinput_resized = transformimageinput[:-4] + '_resampledforelastix.tif'
        print('Resizing {}'.format(transformimageinput_resized))
        resample_par(cores,
                     transformimageinput,
                     AtlasFile,
                     svlocname=transformimageinput_resized,
                     singletifffile=True,
                     resamplefactor=1.7)
        sp.call([
            'transformix', '-in', transformimageinput_resized, '-out',
            trnsfrm_outpath, '-tp', transformfile
        ])
        writer(trnsfrm_outpath,
               '\n   Transformix File Generated: {}'.format(trnsfrm_out_file))
        writer(
            trnsfrm_outpath, '\n   Passing colorcode: {} file as {}'.format(
                ch, os.path.join(trnsfrm_outpath, 'depthcoded.png')))
        ###depth coded image of transformix result; not functional yet
        #depth.colorcode(trnsfrm_out_file, trnsfrm_outpath)
        #getvoxels(trnsfrm_out_file, os.path.join(trnsfrm_outpath, 'zyx_voxels_{}.npy'.format(ch)))
        #allen_compare(AtlasFile, svlc, trnsfrm_outpath)
        ##if successful delete contour cooridnates and maybe contourdetect3d flds
    ############################################################

    ##############apply transform to points#####################
    elastixpth = os.path.join(outdr, 'elastix_inverse_transform')
    trnsfrm_outpath = os.path.join(elastixpth, 'ch{}_3dpoints'.format(ch))
    makedir(trnsfrm_outpath)
    writer(trnsfrm_outpath,
           '\n***********Starting Transformix for: {}***********'.format(ch))
    sys.stdout.flush()
    #transformfiles=[os.path.join(elastixpth, xx) for xx in os.listdir(os.path.join(outdr, 'elastix')) if "TransformParameters" in xx]; mxx=max([xx[-5] for xx in transformfiles])
    #transformfile=os.path.join(elastixpth, 'TransformParameters.{}.txt'.format(mxx))
    trnsfrm_out_file = os.path.join(
        trnsfrm_outpath, 'outputpoints.txt')  #MIGHT NEED TO CHANGE THIS
    sp.call([
        'transformix', '-def', transforminput, '-out', trnsfrm_outpath, '-tp',
        transformfile
    ])
    #sp.call(['transformix', '-def', 'all', '-out', trnsfrm_outpath, '-tp', transformfile]) ##displacement field
    writer(trnsfrm_outpath,
           '\n   Transformix File Generated: {}'.format(trnsfrm_out_file))
    ####################################################################################
    ##############generate list and image overlaid onto allen atlas#####################
    ####################################################################################
    name = 'job{}_{}'.format(jobid, vol_to_process.ch_type)
    transformed_pnts_to_allen(trnsfrm_out_file, ch, cores, name=name, **kwargs)
    writer(outdr, '*************STEP 5*************\n Finished')
    print('end of script')
    try:
        p.terminate()
    except:
        1
    return
Beispiel #35
0
def save_tiff(img, filename):
    tifffile.imsave(filename, img)
Beispiel #36
0
def transformed_pnts_to_allen(trnsfrm_out_file,
                              ch,
                              cores,
                              point_or_index=None,
                              name=False,
                              **kwargs):
    '''function to take elastix point transform file and return anatomical locations of those points
    point_or_index=None/point/index: determines which transformix output to use: point is more accurate, index is pixel value(?)
    Elastix uses the xyz convention rather than the zyx numpy convention
    
    ###ASSUMES INPUT OF XYZ
    
    '''
    #####inputs
    assert type(trnsfrm_out_file) == str
    if point_or_index == None:
        point_or_index = 'OutputPoint'
    elif point_or_index == 'point':
        point_or_index = 'OutputPoint'
    elif point_or_index == 'index':
        point_or_index = 'OutputIndexFixed'
    try:  #check to see if pool processes have already been spawned
        p
    except NameError:
        p = mp.Pool(cores)

    kwargs = load_kwargs(**kwargs)
    vols = kwargs['volumes']
    reg_vol = [xx for xx in vols if xx.ch_type == 'regch'][0]

    ####load files
    id_table = pd.read_excel(
        os.path.join(kwargs['packagedirectory'], 'supp_files/id_table.xlsx')
    )  ##use for determining neuroanatomical locations according to allen
    ann = sitk.GetArrayFromImage(sitk.ReadImage(
        kwargs['annotationfile']))  ###zyx
    with open(trnsfrm_out_file, "rb") as f:
        lines = f.readlines()
        f.close()

    #####populate post-transformed array of contour centers
    sys.stdout.write('\n{} points detected'.format(len(lines)))
    arr = np.empty((len(lines), 3))
    for i in range(len(lines)):
        arr[i,
            ...] = lines[i].split()[lines[i].split().index(point_or_index) +
                                    3:lines[i].split().index(point_or_index) +
                                    6]  #x,y,z

    #optional save out of points
    np.save(kwargs['outputdirectory'] + '/injection/zyx_voxels.npy',
            np.asarray([(z, y, x) for x, y, z in arr]))

    pnts = transformed_pnts_to_allen_helper_func(arr, ann)
    pnt_lst = [xx for xx in pnts if xx != 0]
    if len(pnt_lst) == 0:
        raise ValueError('pnt_lst is empty')
    else:
        sys.stdout.write('\nlen of pnt_lst({})'.format(len(pnt_lst)))
    imstack = brain_structure_keeper(
        ann, True,
        *pnt_lst)  ###annotation file, true=to depict density, list of pnts
    df = count_structure_lister(id_table, *pnt_lst)
    #########save out imstack and df
    nametosave = '{}{}_{}'.format(name, ch, reg_vol.brainname)
    tifffile.imsave(
        os.path.join(kwargs['outputdirectory'],
                     nametosave + '_structure_density_map.tif'), imstack)
    excelfl = os.path.join(kwargs['outputdirectory'],
                           nametosave + '_stuctures_table.xlsx')
    df.to_excel(excelfl)
    print('file saved as: {}'.format(excelfl))
    try:
        p.terminate()
    except:
        1
    return
Beispiel #37
0
def pool_injections_for_analysis(**kwargs):
    
    inputlist = kwargs['inputlist']
    dst = kwargs['dst']; makedir(dst)
    injscale = kwargs['injectionscale'] if 'injectionscale' in kwargs else 1
    imagescale = kwargs['imagescale'] if 'imagescale' in kwargs else 1
    axes = kwargs['reorientation'] if 'reorientation' in kwargs else ('0','1','2')
    cmap = kwargs['colormap'] if 'colormap' in kwargs else 'plasma'
    id_table = kwargs['id_table'] if 'id_table' in kwargs else '/jukebox/temp_wang/pisano/Python/lightsheet/supp_files/allen_id_table.xlsx'
    save_tif = kwargs['save_tif'] if 'save_tif' in kwargs else False
    num_sites_to_keep = kwargs['num_sites_to_keep'] if 'num_sites_to_keep' in kwargs else 1
    nonzeros = []
    ann = sitk.GetArrayFromImage(sitk.ReadImage(kwargs['annotation']))
    if kwargs['crop']: ann = eval('ann{}'.format(kwargs['crop']))   
    allen_id_table=pd.read_excel(id_table)
    
    for i in range(len(inputlist)):
        impth = inputlist[i]
        animal = os.path.basename(os.path.dirname(os.path.dirname(os.path.dirname(impth))))
        
        print('\n\n_______\n{}'.format(animal))
        
        print('  loading:\n     {}'.format(animal))
        im = tifffile.imread(impth)
            
        if kwargs['crop']: im = eval('im{}'.format(kwargs['crop']))#; print im.shape
        
        #reorient to coronal?
        
        #segment
        arr = find_site(im, thresh=kwargs['threshold'], filter_kernel=kwargs['filter_kernel'], num_sites_to_keep=num_sites_to_keep)*injscale
        if save_tif: tifffile.imsave(os.path.join(dst,'{}'.format(os.path.dirname(impth))+'_inj.tif'), arr.astype('float32'))
        
        #optional 'save_individual'
        if kwargs['save_individual']:
            im = im*imagescale
            a=np.concatenate((np.max(im, axis=0), np.max(arr.astype('uint16'), axis=0)), axis=1)
            b=np.concatenate((np.fliplr(np.rot90(np.max(fix_orientation(im, axes=axes), axis=0),k=3)), np.fliplr(np.rot90(np.max(fix_orientation(arr.astype('uint16'), axes=axes), axis=0),k=3))), axis=1)
            plt.figure()
            plt.imshow(np.concatenate((b,a), axis=0), cmap=cmap, alpha=1);  plt.axis('off')
            plt.savefig(os.path.join(dst,'{}'.format(animal)+'.pdf'), dpi=300, transparent=True)
            plt.close()

        #cell counts to csv
        print('   finding nonzero pixels for voxel counts...')      
        nz = np.nonzero(arr)
        nonzeros.append(zip(*nz)) #<-for pooled image
        pos = transformed_pnts_to_allen_helper_func(np.asarray(zip(*[nz[2], nz[1], nz[0]])), ann)
        tdf = count_structure_lister(allen_id_table, *pos)
        if i == 0: 
            df = tdf.copy()
            countcol = 'count' if 'count' in df.columns else 'cell_count'
            df.drop([countcol], axis=1, inplace=True)
        df[animal] = tdf[countcol]
        
    df.to_csv(os.path.join(dst,'voxel_counts.csv'))
    print('\n\nCSV file of cell counts, saved as {}\n\n\n'.format(os.path.join(dst,'voxel_counts.csv')))  
            
    #condense nonzero pixels
    nzs = [str(x) for xx in nonzeros for x in xx] #this list has duplicates if two brains had the same voxel w label
    c = Counter(nzs)
    array = np.zeros(im.shape)
    print('Collecting nonzero pixels for pooled image...')
    tick = 0
    #generating pooled array where voxel value = total number of brains with that voxel as positive
    for k,v in c.iteritems():
        k = [int(xx) for xx in k.replace('(','').replace(')','').split(',')]
        array[k[0], k[1], k[2]] = int(v)
        tick+=1
        if tick % 50000 == 0: print('   {}'.format(tick))
        
    #load atlas and generate final figure
    print('Generating final figure...')      
    atlas = tifffile.imread(kwargs['atlas'])
    arr = fix_orientation(array, axes=axes)
    #cropping
    #if 'crop_atlas' not in kwargs:
    if kwargs['crop']: atlas = eval('atlas{}'.format(kwargs['crop']))
    atlas = fix_orientation(atlas, axes=axes)
    
    my_cmap = eval('plt.cm.{}(np.arange(plt.cm.RdBu.N))'.format(cmap))
    my_cmap[:1,:4] = 0.0  
    my_cmap = mpl.colors.ListedColormap(my_cmap)
    my_cmap.set_under('w')
    plt.figure()
    plt.imshow(np.max(atlas, axis=0), cmap='gray')
    plt.imshow(np.max(arr, axis=0), alpha=0.99, cmap=my_cmap); plt.colorbar(); plt.axis('off')
    dpi = int(kwargs['dpi']) if 'dpi' in kwargs else 300
    plt.savefig(os.path.join(dst,'heatmap.pdf'), dpi=dpi, transparent=True);
    plt.close()
    
    print('Saved as {}'.format(os.path.join(dst,'heatmap.pdf')))  
        
    return df
Beispiel #38
0
def savetiff(name, data):
    fdir = os.path.dirname(name)
    if not os.path.isdir(fdir):
        os.makedirs(fdir, exist_ok=True)
    skitiff.imsave(name, data)
Beispiel #39
0
def writeOmeTiff(outputPath, array, omexmlString):
    tifffile.imsave(outputPath,
                    array,
                    description=omexmlString,
                    metadata={'axes': 'TZCXY'})
Beispiel #40
0
# -*- coding: utf-8 -*-

import os, sys
from pydaily import filesystem
from skimage.external.tifffile import imsave

sys.path.insert(0, '.')
from kfb_io.io_image import patch_read_slide

if __name__ == "__main__":
	input_root = str(sys.argv[1])   # kfb folder
	save_root = str(sys.argv[2])    # tif folder

    if not os.path.exists(save_root):
        os.makedirs(save_root)
    kfb_files = filesystem.find_ext_files(input_root, "kfb")

	for ind, this_kfb_path in enumerate(kfb_files):
        print("Processing {}/{}".format(ind+1, len(kfb_files)))
	    img_name = os.path.basename(this_kfb_path)
	    img_name_noext = os.path.splitext(img_name)[0]

	    this_raw_data = patch_read_slide(this_kfb_path, level=1)
	    save_path = os.path.join(save_root, img_name_noext+'.tif')
	    imsave(save_path, this_raw_data, compress=9, bigtiff=True)
Beispiel #41
0
def build_hand_segmentation_iscat_testval():
    """Creates dataset of manually segmented iSCAT images for validation and testing"""

    OUT_PATH_CELL = DATA_PATH + 'hand_seg_iscat_cell/'
    os.makedirs(os.path.join(OUT_PATH_CELL, 'REF_FRAMES/'), exist_ok=True)
    os.makedirs(os.path.join(OUT_PATH_CELL, 'MASKS/'), exist_ok=True)

    OUT_PATH_PILI = DATA_PATH + 'hand_seg_iscat_pili/'
    os.makedirs(os.path.join(OUT_PATH_PILI, 'REF_FRAMES/'), exist_ok=True)
    os.makedirs(os.path.join(OUT_PATH_PILI, 'MASKS/'), exist_ok=True)

    ROOT_TEST_PATH = "data/hand-segmentation/"
    iscat_files = glob.glob(os.path.join(ROOT_TEST_PATH, 'iSCAT/*.tif'))
    cell_seg_files = glob.glob(os.path.join(ROOT_TEST_PATH, 'cell_seg/*.txt'))
    pili_seg_files = glob.glob(os.path.join(ROOT_TEST_PATH, 'pili_seg/*.txt'))

    iscat_files.sort()
    cell_seg_files.sort()
    pili_seg_files.sort()

    for i, (iscat, cell_seg, pili_seg) in enumerate(
            zip(iscat_files, cell_seg_files, pili_seg_files)):

        # Loading tirf and iSCAT images
        iscat_stack = tifffile.imread(iscat)

        # iSCAT preprocessing
        iscat_stack = processing.image_correction(iscat_stack)
        iscat_stack = processing.enhance_contrast(iscat_stack,
                                                  'stretching',
                                                  percentile=(1, 99))
        iscat_stack = processing.fft_filtering(iscat_stack, 1, 13, True)
        iscat_stack = processing.enhance_contrast(iscat_stack,
                                                  'stretching',
                                                  percentile=(3, 97))

        # Loading ground truth masks
        mask_cell = utilities.cell_mask_from_segmentation(cell_seg)
        mask_pili = utilities.pili_mask_from_segmentation(pili_seg)

        for j in range(0, iscat_stack.shape[0], 8):
            print("\rSaving to stack_{}_{}.png".format(i + 1, j + 1),
                  end=' ' * 5)
            tifffile.imsave(
                os.path.join(OUT_PATH_CELL, 'REF_FRAMES/',
                             "stack_{}_{}.png".format(i + 1, j + 1)),
                rescale(iscat_stack[j]))
            tifffile.imsave(
                os.path.join(OUT_PATH_CELL, 'MASKS/',
                             "mask_{}_{}.png".format(i + 1, j + 1)),
                mask_cell[j // 2].astype('uint8'))

        print('')
        for j in range(iscat_stack.shape[0]):
            if not (mask_pili != 0).any(): continue

            print("\rSaving to stack_{}_{}.png".format(i + 1, j + 1),
                  end=' ' * 5)
            tifffile.imsave(
                os.path.join(OUT_PATH_PILI, 'REF_FRAMES/',
                             "stack_{}_{}.png".format(i + 1, j + 1)),
                rescale(iscat_stack[j]))
            tifffile.imsave(
                os.path.join(OUT_PATH_PILI, 'MASKS/',
                             "mask_{}_{}.png".format(i + 1, j + 1)),
                mask_pili[j].astype('uint8'))

        print('')
                  "a") as txt:
            txt.write("Allen Atlas CCF coordinates (in zyx):\n%s" % zyx_rois)

        #atlas (horizontal)
        atl = tifffile.imread(
            "/jukebox/LightSheetData/witten-mouse/atlas/average_template_25_sagittal_forDVscans.tif"
        )
        atl = np.transpose(atl, [2, 1, 0])
        atl_cnn = np.zeros_like(atl)

        for i in range(zyx_rois.shape[0]):
            atl_cnn[zyx_rois[i][0], zyx_rois[i][1], zyx_rois[i][2]] = 1

        merged = np.stack([atl, atl_cnn, np.zeros_like(atl)], -1)
        tifffile.imsave(
            os.path.join(
                dst, "{}_ROI_merged_to_Allen_horizontal.tif".format(brain)),
            merged)

        coronal = np.transpose(merged, [1, 0, 2, 3])  #make coronal sections

        #save out coronal sections - based on the fact that you click 5 points in each site in HORIZONTAL sectionss
        tifffile.imsave(
            os.path.join(dst,
                         "{}_ROI_merged_to_Allen_coronal.tif".format(brain)),
            coronal)

        #doing a max projection, in case you just want to look at that
        maxip = np.max(coronal, 0)

        alpha = 0.6  #determines transparency, don"t need to alter
        cmap = matplotlib.colors.LinearSegmentedColormap.from_list(
Beispiel #43
0
from skimage.external.tifffile import imsave, imread
import os

result_dir = "../../../data/CycleGAN-data/result_mayo_blur_gaussian/128_longskip_mstd_r9/128_longskip_mstd_r9/test_latest/FakeClean/"

result_list = sorted(os.listdir(result_dir))

for i in range(len(result_list)):
    im = imread(result_dir + result_list[i])
    im[im < 0] = 0
    im[im > 1] = 1
    print(result_dir + result_list[i])
    imsave(result_dir + result_list[i], im)
Beispiel #44
0
def overlay_qc(args):  
    #unpacking this way for multiprocessing
    fld, folder_suffix, output_folder, verbose, doubletransform, make_volumes = args
    try:
        #get 3dunet cell dataframe csv file
        input_csv = listdirfull(os.path.join(fld, folder_suffix), ".csv")
        assert len(input_csv) == 1, "multiple csv files"
        dataframe = pd.read_csv(input_csv[0])
        
        #location to save out
        dst = os.path.join(output_folder, os.path.basename(fld)); makedir(dst)
    
        #EXAMPLE USING LIGHTSHEET - assumes marking centers in the "raw" full sized cell channel. This will transform those 
        #centers into "atlas" space (in this case the moving image)
        #in this case the "inverse transform has the atlas as the moving image in the first step, 
        #and the autofluorescence channel as the moving image in the second step 
        #NOTE - it seems that the registration of cell to auto is failing on occasion....thus get new files...
        ################################
        cell_inverse_folder = listdirfull(os.path.join(fld, "elastix_inverse_transform"), "cellch")[0]
        a2r = listall(cell_inverse_folder, "atlas2reg_TransformParameters"); a2r.sort()
        r2s = listall(cell_inverse_folder, "reg2sig_TransformParameters"); r2s.sort() #possibly remove

        #IMPORTANT. the idea is to apply cfos->auto->atlas
        transformfiles = r2s + a2r if doubletransform else a2r #might get rid of r2s
    
        lightsheet_parameter_dictionary = os.path.join(fld, "param_dict.p")
            
        converted_points = generate_transformed_cellcount(dataframe, dst, transformfiles, 
                                                          lightsheet_parameter_dictionary, verbose=verbose)
    
        #load and convert to single voxel loc
        zyx = np.asarray([str((int(xx[0]), int(xx[1]), int(xx[2]))) for xx in np.nan_to_num(np.load(converted_points))])
        from collections import Counter
        zyx_cnt = Counter(zyx)
        
        #check...
        if make_volumes:
            #manually call transformix
            kwargs = load_dictionary(lightsheet_parameter_dictionary)
            vol = [xx for xx in kwargs["volumes"] if xx.ch_type == "cellch"][0].resampled_for_elastix_vol
            transformed_vol = os.path.join(dst, "transformed_volume"); makedir(transformed_vol)
            if not doubletransform:
                transformfiles = [os.path.join(fld, "elastix/TransformParameters.0.txt"), os.path.join(fld, 
                                  "elastix/TransformParameters.1.txt")]
                transformfiles = modify_transform_files(transformfiles, transformed_vol) #copy over elastix files
                transformix_command_line_call(vol, transformed_vol, transformfiles[-1])
            else:
                v=[xx for xx in kwargs["volumes"] if xx.ch_type == "cellch"][0]
                #sig to reg
                tps = [listall(os.path.dirname(v.ch_to_reg_to_atlas), "/TransformParameters.0")[0], 
                       listall(os.path.dirname(v.ch_to_reg_to_atlas), "/TransformParameters.1")[0]]
                #reg to atlas
                transformfiles = tps+[os.path.join(fld, "elastix/TransformParameters.0.txt"), 
                                      os.path.join(fld, "elastix/TransformParameters.1.txt")]
                transformfiles = modify_transform_files(transformfiles, transformed_vol) #copy over elastix files
                transformix_command_line_call(vol, transformed_vol, transformfiles[-1])
            

            #cell_registered channel
            cell_reg = tifffile.imread(os.path.join(transformed_vol, "result.tif"))
            tifffile.imsave(os.path.join(transformed_vol, "result.tif"), cell_reg, compress=1)
            cell_cnn = np.zeros_like(cell_reg)
            tarr = []; badlist=[]
            for zyx,v in zyx_cnt.items():
                z,y,x = [int(xx) for xx in zyx.replace("(","",).replace(")","").split(",")]
                tarr.append([z,y,x])
                try:
                    cell_cnn[z,y,x] = v*100
                except:
                    badlist.append([z,y,x])
                    
            #apply x y dilation
            r = 2
            selem = ball(r)[int(r/2)]
            cell_cnn = cell_cnn.astype("uint8")
            cell_cnn = np.asarray([cv2.dilate(cell_cnn[i], selem, iterations = 1) for i in range(cell_cnn.shape[0])])
            
            tarr=np.asarray(tarr)
            if len(badlist)>0: 
                print("{} errors in mapping with cell_cnn shape {}, each max dim {}, \npossibly due to a registration overshoot \
                      or not using double transform\n\n{}".format(len(badlist), cell_cnn.shape, np.max(tarr,0), badlist))
            merged = np.stack([cell_cnn, cell_reg, np.zeros_like(cell_reg)], -1)
            tifffile.imsave(os.path.join(transformed_vol, "merged.tif"), merged)#, compress=1)
            #out = np.concatenate([cell_cnn, cell_reg, ], 0)
        
        #####check at the resampled for elastix phase before transform...this mapping looks good...
        if make_volumes:
            #make zyx numpy arry
            zyx = dataframe[["z","y","x"]].values
            kwargs = load_dictionary(lightsheet_parameter_dictionary)
            vol = [xx for xx in kwargs["volumes"] if xx.ch_type =="cellch"][0]
            fullsizedimensions = get_fullsizedims_from_kwargs(kwargs) #don"t get from kwargs["volumes"][0].fullsizedimensions it"s bad! use this instead
            zyx = fix_contour_orientation(zyx, verbose=verbose, **kwargs) #now in orientation of resample
            zyx = points_resample(zyx, original_dims = fix_dimension_orientation(fullsizedimensions, **kwargs), 
                                  resample_dims = tifffile.imread(vol.resampled_for_elastix_vol).shape, verbose = verbose)[:, :3]
            
            #cell channel
            cell_ch = tifffile.imread(vol.resampled_for_elastix_vol)
            cell_cnn = np.zeros_like(cell_ch)
            tarr = []; badlist=[]
            for _zyx in zyx:
                z,y,x = [int(xx) for xx in _zyx]
                tarr.append([z,y,x])
                try:
                    cell_cnn[z,y,x] = 100
                except:
                    badlist.append([z,y,x])
            tarr=np.asarray(tarr)        
            merged = np.stack([cell_cnn, cell_ch, np.zeros_like(cell_ch)], -1)
            tifffile.imsave(os.path.join(transformed_vol, "resampled_merged.tif"), merged)#, compress=1)
            
    except Exception as e:
        print(e)
        with open(error_file, "a") as err_fl:
            err_fl.write("\n\n{} {}\n\n".format(fld, e))
def save_tiff(path, np_image):
    imsave(path, np_image)
    print("{} save".format(path))
Beispiel #46
0
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)
Beispiel #47
0
def record(model, class_indices):
    #valdir = os.path.join(args.data, 'val')
    #val_data = MSdata(image_dir=valdir, resize_height=max(input_size), resize_width=max(input_size))
    #val_loader = DataLoader(dataset=val_data, batch_size=args.batch_size, shuffle=False)
    #for i, (input, target) in enumerate(val_loader):

    class_name = list(class_indices.keys())
    data_name = os.path.basename(args.data)
    ads_path = os.path.join(os.path.dirname(args.data), 'AEs', data_name,
                            args.arch, args.tasks, args.attack_type)
    ads_record = open(
        os.path.join(
            ads_path, '{}_{}_{}_{}.txt'.format(data_name, args.arch,
                                               args.tasks, args.attack_type)),
        'w')

    file_path = os.path.join(args.data, args.tasks)
    files = get_fils(file_path)

    mean = np.array([
        1353.036, 1116.468, 1041.475, 945.344, 1198.498, 2004.878, 2376.699,
        2303.738, 732.957, 12.092, 1818.820, 1116.271, 2602.579
    ])
    mean = mean / mean.max()
    std = np.array([
        65.479, 154.008, 187.997, 278.508, 228.122, 356.598, 456.035, 531.570,
        98.947, 1.188, 378.993, 303.851, 503.181
    ])
    std = std / std.max()

    preprocessing = dict(mean=mean, std=std, axis=-3)
    fmodel = foolbox.models.PyTorchModel(model,
                                         bounds=(0, 1),
                                         num_classes=len(class_name),
                                         preprocessing=preprocessing)
    attack = ad_type(fmodel, args.attack_type)

    for batch_files in yield_mb(files, args.batch_size, shuffle=False):

        categorical_label_from_full_file_name(batch_files, class_indices)
        images, labels = data_generator(batch_files, model.input_size[1:],
                                        class_indices)
        labels = np.argmax(labels, axis=1)
        #print(images.shape, labels.shape)
        cfds = fmodel.forward(images)

        cfds = softmax(cfds, axis=1)

        adversarials = attack(images, labels)
        ads_cfds = fmodel.forward(adversarials)
        ads_cfds = softmax(ads_cfds, axis=1)

        for i in range(args.batch_size):
            _class = batch_files[i].split('/')[-2]
            file_name = os.path.basename(batch_files[i]).split('.')[-2]
            model_idx = cfds[i].argmax(-1)
            model_cla = class_name[model_idx]
            model_cfs = cfds[i].max() * 100
            model_flg = (model_idx == labels[i])

            ads_idx = ads_cfds[i].argmax(-1)
            ads_cla = class_name[ads_idx]
            ads_cfs = ads_cfds[i].max() * 100
            ads_flg = bool(1 - (ads_idx == labels[i]))

            ads_record.write(
                "{_class}+{file_name}+{model_cfs:.2f}+{ads_cla}+{ads_cfs:.2f}.tif,{_class},{model_cla},{model_idx},{model_cfs:.2f},{model_flg},{ads_cla},{ads_idx},{ads_cfs:.2f},{ads_flg}\n"
                .format(_class=_class,
                        file_name=file_name,
                        model_idx=model_idx,
                        model_cla=model_cla,
                        model_cfs=model_cfs,
                        model_flg=model_flg,
                        ads_idx=ads_idx,
                        ads_cla=ads_cla,
                        ads_cfs=ads_cfs,
                        ads_flg=ads_flg))

            if model_flg and ads_flg:
                image_path = os.path.join(ads_path, _class)
                imsave(
                    "{image_path}/{_class}+{file_name}+{model_cfs:.2f}+{ads_cla}+{ads_cfs:.2f}.tif"
                    .format(image_path=image_path,
                            _class=_class,
                            file_name=file_name,
                            model_cfs=model_cfs,
                            ads_cla=ads_cla,
                            ads_cfs=ads_cfs),
                    img_as_ubyte(np.transpose(adversarials[i], (1, 2, 0))))
Beispiel #48
0
binary_global = img > global_thresh

block_size = 40

# True False binary matrix represent color value of the img using adaptive thresholding
binary_adaptive = threshold_adaptive(img, block_size, offset=0)

# 0 1 binary matrix
img_bin_global = clear_border(img_as_uint(binary_global))

# 0 1 binary matrix 
img_bin_adaptive = clear_border(img_as_uint(binary_adaptive))

savedImg = img_as_float(binary_adaptive)

imsave('../pics/result.tif', img_as_uint(binary_adaptive))


bin_pos_mat = ocr.binary_matrix_to_position(binary_adaptive)


fig, axes = plt.subplots(nrows=3, figsize=(7, 8))
ax0, ax1, ax2 = axes
figure(1)
subplot(311)
imshow(image)
subplot(312)
scatter(bin_pos_mat[:,1], bin_pos_mat[:,0])
# imshow(np.flipud(clustered))
subplot(313)
imshow(binary_adaptive)