def contrast_stretch(): img = data.moon() p2, p98 = np.percentile(img, (2, 58)) #img2 = exposure.rescale_intesity(img, in_range=(p2,p98)) img2 = (img.astype(np.float32) - p2) * 255 / (p98 - p2) img2[img2 < 0] = 0 img2[img2 > 255] = 255 img2 = img2.astype(np.uint8) fig, (ax, ax2) = plt.subplots(1, 2) ax.imshow(img, cmap="gray") ax2.imshow(img2, cmap="gray") #Display_histogram img2 = img_as_float32(img2) img = img_as_float32(img) fig, ax = plt.subplots() #img.ravel() -> splaszczenie obrazu wielowymiarowego ax.hist(img2.ravel(), bins=256, histtype="bar", color='blue') ax.ticklabel_format(axis='y', style='scientific', scilimits=(0, 0)) ax.set_xlim(0, 1) ax.grid(True) #dystrybuatna fig, ax = plt.subplots() cdf, bins = exposure.cumulative_distribution(img2, 256) ax.plot(bins, cdf, 'r') ax.grid(True)
def generate_mov2art(img_mov, verbose=True, radius_max=60, use_normal=True): """Generate geometric augmentation and its inverse.""" shape = img_mov.shape img_mov_float = img_as_float32(img_mov) edge_mask = canny(img_mov_float) if use_normal: c = np.random.normal(0.7, 0.3) else: c = np.random.random() if verbose: print("Scalar: {}".format(c)) mov2art = c * DisplacementField.generate( shape, approach="edge_stretching", edge_mask=edge_mask, interpolation_method="rbf", interpolator_kwargs={"function": "linear"}, n_perturbation_points=6, radius_max=radius_max, ) return mov2art
def _imagesProcessing(self, tif): """ Process each images of the stack contained in one .tif file. Warning data type : https://scikit-image.org/docs/dev/user_guide/data_types.html#data-types """ tif32 = util.img_as_float32(tif) N = tif32.shape[0] tifAvg = None imCount = 0 for image in tif32: im = ndimage.median_filter( image, self.filterSize ) #filters.median(image, np.ones(self.filterSize)) # #Facultactive rescaling # try: # im = transform.rescale(im, self.rescaleRatio, anti_aliasing=True) # except: # print 'failed rescale' if tifAvg is not None: tifAvg += im / N else: h, w = im.shape tifAvg = np.ones((h, w), np.float32) #Should we really use ones ? tifAvg += im / N imCount += 1 return tifAvg
def read_image(path): try: img = io.imread(path) return (transform.rescale(util.img_as_float32(img), 0.02, multichannel=True).reshape(-1), path) except: return (None, path)
def img_grayscale_float(img_grayscale_uint): """Generate a float32 version of the grayscale image.""" img_out = img_as_float32(img_grayscale_uint, force_copy=True) assert img_out.ndim == 2 assert img_out.dtype == np.float32 assert np.all(img_out >= 0) and np.all(img_out <= 1) return img_out
def load_image_and_blur(filename): image = cv2.imread(filename.decode(), 0) image = dilation(image) # [0,0,255,0,0] => [0,255,255,255,0] image = dilation(image) image = img_as_float32(image) image = cv2.resize(image, (56, 56)) image = cv2.GaussianBlur(image, (5, 5), 0) # Blur image image = image[:, :, np.newaxis] # TF insists on 3rd dimension. return image
def __call__(self, image, target=None): size, im_scale = self.get_size(image.shape[:2]) image = util.img_as_float32(T.resize(image, size)) if target is None: return image target = target.resize(image.shape[:2]) # target.im_scale = im_scale target.add_field("scale", im_scale) return image, target
def process(pth): print(f'\nProcessing {pth}') save_pth = pth / 'reg_stacks' #tmat_pth = pth / 'transformation_matrices' try: save_pth.mkdir() #tmat_pth.mkdir() except FileExistsError: ex('Save File for reg stacks or tmats already exists. Delete and re-run.' ) #tell pystack reg that we will use a translational transformation #there shouldn't be intra-volume rotation or shear (there might be for rod blink) sr = StackReg(StackReg.TRANSLATION) #register to the first slice and output the transfomation matrix without transforming #iterate through the files in the stacks folder files = pth.glob('*.tif') loop_starts = time.time() for i, file in enumerate(files): #start_time = time.time() print(f'Processing: {file}') #Intravolume registration of the fixed volume #load first stack and do a 3d gaussian blur with a sigma=1 #str needed for imread, otherwise only one frame is loaded fixed = io.imread(str(file)) #had gauss(), testing t_mats = sr.register_stack(gauss(fixed), reference='first', n_frames=1) #remove the x shift from all the matrices - horizontal movement isn't relevant here, #the volume should be acquired quickly enough that this isn't a problem. t_mats[:, 0, -1] = 0 fixed = sr.transform_stack(fixed, tmats=t_mats) #Using previous to see if I could get rid of wigge. Didn't seem to work. #t_mats = sr.register_stack(gauss(fixed), reference='previous') #t_mats[:,1,-1] = 0 #fixed = sr.transform_stack(fixed, tmats=t_mats) #save the register fixed volume in the parent directory for reference save_name = save_pth / f'reg_{file.name}' #io.imsave(arr=img_as_uint(fixed), fname=str(save_name)) io.imsave(arr=img_as_float32(fixed), fname=str(save_name)) #get fixed out of memory - may not be worth the time? print(f'Intravolume registration complete. File saved at {save_name}') #end_time = time.time() #print(f'{file} was processed in {(end_time - start_time):.2f}s. \ #\n{((end_time - loop_starts)/60):.2f} minutes have elapsed.') #de;ete emumerate #if i==4: #ex('auto break') end_time = time.time() print(f'Run took {(end_time-loop_starts)/60:.2f} minutes')
def to_pytorch_from_uint8(img): """ Convert from uint8 images, with standard dimension order of [h,w,c] To PyTorch format, float32, dimension order of [c,h,w] """ order = (2, 0, 1) img = img_as_float32(img) # convert from uint8 to float 32 img = np.transpose(img, order) return img
def copy_image(path): Path(os.path.join(target_dir, os.path.split(path)[0])).mkdir(parents=True, exist_ok=True) img = io.imread(os.path.join(datapath, path)) io.imsave( os.path.join(target_dir, os.path.splitext(path)[0] + '.png'), util.img_as_ubyte( transform.rescale(util.img_as_float32(img), 0.1, multichannel=True)))
def __data_generation(self, batch_filenames): """Data generation method Parameters ---------- batch_filenames : list List of strings containing filenames to read. Note that, for each noisy image filename there must be a clean image with same filename. Returns ------- noisy_batch : :class:`numpy.ndarray` Batch of noisy images. clean_batch : :class:`numpy.ndarray` Batch of reference images. """ # Noised image and ground truth initialization inp_batch = [] ref_batch = [] for filename in batch_filenames: filepath = os.path.join(self.path, 'ref', filename) ref = imread(filepath) ref = img_as_float32(ref) if ref.ndim == 3 and ref.shape[-1] == 3 and self.n_channels == 1: # Converts RGB to Gray ref = rgb2gray(ref) if ref.ndim == 2 and self.n_channels == 1: # Expand last dim if image is grayscale ref = np.expand_dims(ref, axis=-1) elif ref.ndim == 2 and self.n_channels == 3: raise ValueError( "Expected RGB image but got Grayscale (image shape: {})". format(ref.shape)) inp = ref.copy() for noise_function, noise_arg in zip(self.noise_functions, self.noise_args): # Adds noise to the reference. inp = noise_function(inp, *noise_arg) # Applies preprocessing functions in order for func in self.preprocessing: inp, ref = func(inp, ref) ref_batch.append(ref) inp_batch.append(inp) inp_batch = np.stack(inp_batch) ref_batch = np.stack(ref_batch) if len(inp_batch.shape) > 4: inp_batch = inp_batch.reshape([-1, *inp_batch.shape[2:]]) ref_batch = ref_batch.reshape([-1, *ref_batch.shape[2:]]) return inp_batch, ref_batch
def plt_fnc(indx=77308, resize=False): plt.clf() img = io.imread( os.path.join( r'Z:\ftp\sprayers\IntelligentSprayTechnology\Connor_Field_Data\2019_ImageLibrary_FieldLogs_Motec', os.path.splitext(fn_time_crop_list[indx][0])[0] + '.bmp')) if resize: img = util.img_as_ubyte( transform.rescale(util.img_as_float32(img), 0.1, multichannel=True)) plt.imshow(img) return img
def load_dataset_images(root): gt, bl = list_dataset_images(root) for i, f in enumerate(bl): logger.debug("reading '{}'".format(f)) I = imageio.imread(f) if I.ndim == 3: I = rgb2gray(I) I = img_as_float32(I) bl[i] = I if gt is not None: gt = imageio.imread(gt) if gt.ndim == 3: gt = rgb2gray(gt) gt = img_as_float32(gt) # sanity check s_gt = gt.shape if any([im.shape != s_gt for im in bl]): raise ValueError("blurred image has a different size") return gt, bl
def test_noise(ntype, fname): img = io.imread(fname) img = img_as_float32(img) img2 = add_noise(ntype, img) fig, (ax, ax2) = plt.subplots(1, 2) ax.imshow(img, cmap="gray") ax.set_title('original') ax2.imshow(img2, cmap="gray") ax2.set_title('noisy') ax.axis('off') ax2.axis('off') fig.tight_layout() plt.show(block=False)
def main(): source = askdirectory() if source == '': ex("\n\nExited: No file path selected\n\n") #sorting(Path(os.path.abspath(source))) src = Path(source) stack = im_open(src) avg_stack = timeseries(stack) save_pth = src / 'timeseries' save_pth.mkdir() io.imsave(arr=img_as_float32(avg_stack), fname=str(save_pth / 'timeseries.tif')) print('\n\n\n\t\t\t\t---------\n\t\t\t\tCompleted\n\t\t\t\t---------')
def test_optic_flow(frame1, frame2): # im1 = img_as_ubyte(frame1) # im2 = img_as_ubyte(frame2) im1 = cv2.imread('im1.png') im2 = cv2.imread('im2.png') frame1 = img_as_float32(im1) frame2 = img_as_float32(im2) prvs = cv2.cvtColor(im1, cv2.COLOR_BGR2GRAY) next = cv2.cvtColor(im2, cv2.COLOR_BGR2GRAY) flow = cv2.calcOpticalFlowFarneback(prvs, next, None, 0.5, 3, 15, 3, 5, 1.2, 0) flow[..., 0] /= flow.shape[1] / 2 flow[..., 1] /= flow.shape[0] / 2 flow *= -1 for i in range(flow.shape[0]): for j in range(flow.shape[1]): flow[i, j, 0] += (j / flow.shape[1] * 2 - 1) flow[i, j, 1] += (i / flow.shape[0] * 2 - 1) print(flow.shape) torch_frame1 = torch.unsqueeze(torch.tensor(frame1).permute(2, 0, 1), 0) # print(frame1.shape) # print(torch_frame1.shape) # print(torch_frame1) flow = flow.astype(np.float32, copy=False) est_frame2 = func.grid_sample(torch_frame1, torch.unsqueeze(torch.tensor(flow), 0)) res_img = img_as_ubyte(est_frame2[0].permute(1, 2, 0).numpy()) cv2.imwrite('est_frame2.png', res_img) # flow_len = np.expand_dims(np.sqrt((flow[...,0]**2 + flow[...,1]**2)), 2) # flow /= flow_len # print(flow) pass exit(0)
def run(params): RTimageLocation = params['inputRTImagePath'] GTimageLocation = params['inputGTImagePath'] resultLocation = params['resultPath'] resultLocationAdj = params['resultPathAdj'] # Checking existence of temporary files (individual channels) if not os.path.exists(RTimageLocation): print(f'Error: {RTimageLocation} does not exist') return; if not os.path.exists(GTimageLocation): print(f'Error: {GTimageLocation} does not exist') return; # Loading input images RTData = imread(RTimageLocation) GTData = imread(GTimageLocation) print(f'Dimensions of Restored image: {RTData.shape}') print(f'Dimensions of GT image: {GTData.shape}') # Histogram matching matched_GTData = match_histograms(GTData, RTData).astype(RTData.dtype) # MSE measurement # valMSE = skimage.measure.compare_mse(RTData, GTData) # deprecated in scikit-image 0.18 valMSE = mean_squared_error(RTData, matched_GTData) print(f'___ MSE = {valMSE} ___') # Value appears in the log if Verbosity option is set to 'Everything' # SSIM measurement outFullSSIM = structural_similarity(RTData, matched_GTData, full=True) # Extracting mean value (first item) outMeanSSIM = outFullSSIM[0] print(f'___ Mean SSIM = {outMeanSSIM} ___') # Extracting map (second item) outSSIM = outFullSSIM[1] print(f'Bit depth of SSIM array: {outSSIM.dtype}') # Convert output array whose range is [0-1] to adjusted bit range (8- or 16-bit) if RTData.dtype is np.dtype('u2'): outputData = img_as_uint(outSSIM) elif RTData.dtype is np.dtype('f4'): outputData = img_as_float32(outSSIM) # necessary? else: outputData = img_as_ubyte(outSSIM) imsave(resultLocation, outputData) imsave(resultLocationAdj, matched_GTData)
def align_with(image, ref_matrix, ref_file): """ Given a FITS file it will open the file and align to the reference image matrix and rewrite the file. It uses the astroalign package that align stellar astronomical images with an 3 point matching (triangle). It need above about 10 stellar sources in an image (based on the tests). # This function takes the matrix directly (instead of path to file) because of performance. This function in meant to be used within a loop, with this the ref_matrix needs to be loaded just once. Parameters ---------- image : str Path to image to align with the reference. ref_matrix : Numpy 2D array Reference image. ref_name : str Name of reference FITS file. Returns ------- None. File transformation: Re-write FITS file pointed at image variable with updated header. """ # Loading data = fits.getdata(image) data = img_as_float32(data) # Converting to float to avoid scikitimage bug # Issue #4525 header = fits.getheader(image) new_image = "a" + image # Aligning aligned_image = astroalign.register(data, ref_matrix) # Re-write file and update header header["ALIGNED-TO"] = ref_file fits.writeto(new_image, aligned_image, header) os.remove(image)
def __data_generation(self, batch_filenames): """Data generation method Parameters ---------- batch_filenames : list List of strings containing filenames to read. Returns ------- noisy_batch : :class:`numpy.ndarray` Batch of noisy images. """ # Noised image and ground truth initialization inp_batch = [] ref_batch = [] for filename in batch_filenames: filepath = os.path.join(self.path, 'in', filename) module_logger.debug("Loading image located on {}".format(filepath)) inp = imread(filepath) inp = img_as_float32(inp) if inp.ndim == 3 and inp.shape[-1] == 3 and self.n_channels == 1: # Converts RGB to Gray inp = rgb2gray(inp) if inp.ndim == 2 and self.n_channels == 1: # Expand last dim if image is grayscale inp = np.expand_dims(inp, axis=-1) elif inp.ndim == 2 and self.n_channels == 3: raise ValueError( "Expected RGB image but got Grayscale (image shape: {})". format(inp.shape)) for func in self.preprocessing: # Preprocessing pipeline inp = func(inp) # Generates target from input inp, ref = self.target_fcn(inp) ref_batch.append(ref) inp_batch.append(inp) inp_batch = np.array(inp_batch) ref_batch = np.array(ref_batch) module_logger.debug("Data shape: {}".format(inp_batch.shape)) return inp_batch, ref_batch
def align_all_images(images_folder, ref_file=None): """ Align all FITS stellar images to reference file. If reference file is set to None it uses the first image in the folder. # Wraps align_with function. Parameters ---------- images_folder : str Path to folder with images to align. ref_file : str Path to FITS with reference field. Default is None, so it takes the first file of the folder. Returns ------- None. File transformation ------------------- Re-write FITS files with aligned version. """ os.chdir(images_folder) images = glob("*.fits") images.sort() if ref_file == None: ref_file = images[0] ref_image = img_as_float32(fits.getdata(ref_file)) N = len(images) print( f"Aligning {N} images with file {ref_file} in folder {images_folder}.\n" ) for i, im in enumerate(images, start=1): print(f"Aligning: {im} ({i} of {N}).") align_with(im, ref_image, ref_file) print(f"\n Finished alignment of {images_folder} images.") os.chdir("../")
def quilt(filenames, block_size, num_block, mode, sequence=False): textures = np.stack( [util.img_as_float32(Image.open(path)) for path in filenames]) if textures.ndim < 4: textures = np.expand_dims(textures, -1) overlap = block_size // 4 num_blockHigh, num_blockWide = num_block h = (num_blockHigh * block_size) - (num_blockHigh - 1) * overlap w = (num_blockWide * block_size) - (num_blockWide - 1) * overlap c = textures[0].shape[2] res = np.zeros((h, w, c)) for i in range(num_blockHigh): print(f'{i}/{num_blockHigh}') for j in range(num_blockWide): # print(i, j) # print(f'{i * num_blockHigh + j}/{num_blockHigh * num_blockWide}') y = i * (block_size - overlap) x = j * (block_size - overlap) if i == 0 and j == 0 or mode == "Random": patch = textures[np.random.randint(0, len(textures) ), :block_size, :block_size] elif mode == "Best": patch = randomBestPatch(textures, block_size, overlap, res, y, x) elif mode == "Cut": patch = randomBestPatch(textures, block_size, overlap, res, y, x) patch = minCutPatch(patch, block_size, overlap, res, y, x) res[y:y + block_size, x:x + block_size] = patch print(res.shape, res.min(), res.max()) if c == 1: res = res.squeeze(-1) image = Image.fromarray((res * 255).astype(np.uint8)) return image
def predict(self, images, object_extreme_points, torch_device=None, batch_size=4, num_workers=0): """ Predict DEXTR masks for objects identified in images by extreme points. :param images: a list of N images; images can be PIL Images or NumPy arrays :param object_extreme_points: extreme points for each object/image as an array of `(N, 4, [y,x])` NumPy arrays :param torch_device: PyTorch device used :param batch_size: batch size used (relevant when using a large number of images) :param num_workers: number of background processes used by the data pipeline :return: mask for each image in images, where each mask is a NumPy array """ if torch_device is None: torch_device = next(self.net.parameters()).device ds = _DextrInferenceDataset(images, object_extreme_points, transform=self.__inference_transforms) loader = torch.utils.data.DataLoader(ds, batch_size=batch_size, num_workers=num_workers) sample_i = 0 predictions = [] with torch.no_grad(): for batch in loader: input = batch['input'].to(torch_device) crop_yx = batch['crop_yx'].detach().cpu().numpy() pred_logits = self.net(input)['out'] pred_prob = torch.sigmoid(pred_logits).detach().cpu().numpy() for i in range(len(crop_yx)): image_size = ds.image_sizes[sample_i] pred_pil = dextr_transforms.paste_mask_into_image( image_size, pred_prob[i, 0, :, :], crop_yx[i]) pred_pil_arr = img_as_float32(np.array(pred_pil)) predictions.append(pred_pil_arr) sample_i += 1 return predictions
def nissl_volume(path=None): """Output a dataset created of 528 consecutive coronal slices with Nissl staining. Parameters ---------- path : str or None or LocalPath An absolute path to the underlying .npy file. If not speficied then a default one used. Returns ------- x_atlas : np.ndarray An array of shape (528, 320, 456, 1) representing the consecutive coronal slices. The dtype is np.float32 """ path = path or (GLOBAL_CACHE_FOLDER / "nissl.npy") atlas_volume = np.load(str(path)).astype( "uint8") # saved as float but actually just integers atlas_volume_float = np.array([ img_as_float32(slc) for slc in atlas_volume ]) # deals with scaling too! return atlas_volume_float[:, :, :, np.newaxis]
def lowpass_filter(dname, fname): fname = dname + fname img = io.imread(fname) img = img_as_float32(img) img = add_noise("s&p", img) if img.ndim > 2: img = color.rgb2gray(img) #sigma -> jak szybko gasna #mode reflect -> odbija sie symetrycznie na 2 strone #granice obrazu sa odbiciem symetrycznym #imflt.gaussian - > inne pixele gasna odnosnie odleglosci od srodka pixela img = imflt.gaussian(img, sigma=2, mode='reflect') #img2 = imflt.median(img,mph.disk(2)) fig, (ax, ax2) = plt.subplots(1, 2) ax.imshow(img, cmap="gray") ax.set_title('original') ax2.imshow(img2, cmap="gray") ax2.set_title('noisy') ax.axis('off') ax2.axis('off') fig.tight_layout() plt.show(block=False)
def test_rgba2rgb_dtype(self): rgba = self.img_rgba.astype('float64') rgba32 = img_as_float32(rgba) assert rgba2rgb(rgba).dtype == rgba.dtype assert rgba2rgb(rgba32).dtype == rgba32.dtype
def test_rgb2hsv_dtype(self): rgb = img_as_float(self.img_rgb) rgb32 = img_as_float32(self.img_rgb) assert rgb2hsv(rgb).dtype == rgb.dtype assert rgb2hsv(rgb32).dtype == rgb32.dtype
def main( load_name: Param("load learner name", str) = "em_save", save_dir: Param("dir to save to:", str) = "/scratch/bpho/results/emsynth_crap", gpu: Param("GPU to run on", str) = 0, ): torch.cuda.set_device(gpu) bs = 1 size = 1920 data = get_data(bs, size) arch = models.resnet34 wd = 1e-3 learn = unet_learner(data, arch, wd=wd, loss_func=feat_loss, metrics=superres_metrics, callback_fns=LossMetrics, blur=True, norm_type=NormType.Weight, model_dir=model_path) gc.collect() learn = learn.load(load_name) test_files = Path( '/scratch/bpho/datasources/EM_manually_aquired_pairs_01242019/') test_hr = list((test_files / 'aligned_hr').glob('*.tif')) test_lr = list((test_files / 'aligned_lr').glob('*.tif')) results = Path(save_dir) if results.exists(): shutil.rmtree(results) results.mkdir(parents=True, mode=0o775, exist_ok=True) def get_key(fn): return fn.stem[0:(fn.stem.find('Region') - 1)] hr_map = {get_key(fn): fn for fn in test_hr} lr_map = {get_key(fn): fn for fn in test_lr} ssims = [] psnrs = [] for k in progress_bar(hr_map): hr_fn, lr_fn = hr_map[k], lr_map[k] hr_img = PIL.Image.open(hr_fn) lr_img = PIL.Image.open(lr_fn) lr_img_data = img_as_float32(lr_img) lr_up_data = npzoom(lr_img_data, 4, order=1) lr_up_img = Image(tensor(lr_up_data[None])) hr_pred_img, aaa, bbb = learn.predict(lr_up_img) pred_img = PIL.Image.fromarray( img_as_ubyte(np.array(hr_pred_img.data))[0, :, :]) lr_img.save(results / f'{k}_orig.tif') hr_img.save(results / f'{k}_truth.tif') pred_img.save(results / f'{k}_pred.tif') hr_img_data = np.array(hr_img) ssims.append( compare_ssim(img_as_float32(np.array(hr_img)), img_as_float32(np.array(pred_img)))) psnrs.append( compare_psnr(img_as_float32(np.array(hr_img)), img_as_float32(np.array(pred_img)))) print(np.array(ssims).mean(), np.array(psnrs).mean()) #target_path = Path('/DATA/Dropbox/bpho_movie_results/emsynth_003/') target_path = results orig, tru, pred = [ list(target_path.glob(f'*{tag}*')) for tag in ['orig', 'tru', 'pred'] ] orig.sort() tru.sort() pred.sort() ssims = [] c_ssims = [] l_ssims = [] psnrs = [] c_psnrs = [] l_psnrs = [] for o, t, p in progress_bar(list(zip(orig, tru, pred))): oimg, timg, pimg = [img_as_float32(io.imread(fn)) for fn in [o, t, p]] if len(pimg.shape) == 3: pimg = pimg[:, :, 0] cimg = npzoom(oimg, 4) limg = npzoom(oimg, 4, order=1) ssims.append(compare_ssim(timg, pimg)) c_ssims.append(compare_ssim(timg, cimg)) l_ssims.append(compare_ssim(timg, limg)) psnrs.append(compare_psnr(timg, pimg)) c_psnrs.append(compare_psnr(timg, cimg)) l_psnrs.append(compare_psnr(timg, limg)) import pandas as pd df = pd.DataFrame( dict(ssim=ssims, psnr=psnrs, bicubic_ssim=c_ssims, bicubic_psnr=c_psnrs, bilinear_ssim=l_ssims, bilinear_psnr=l_psnrs)) df.describe() print(df.describe())
def copy_image(path): # Path(os.path.join(target_dir, os.path.split(path)[0])).mkdir(parents=True, exist_ok=True) img = io.imread(os.path.join(datapath, path)) return tf.image.encode_png(util.img_as_ubyte( transform.rescale(util.img_as_float32(img), 0.1, multichannel=True)), compression=9).numpy()
from skimage.morphology import binary_erosion from skimage.morphology import binary_dilation from skimage.morphology import label from skimage.morphology import remove_small_objects import cv2 filename = "/Users/jrug001/Desktop/nesi00119/Yule/intravital/Mistgcamp-3_0002.oir" figX, ax = plt.subplots(1, 1) # an extra single figure fig = plt.figure(figsize=(16, 8)) gs = gridspec.GridSpec(nrows=2, ncols=4, height_ratios=[1, 1]) # get the image stack #os.system("/Users/jrug001/Desktop/nesi00119/bftools/bfconvert " + filename + " temp.tiff") A0 = img_as_float32(io.imread('temp.tiff')) A0 = exposure.rescale_intensity(A0) #os.system("rm temp.tiff") # average out y-direction aliasing over every other line for n in range(A0.shape[0] - 1): # average over every two lines A0[n] = (A0[n] + A0[n + 1]) / 2.0 ########################################### # unstimulated average over time A = np.concatenate((A0[:100, :, :], A0[249:, :, :])) # unstimulated only M = np.zeros(A[0].shape) for n in range(A.shape[0]): # average over time M += A[n] M /= A.shape[0]
NUM_SAMPLES_LIME = int(args['samples']) N_KEEP = int(args['keep']) CHECKPOINT_DIR = str(args['checkpoint_dir']) OUTPUT_DIR = os.path.abspath(str(args['output_dir'])) + "/" THRESHOLD_TRUE_CLASS = float(args['theta']) NOISE = int(args['noise']) # completely remove the output directory and create a new one shutil.rmtree(OUTPUT_DIR, ignore_errors=True) os.makedirs(OUTPUT_DIR) # load in and resize original image to match network default size image_filepath = os.path.abspath(args["image"]) image = img_as_float32(io.imread(image_filepath)) image = resize(image, (own_rel.IMAGE_SIZE, own_rel.IMAGE_SIZE), anti_aliasing=True) # import model model = own_rel.own_rel() # load weights from checkpoint model.load_weights(CHECKPOINT_DIR) # get the annotated image annotated_image = la.annotate_image_parts(image, model, OUTPUT_DIR, NUM_SAMPLES_LIME) # get the list of the important superpixels important_superpixels, labeled_image = la.find_important_parts(