def __init__(self, case_num, transform=None, target_transform=None): # root表示图片路径 volume = [] segmentation = [] if case_num == -1: # 如果等于-1,将所有数据集都读入 volume = [] segmentation = [] for i in range(210): tmp_volume, tmp_segmentation = load_case(i) np.vstack((volume, tmp_volume)) np.vstack((segmentation, tmp_segmentation)) elif case_num < 210: volume, segmentation = load_case(case_num) kid_seg_ims = get_kid_img(segmentation.get_data()) # 取出肾脏分割图 else: volume = load_volume(case_num) vol_ims = normalize(volume.get_data(), DEFAULT_HU_MAX, DEFAULT_HU_MIN) # 将原图归一化转为灰度图 imgs = [] if case_num == -1: for num in range(vol_ims.shape[0]): imgs.append([vol_ims[num], kid_seg_ims[num]]) elif case_num < 210: for num in range(vol_ims.shape[0]): # if not np.all(kid_seg_ims[num]==0): imgs.append([vol_ims[num], kid_seg_ims[num]]) else: for num in range(vol_ims.shape[0]): imgs.append([vol_ims[num], None]) self.imgs = imgs self.transform = transform self.target_transform = target_transform
def visualize_case(case_num, save=None): def minMax(array): return (array - np.min(array)) / (np.max(array) - np.min(array)) volume, segmentation = load_case(case_num) X = preprocess_X(volume) y = segmentation.get_fdata() model = tf.keras.models.load_model(r'MODEL.h5', custom_objects={ 'dice_coef_loss': dice_coef_loss, 'dice_coef': dice_coef }) segmentation_pred = model.predict(X) kidney = cv2.threshold(segmentation_pred[:, :, :, 1], 0.2, 1, cv2.THRESH_BINARY)[1] cancer = cv2.threshold(segmentation_pred[:, :, :, 2], 0.06, 1, cv2.THRESH_BINARY)[1] seg_img = np.clip((kidney * 0.5 + cancer), 0, 1) cube_show_slider(cube=X[:, :, :, 0], cube1=y, cube2=seg_img, axis=0, cmap='gray') if save: nifty_img = nib.Nifti1Image(seg_img, volume.affine, volume.header) nib.save(nifty_img, "predict\case{}".format(case_num))
def load_imgs(case_list=[0], height=512, width=512, channels=1, num_class=2, no_negative=False, normalization=False, kidney_only=True): for i in case_list: volume, segmentation = load_case(i) img = volume.get_data() # print(img.shape) img = to_gray(img, -512, 512).astype(np.uint8) seg = segmentation.get_data().astype(np.uint8) if normalization: img = (img - np.mean(img)) / np.std(img) #是否归一化 img = np.expand_dims(img, axis=-1) # print(img.shape) mask = seg_to_mask(seg, kidney_only) label = np.array([np.max(mask[i]) for i in range(mask.shape[0]) ]).astype(np.uint8) #判断是否有分割内容 # np.amax(mask[i],axis=(0,1))[1] #肾和肿瘤都训练时,选出包含两种内容的图片 if no_negative: #不加载不含分割图的 l = np.squeeze(np.argwhere(label == 1)).tolist() # positve_list img, mask, label = img[l], mask[l], label[l] if i == case_list[0]: imgs, masks, labels = img, mask, label else: imgs = np.concatenate([imgs, img], axis=0) masks = np.concatenate([masks, mask], axis=0) labels = np.concatenate([labels, label], axis=0) print(i, img.shape[0], np.mean(label)) print('all images', imgs.shape[0], np.mean(labels)) return imgs, masks, labels
def visualize(cid, destination, hu_min=DEFAULT_HU_MIN, hu_max=DEFAULT_HU_MAX, k_color=DEFAULT_KIDNEY_COLOR, t_color=DEFAULT_TUMOR_COLOR, alpha=DEFAULT_OVERLAY_ALPHA): # Prepare output location out_path = Path(destination) if not out_path.exists(): out_path.mkdir() # Load segmentation and volume vol, seg = load_case(cid) vol = vol.get_data() seg = seg.get_data() seg = seg.astype(np.int32) # Convert to a visual format vol_ims = hu_to_grayscale(vol, hu_min, hu_max) seg_ims = class_to_color(seg, k_color, t_color) # Overlay the segmentation colors viz_ims = overlay(vol_ims, seg_ims, seg, alpha) # Save individual images to disk for i in range(viz_ims.shape[0]): fpath = out_path / ("{:05d}.png".format(i)) scipy.misc.imsave(str(fpath), viz_ims[i])
def main(): img, seg = load_case("123") img = img.get_data() seg = seg.get_data() seg[seg == 1] = 255 model = pkl.load(open("model.p", "rb")) infer_images(img, seg, model)
def validationGenerator(case_nums, batch_size): #takes data from begining of data set to while True: for case_num in case_nums: volume, segmentation = load_case(case_num) X_file = preprocess_X(volume) y_file, begining_num, end_num = preprocess_y(segmentation) X_file = X_file[begining_num:end_num + 1, :, :] y_file = y_file[begining_num:end_num + 1, :, :] L = X_file.shape[0] batch_start = 0 batch_end = batch_size print('Validation in progress: {:.2f}%'.format( ((case_num - np.min(case_nums)) / (np.max(case_nums) - np.min(case_nums))) * 100)) while batch_start < L: limit = min(batch_end, L) X = X_file[batch_start:limit, :, :, :] y = y_file[batch_start:limit, :, :, :] #needs to yield (X, y, [None]) for some reason yield (tf.cast(X, dtype=tf.float16), tf.cast(y, dtype=tf.float16), [None]) batch_start += batch_size batch_end += batch_size if case_num == case_nums[-1]: # breaks loop so it starts again infinietly break # def validationGenerator(case_nums, batch_size): # #generates random index from given dataset (validation data is given) # while True: # random_val_index = case_nums[np.random.randint(0, len(case_nums))] # volume, segmentation = load_case(random_val_index) # #preprocessing input # X_file = preprocess_X(volume) # y_file = preprocess_y(segmentation) # L = X_file.shape[0] # batch_start = 0 # batch_end = batch_size # print('validation in progress please wait') # while batch_start < L: # limit = min(batch_end, L) # X = X_file[batch_start:limit, :, :, :] # y = y_file[batch_start:limit, :, :, :] # #needs to yield (X, y, [None]) for some reason # yield (X.astype(np.float32), y.astype(np.float32)) # batch_start += batch_size # batch_end += batch_size
def get_vol_seg_ims(cid, hu_min=DEFAULT_HU_MIN, hu_max=DEFAULT_HU_MAX, k_color=DEFAULT_KIDNEY_COLOR, t_color=DEFAULT_TUMOR_COLOR): # Load segmentation and volume vol, seg = load_case(cid) spacing = vol.affine vol = vol.get_data() seg = seg.get_data() seg = seg.astype(np.int32) # Convert to a visual format vol_ims = hu_to_grayscale(vol, hu_min, hu_max) seg_ims = class_to_color(seg, k_color, t_color) return vol, seg, vol_ims, seg_ims
def main(): vol, seg = load_case('123') vol = vol.get_data() seg = seg.get_data() ball = morphology.disk(2) disk = morphology.disk(7) jaccards = [] listImage = [] listSeg = [] with imageio.get_writer(os.path.join('kidney1.gif'), mode='I') as writer: for i in range(len(vol)): seg[i][seg[i] == 1] = 255 seg[i][seg[i] == 2] = 255 vol[i] = vol[i] + 2048 vol[i] = vol[i] / 4096 vol[i] = 255 * vol[i] vol[i][200:400, 100:400] = exposure.equalize_hist(vol[i][200:400, 100:400]) vol[i][200:400, 100:400] = filters.median(vol[i][200:400, 100:400]) # denoised = filters.rank.median(vol[i][200:400,100:400], ball) # markers = filters.rank.gradient(denoised, disk) < 10 # markers = ndi.label(markers)[0] # gradient = filters.rank.gradient(denoised, ball) # vol[i][200:400,100:400] = morphology.watershed(gradient, markers) listImage.append(vol[i][200:400, 100:400]) listSeg.append(seg[i][200:400, 100:400]) # writer.append_data(vol[i][200:400,100:400]) print(len(listImage), len(listSeg)) X_train, X_test, y_train, y_test = create_training_dataset( listImage, listSeg) model = train_model(X_train, y_train, "RF") test_model(X_test, y_test, model) pkl.dump(model, open("model.p", "wb"))
def trainGenerator(case_nums, batch_size): #takes data from begining of data set to while True: for case_num in case_nums: volume, segmentation = load_case(case_num) #preprocessing input X_file = preprocess_X(volume) y_file, begining_num, end_num = preprocess_y(segmentation) X_file = X_file[begining_num:end_num + 1, :, :] y_file = y_file[begining_num:end_num + 1, :, :] L = X_file.shape[0] batch_start = 0 batch_end = batch_size while batch_start < L: limit = min(batch_end, L) X = X_file[batch_start:limit, :, :, :] y = y_file[batch_start:limit, :, :, :] yield (tf.cast(X, dtype=tf.float16), tf.cast(y, dtype=tf.float16), [None]) batch_start += batch_size batch_end += batch_size if case_num == case_nums[-1]: break
from skimage import segmentation from skimage.morphology import disk from skimage.morphology import binary_closing from skimage.morphology import binary_dilation from skimage import restoration from skimage.segmentation import active_contour from skimage.filters import gaussian import matplotlib.pyplot as plt #instalacja biblioteki do analizy danych z rozszerzeniem .nii pip install nibabel !pip install python-utils from starter_code.utils import load_case #załadowanie danych i pobranie wycinków volume0, segmentation0 =load_case("case_00000") volume0 = volume0.get_fdata() segmentation0 = segmentation0.get_fdata() volume_shape=np.shape(volume0) segmentation_shape=np.shape(segmentation0) print(f"shape of volume {volume_shape}") print(f"shape of segmentation {segmentation_shape}") #wyswietlenie przekrojów #for i in range (0, volume_shape[0],1): # plt.figure() # plt.imshow(volume0[i],cmap='gray') #funkcja która umożliwi pracę na wybranych przekrojach z widocznymi nerkami def show_slices(slices): """ Function to display row of image slices """
def visualize(cid, destination, hu_min=DEFAULT_HU_MIN, hu_max=DEFAULT_HU_MAX, k_color=DEFAULT_KIDNEY_COLOR, t_color=DEFAULT_TUMOR_COLOR, alpha=DEFAULT_OVERLAY_ALPHA, plane=DEFAULT_PLANE): plane = plane.lower() plane_opts = ["axial", "coronal", "sagittal"] if plane not in plane_opts: raise ValueError(("Plane \"{}\" not understood. " "Must be one of the following\n\n\t{}\n").format( plane, plane_opts)) # Prepare output location out_path = Path(destination) if not out_path.exists(): out_path.mkdir() # Load segmentation and volume vol, seg = load_case(cid) spacing = vol.affine vol = vol.get_data() seg = seg.get_data() seg = seg.astype(np.int32) # Convert to a visual format vol_ims = hu_to_grayscale(vol, hu_min, hu_max) seg_ims = class_to_color(seg, k_color, t_color) # Save individual images to disk if plane == plane_opts[0]: # Overlay the segmentation colors viz_ims = overlay(vol_ims, seg_ims, seg, alpha) for i in range(viz_ims.shape[0]): fpath = out_path / ("{:05d}.png".format(i)) imwrite(str(fpath), viz_ims[i]) if plane == plane_opts[1]: # I use sum here to account for both legacy (incorrect) and # fixed affine matrices spc_ratio = np.abs(np.sum(spacing[2, :])) / np.abs( np.sum(spacing[0, :])) for i in range(vol_ims.shape[1]): fpath = out_path / ("{:05d}.png".format(i)) vol_im = scipy.misc.imresize( vol_ims[:, i, :], (int(vol_ims.shape[0] * spc_ratio), int(vol_ims.shape[2])), interp="bicubic") seg_im = scipy.misc.imresize( seg_ims[:, i, :], (int(vol_ims.shape[0] * spc_ratio), int(vol_ims.shape[2])), interp="nearest") sim = scipy.misc.imresize( seg[:, i, :], (int(vol_ims.shape[0] * spc_ratio), int(vol_ims.shape[2])), interp="nearest") viz_im = overlay(vol_im, seg_im, sim, alpha) imwrite(str(fpath), viz_im) if plane == plane_opts[2]: # I use sum here to account for both legacy (incorrect) and # fixed affine matrices spc_ratio = np.abs(np.sum(spacing[2, :])) / np.abs( np.sum(spacing[1, :])) for i in range(vol_ims.shape[2]): fpath = out_path / ("{:05d}.png".format(i)) vol_im = scipy.misc.imresize( vol_ims[:, :, i], (int(vol_ims.shape[0] * spc_ratio), int(vol_ims.shape[1])), interp="bicubic") seg_im = scipy.misc.imresize( seg_ims[:, :, i], (int(vol_ims.shape[0] * spc_ratio), int(vol_ims.shape[1])), interp="nearest") sim = scipy.misc.imresize( seg[:, :, i], (int(vol_ims.shape[0] * spc_ratio), int(vol_ims.shape[1])), interp="nearest") viz_im = overlay(vol_im, seg_im, sim, alpha) imwrite(str(fpath), viz_im)
import sys sys.path.append('/home/kitamiya/Documents/python/snake3D/src') sys.path.append('/home/kitamiya/Documents/python/snake3D/src/Toolbox') import Toolbox as tb from starter_code.utils import load_case import numpy as np num = int(sys.argv[1]) volume, segmentation = load_case(num) img = np.asarray(volume.dataobj) print(img.shape) np.save( "/home/kitamiya/Documents/python/snake3D/data/numpy/case" + str(num) + ".npy", img)
Created on Sun Jun 21 20:45:43 2020 @author: Acer """ %cd kits19 from starter_code.utils import load_case import numpy as np from sklearn.ensemble import RandomForestClassifier import pandas as pd import matplotlib.pyplot as plt from sklearn import metrics #ładowanie danych treningowych for i in range(9, 12): volume, segmentation = load_case(i) vol = volume.get_fdata() seg = segmentation.get_fdata() nsamples, nx, ny = vol.shape vol = vol.reshape(nsamples, nx*ny) nsamples, nx, ny = seg.shape seg = seg.reshape(nsamples, nx*ny) if i==9: X=vol y=seg X=np.concatenate((X, vol)) y=np.concatenate((y, seg))
import sys sys.path.append('/Users/shomakitamiya/Documents/python/snake3D/src') sys.path.append('/Users/shomakitamiya/Documents/python/snake3D/src/Toolbox') import Toolbox as tb from starter_code.utils import load_case import numpy as np from mpl_toolkits.mplot3d import Axes3D # noqa: F401 unused import import matplotlib.pyplot as plt from mayavi import mlab volume, segmentation = load_case(123) print(type(segmentation)) seg = np.asarray(segmentation.dataobj) seg = np.where(seg == 1, 1, 0) seg = seg.astype(np.float32) # fig = plt.figure() # ax = fig.gca(projection='3d') # ax.voxels(seg[100:180,260:340,300:380]) # plt.show() mlab.clf() mlab.contour3d(seg[50:250, 200:400, 250:450]) mlab.show()
import skimage.transform as trans from keras.models import * from keras.layers import * from keras.optimizers import * from keras.callbacks import ModelCheckpoint, LearningRateScheduler from keras import backend as keras import skimage.measure as measure from skimage.transform import resize from sklearn.model_selection import train_test_split """Wczytywanie zdjęć do folderów""" # Commented out IPython magic to ensure Python compatibility. for i in range(1,10): # %cd /content/kits19/visualized volume, segemnatation=load_case('case_0000'+str(i)) os.mkdir("masks_0000" +str(i)) os.mkdir("images_0000"+str(i)) mask_out_path = Path("/content/kits19/visualized/masks_0000"+str(i)) image_out_path = Path("/content/kits19/visualized/images_0000"+str(i)) s=segemnatation.get_fdata() v=volume.get_fdata() for j in range(s.shape[0]): maskfpath = mask_out_path / ("{:05d}.png".format(j)) imagefpath = image_out_path / ("{:05d}.png".format(j)) imwrite(str(maskfpath), s[j,:,:]) imwrite(str(imagefpath), v[j,:,:]) """Przygotowywanie danych do trenowania i testów. Zmniejszenie wielkosci obrazów i określenie ilosci wsadowych case-ów."""
def ToPNGfunc(Cases): cases = np.linspace(2, Cases - 3, Cases - 4, dtype=np.int) TRAIN_PATH_CT = Path('E:\TOM\dataPNG\TRAIN\CT') TRAIN_PATH_MASK = Path('E:\TOM\dataPNG\TRAIN\MASK') TEST_PATH_CT = Path('E:\TOM\dataPNG\TEST\CT') TEST_PATH_MASK = Path('E:\TOM\dataPNG\TEST\MASK') # VALID_PATH_CT = Path('E:\TOM\dataPNG\VALID\CT') # VALID_PATH_MASK = Path('E:\TOM\dataPNG\VALID\MASK') a = 0 b = 0 train_n = 0 test_n = 0 for id in cases: ################################ Ładowanie zbioru treningowego zachowyjąc pewnien % czarnych zdjec b = a + b volume, segmentation = load_case(id) segmentation = segmentation.get_fdata() volume = volume.get_fdata() (a, y, x) = segmentation.shape print(f"loading case for TRAINING: {id} out of {Cases}") for index in range(b, a + b, 1): if (len(np.unique(segmentation[index - b])) > 1 or (random.randint(0, 100)) < 3): picture_ct = TRAIN_PATH_CT / '{:05d}.png'.format(index) picture_mask = TRAIN_PATH_MASK / '{:05d}.png'.format(index) train_n += 1 plt.imsave(fname=str(picture_ct), arr=volume[index - b], format='png', cmap='gray') plt.imsave(fname=str(picture_mask), arr=segmentation[index - b], format='png', cmap='gray') ################################ Ładowanie zbioru testowego bez czarnych zdjec cases = np.linspace(Cases - 2, Cases, 3, dtype=np.int) for id in cases: b = a + b volume, segmentation = load_case(id) segmentation = segmentation.get_fdata() volume = volume.get_fdata() (a, y, x) = segmentation.shape print(f"loading case for TESTING: {id} out of {Cases}") for index in range(b, a + b, 1): if (len(np.unique(segmentation[index - b])) > 1): picture_ct = TEST_PATH_CT / '{:05d}.png'.format(index) picture_mask = TEST_PATH_MASK / '{:05d}.png'.format(index) test_n += 1 plt.imsave(fname=str(picture_ct), arr=volume[index - b], format='png', cmap='gray') plt.imsave(fname=str(picture_mask), arr=segmentation[index - b], format='png', cmap='gray') return train_n, test_n
#zmiana working directory na folder zawierajacy zdjecie import os os.chdir('/Users/komala/Desktop/TOM_projekt/kits19') from starter_code.utils import load_case from starter_code.visualize import visualize volume, segmentation = load_case("case_00000") visualize("case_00000", "pictures")
import imageio from starter_code.utils import load_case import os for i in range(0, 50, 10): print(i) with imageio.get_writer(os.path.join(f'allkidneys{i}.gif'), mode='I') as writer: vol, seg = load_case(str(i)) vol = vol.get_data() mask = vol mask2 = vol seg = seg.get_data() seg[seg == 1] = 255 for v in range(len(seg)): writer.append_data(seg[v][200:400, 100:400])
def visualize(cid, destination, hu_min=DEFAULT_HU_MIN, hu_max=DEFAULT_HU_MAX, k_color=DEFAULT_KIDNEY_COLOR, t_color=DEFAULT_TUMOR_COLOR, alpha=DEFAULT_OVERLAY_ALPHA, plane=DEFAULT_PLANE, less_ram=False): plane = plane.lower() plane_opts = ["axial", "coronal", "sagittal"] if plane not in plane_opts: raise ValueError(("Plane \"{}\" not understood. " "Must be one of the following\n\n\t{}\n").format( plane, plane_opts)) # Prepare output location out_path = Path(destination) if not out_path.exists(): out_path.mkdir() # Load segmentation and volume vol, seg = load_case(cid) spacing = vol.affine vol = vol.get_data() seg = seg.get_data() seg = seg.astype(np.int32) vol_ims = None seg_ims = None if not less_ram: # Convert to a visual format vol_ims = hu_to_grayscale(vol, hu_min, hu_max).astype(np.uint8) seg_ims = class_to_color(seg, k_color, t_color).astype(np.uint8) # Save individual images to disk if plane == plane_opts[0]: if less_ram: for j in range(vol.shape[0]): vol_ims = hu_to_grayscale(vol[j:j + 1], hu_min, hu_max) seg_ims = class_to_color(seg[j:j + 1], k_color, t_color) viz_ims = overlay(vol_ims, seg_ims, seg[j:j + 1], alpha) for i in range(viz_ims.shape[0]): fpath = out_path / ("{:05d}.png".format(j)) imwrite(str(fpath), viz_ims[i]) else: # Overlay the segmentation colors viz_ims = overlay(vol_ims, seg_ims, seg, alpha) for i in range(viz_ims.shape[0]): fpath = out_path / ("{:05d}.png".format(i)) imwrite(str(fpath), viz_ims[i]) if plane == plane_opts[1]: # I use sum here to account for both legacy (incorrect) and # fixed affine matrices spc_ratio = np.abs(spacing[2, 0]) / np.abs(spacing[0, 2]) if less_ram: for j in range(vol.shape[1]): vol_ims = hu_to_grayscale(vol[:, j:j + 1], hu_min, hu_max).astype(np.uint8) seg_ims = class_to_color(seg[:, j:j + 1], k_color, t_color).astype(np.uint8) for i in range(vol_ims.shape[1]): fpath = out_path / ("{:05d}.png".format(j)) vol_im = np.array( Image.fromarray(vol_ims[:, i, :]).resize( (int(vol_ims.shape[2]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.BICUBIC)) seg_im = np.array( Image.fromarray(seg_ims[:, i, :]).resize( (int(vol_ims.shape[2]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) sim = np.array( Image.fromarray(seg[:, j, :]).resize( (int(vol_ims.shape[2]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) viz_im = overlay(vol_im, seg_im, sim, alpha) imwrite(str(fpath), viz_im) else: for i in range(vol_ims.shape[1]): fpath = out_path / ("{:05d}.png".format(i)) vol_im = np.array( Image.fromarray(vol_ims[:, i, :]).resize( (int(vol_ims.shape[2]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.BICUBIC)) seg_im = np.array( Image.fromarray(seg_ims[:, i, :]).resize( (int(vol_ims.shape[2]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) sim = np.array( Image.fromarray(seg[:, i, :]).resize( (int(vol_ims.shape[2]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) viz_im = overlay(vol_im, seg_im, sim, alpha) imwrite(str(fpath), viz_im) if plane == plane_opts[2]: # I use sum here to account for both legacy (incorrect) and # fixed affine matrices spc_ratio = np.abs(spacing[2, 0]) / np.abs(spacing[1, 1]) if less_ram: for j in range(vol.shape[2]): vol_ims = hu_to_grayscale(vol[:, :, j:j + 1], hu_min, hu_max).astype(np.uint8) seg_ims = class_to_color(seg[:, :, j:j + 1], k_color, t_color).astype(np.uint8) for i in range(vol_ims.shape[2]): fpath = out_path / ("{:05d}.png".format(j)) vol_im = np.array( Image.fromarray(vol_ims[:, :, i]).resize( (int(vol_ims.shape[1]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.BICUBIC)) seg_im = np.array( Image.fromarray(seg_ims[:, :, i]).resize( (int(vol_ims.shape[1]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) sim = np.array( Image.fromarray(seg[:, :, j]).resize( (int(vol_ims.shape[1]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) viz_im = overlay(vol_im, seg_im, sim, alpha) imwrite(str(fpath), viz_im) else: for i in range(vol_ims.shape[2]): fpath = out_path / ("{:05d}.png".format(i)) vol_im = np.array( Image.fromarray(vol_ims[:, :, i]).resize( (int(vol_ims.shape[1]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.BICUBIC)) seg_im = np.array( Image.fromarray(seg_ims[:, :, i]).resize( (int(vol_ims.shape[1]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) sim = np.array( Image.fromarray(seg[:, :, i]).resize( (int(vol_ims.shape[1]), int(vol_ims.shape[0] * spc_ratio)), resample=Image.NEAREST)) viz_im = overlay(vol_im, seg_im, sim, alpha) imwrite(str(fpath), viz_im)