173d1be0e72b3b98aa37c8c8529875e4b3f0277a58df6eabd36c541c2f90d0dd

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/ldm/vq_gan_3d/model/lpips.py

@@ -0,0 +1,181 @@
+"""Adapted from https://github.com/SongweiGe/TATS"""
+
+"""Stripped version of https://github.com/richzhang/PerceptualSimilarity/tree/master/models"""
+
+
+from collections import namedtuple
+from torchvision import models
+import torch.nn as nn
+import torch
+from tqdm import tqdm
+import requests
+import os
+import hashlib
+URL_MAP = {
+ "vgg_lpips": "https://heibox.uni-heidelberg.de/f/607503859c864bc1b30b/?dl=1"
+}
+
+CKPT_MAP = {
+ "vgg_lpips": "vgg.pth"
+}
+
+MD5_MAP = {
+ "vgg_lpips": "d507d7349b931f0638a25a48a722f98a"
+}
+
+
+def download(url, local_path, chunk_size=1024):
+ os.makedirs(os.path.split(local_path)[0], exist_ok=True)
+ with requests.get(url, stream=True) as r:
+ total_size = int(r.headers.get("content-length", 0))
+ with tqdm(total=total_size, unit="B", unit_scale=True) as pbar:
+ with open(local_path, "wb") as f:
+ for data in r.iter_content(chunk_size=chunk_size):
+ if data:
+ f.write(data)
+ pbar.update(chunk_size)
+
+
+def md5_hash(path):
+ with open(path, "rb") as f:
+ content = f.read()
+ return hashlib.md5(content).hexdigest()
+
+
+def get_ckpt_path(name, root, check=False):
+ assert name in URL_MAP
+ path = os.path.join(root, CKPT_MAP[name])
+ if not os.path.exists(path) or (check and not md5_hash(path) == MD5_MAP[name]):
+ print("Downloading {} model from {} to {}".format(
+ name, URL_MAP[name], path))
+ download(URL_MAP[name], path)
+ md5 = md5_hash(path)
+ assert md5 == MD5_MAP[name], md5
+ return path
+
+
+class LPIPS(nn.Module):
+ # Learned perceptual metric
+ def __init__(self, use_dropout=True):
+ super().__init__()
+ self.scaling_layer = ScalingLayer()
+ self.chns = [64, 128, 256, 512, 512] # vg16 features
+ self.net = vgg16(pretrained=True, requires_grad=False)
+ self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout)
+ self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout)
+ self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout)
+ self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout)
+ self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout)
+ # self.load_from_pretrained()
+ for param in self.parameters():
+ param.requires_grad = False
+
+ def load_from_pretrained(self, name="vgg_lpips"):
+ ckpt = get_ckpt_path(name, os.path.join(
+ os.path.dirname(os.path.abspath(__file__)), "cache"))
+ self.load_state_dict(torch.load(
+ ckpt, map_location=torch.device("cpu")), strict=False)
+ print("loaded pretrained LPIPS loss from {}".format(ckpt))
+
+ @classmethod
+ def from_pretrained(cls, name="vgg_lpips"):
+ if name is not "vgg_lpips":
+ raise NotImplementedError
+ model = cls()
+ ckpt = get_ckpt_path(name, os.path.join(
+ os.path.dirname(os.path.abspath(__file__)), "cache"))
+ model.load_state_dict(torch.load(
+ ckpt, map_location=torch.device("cpu")), strict=False)
+ return model
+
+ def forward(self, input, target):
+ in0_input, in1_input = (self.scaling_layer(
+ input), self.scaling_layer(target))
+ outs0, outs1 = self.net(in0_input), self.net(in1_input)
+ feats0, feats1, diffs = {}, {}, {}
+ lins = [self.lin0, self.lin1, self.lin2, self.lin3, self.lin4]
+ for kk in range(len(self.chns)):
+ feats0[kk], feats1[kk] = normalize_tensor(
+ outs0[kk]), normalize_tensor(outs1[kk])
+ diffs[kk] = (feats0[kk] - feats1[kk]) ** 2
+
+ res = [spatial_average(lins[kk].model(diffs[kk]), keepdim=True)
+ for kk in range(len(self.chns))]
+ val = res[0]
+ for l in range(1, len(self.chns)):
+ val += res[l]
+ return val
+
+
+class ScalingLayer(nn.Module):
+ def __init__(self):
+ super(ScalingLayer, self).__init__()
+ self.register_buffer('shift', torch.Tensor(
+ [-.030, -.088, -.188])[None, :, None, None])
+ self.register_buffer('scale', torch.Tensor(
+ [.458, .448, .450])[None, :, None, None])
+
+ def forward(self, inp):
+ return (inp - self.shift) / self.scale
+
+
+class NetLinLayer(nn.Module):
+ """ A single linear layer which does a 1x1 conv """
+
+ def __init__(self, chn_in, chn_out=1, use_dropout=False):
+ super(NetLinLayer, self).__init__()
+ layers = [nn.Dropout(), ] if (use_dropout) else []
+ layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1,
+ padding=0, bias=False), ]
+ self.model = nn.Sequential(*layers)
+
+
+class vgg16(torch.nn.Module):
+ def __init__(self, requires_grad=False, pretrained=True):
+ super(vgg16, self).__init__()
+ vgg_pretrained_features = models.vgg16(pretrained=pretrained).features
+ self.slice1 = torch.nn.Sequential()
+ self.slice2 = torch.nn.Sequential()
+ self.slice3 = torch.nn.Sequential()
+ self.slice4 = torch.nn.Sequential()
+ self.slice5 = torch.nn.Sequential()
+ self.N_slices = 5
+ for x in range(4):
+ self.slice1.add_module(str(x), vgg_pretrained_features[x])
+ for x in range(4, 9):
+ self.slice2.add_module(str(x), vgg_pretrained_features[x])
+ for x in range(9, 16):
+ self.slice3.add_module(str(x), vgg_pretrained_features[x])
+ for x in range(16, 23):
+ self.slice4.add_module(str(x), vgg_pretrained_features[x])
+ for x in range(23, 30):
+ self.slice5.add_module(str(x), vgg_pretrained_features[x])
+ if not requires_grad:
+ for param in self.parameters():
+ param.requires_grad = False
+
+ def forward(self, X):
+ h = self.slice1(X)
+ h_relu1_2 = h
+ h = self.slice2(h)
+ h_relu2_2 = h
+ h = self.slice3(h)
+ h_relu3_3 = h
+ h = self.slice4(h)
+ h_relu4_3 = h
+ h = self.slice5(h)
+ h_relu5_3 = h
+ vgg_outputs = namedtuple(
+ "VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3'])
+ out = vgg_outputs(h_relu1_2, h_relu2_2,
+ h_relu3_3, h_relu4_3, h_relu5_3)
+ return out
+
+
+def normalize_tensor(x, eps=1e-10):
+ norm_factor = torch.sqrt(torch.sum(x**2, dim=1, keepdim=True))
+ return x/(norm_factor+eps)
+
+
+def spatial_average(x, keepdim=True):
+ return x.mean([2, 3], keepdim=keepdim)

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/ldm/vq_gan_3d/model/vqgan.py

@@ -0,0 +1,561 @@
+"""Adapted from https://github.com/SongweiGe/TATS"""
+# Copyright (c) Meta Platforms, Inc. All Rights Reserved
+
+import math
+import argparse
+import numpy as np
+import pickle as pkl
+
+import pytorch_lightning as pl
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+
+from ..utils import shift_dim, adopt_weight, comp_getattr
+from .lpips import LPIPS
+from .codebook import Codebook
+
+
+def silu(x):
+ return x*torch.sigmoid(x)
+
+
+class SiLU(nn.Module):
+ def __init__(self):
+ super(SiLU, self).__init__()
+
+ def forward(self, x):
+ return silu(x)
+
+
+def hinge_d_loss(logits_real, logits_fake):
+ loss_real = torch.mean(F.relu(1. - logits_real))
+ loss_fake = torch.mean(F.relu(1. + logits_fake))
+ d_loss = 0.5 * (loss_real + loss_fake)
+ return d_loss
+
+
+def vanilla_d_loss(logits_real, logits_fake):
+ d_loss = 0.5 * (
+ torch.mean(torch.nn.functional.softplus(-logits_real)) +
+ torch.mean(torch.nn.functional.softplus(logits_fake)))
+ return d_loss
+
+
+class VQGAN(pl.LightningModule):
+ def __init__(self, cfg):
+ super().__init__()
+ self.cfg = cfg
+ self.embedding_dim = cfg.model.embedding_dim # 8
+ self.n_codes = cfg.model.n_codes # 16384
+
+ self.encoder = Encoder(cfg.model.n_hiddens, # 16
+ cfg.model.downsample, # [2, 2, 2]
+ cfg.dataset.image_channels, # 1
+ cfg.model.norm_type, # group
+ cfg.model.padding_type, # replicate
+ cfg.model.num_groups, # 32
+ )
+ self.decoder = Decoder(
+ cfg.model.n_hiddens, cfg.model.downsample, cfg.dataset.image_channels, cfg.model.norm_type, cfg.model.num_groups)
+ self.enc_out_ch = self.encoder.out_channels
+ self.pre_vq_conv = SamePadConv3d(
+ self.enc_out_ch, cfg.model.embedding_dim, 1, padding_type=cfg.model.padding_type)
+ self.post_vq_conv = SamePadConv3d(
+ cfg.model.embedding_dim, self.enc_out_ch, 1)
+
+ self.codebook = Codebook(cfg.model.n_codes, cfg.model.embedding_dim,
+ no_random_restart=cfg.model.no_random_restart, restart_thres=cfg.model.restart_thres)
+
+ self.gan_feat_weight = cfg.model.gan_feat_weight
+ # TODO: Changed batchnorm from sync to normal
+ self.image_discriminator = NLayerDiscriminator(
+ cfg.dataset.image_channels, cfg.model.disc_channels, cfg.model.disc_layers, norm_layer=nn.BatchNorm2d)
+ self.video_discriminator = NLayerDiscriminator3D(
+ cfg.dataset.image_channels, cfg.model.disc_channels, cfg.model.disc_layers, norm_layer=nn.BatchNorm3d)
+
+ if cfg.model.disc_loss_type == 'vanilla':
+ self.disc_loss = vanilla_d_loss
+ elif cfg.model.disc_loss_type == 'hinge':
+ self.disc_loss = hinge_d_loss
+
+ self.perceptual_model = LPIPS().eval()
+
+ self.image_gan_weight = cfg.model.image_gan_weight
+ self.video_gan_weight = cfg.model.video_gan_weight
+
+ self.perceptual_weight = cfg.model.perceptual_weight
+
+ self.l1_weight = cfg.model.l1_weight
+ self.save_hyperparameters()
+
+ def encode(self, x, include_embeddings=False, quantize=True):
+ h = self.pre_vq_conv(self.encoder(x))
+ if quantize:
+ vq_output = self.codebook(h)
+ if include_embeddings:
+ return vq_output['embeddings'], vq_output['encodings']
+ else:
+ return vq_output['encodings']
+ return h
+
+ def decode(self, latent, quantize=False):
+ if quantize:
+ vq_output = self.codebook(latent)
+ latent = vq_output['encodings']
+ h = F.embedding(latent, self.codebook.embeddings)
+ h = self.post_vq_conv(shift_dim(h, -1, 1))
+ return self.decoder(h)
+
+ def forward(self, x, optimizer_idx=None, log_image=False):
+ B, C, T, H, W = x.shape
+ z = self.pre_vq_conv(self.encoder(x)) # [2, 32, 32, 32, 32] [2, 8, 32, 32, 32]
+ vq_output = self.codebook(z) # ['embeddings', 'encodings', 'commitment_loss', 'perplexity']
+ x_recon = self.decoder(self.post_vq_conv(vq_output['embeddings'])) # [2, 8, 32, 32, 32] [2, 32, 32, 32, 32]
+
+ recon_loss = F.l1_loss(x_recon, x) * self.l1_weight
+
+ # Selects one random 2D image from each 3D Image
+ frame_idx = torch.randint(0, T, [B]).cuda()
+ frame_idx_selected = frame_idx.reshape(-1,
+ 1, 1, 1, 1).repeat(1, C, 1, H, W) # [2, 1, 1, 64, 64]
+ frames = torch.gather(x, 2, frame_idx_selected).squeeze(2) # [2, 1, 64, 64]
+ frames_recon = torch.gather(x_recon, 2, frame_idx_selected).squeeze(2) # [2, 1, 64, 64]
+
+ if log_image:
+ return frames, frames_recon, x, x_recon
+
+ if optimizer_idx == 0:
+ # Autoencoder - train the "generator"
+
+ # Perceptual loss
+ perceptual_loss = 0
+ if self.perceptual_weight > 0:
+ perceptual_loss = self.perceptual_model(
+ frames, frames_recon).mean() * self.perceptual_weight
+
+ # Discriminator loss (turned on after a certain epoch)
+ logits_image_fake, pred_image_fake = self.image_discriminator(
+ frames_recon)
+ logits_video_fake, pred_video_fake = self.video_discriminator(
+ x_recon)
+ g_image_loss = -torch.mean(logits_image_fake)
+ g_video_loss = -torch.mean(logits_video_fake)
+ g_loss = self.image_gan_weight*g_image_loss + self.video_gan_weight*g_video_loss
+ disc_factor = adopt_weight(
+ self.global_step, threshold=self.cfg.model.discriminator_iter_start)
+ aeloss = disc_factor * g_loss
+
+ # GAN feature matching loss - tune features such that we get the same prediction result on the discriminator
+ image_gan_feat_loss = 0
+ video_gan_feat_loss = 0
+ feat_weights = 4.0 / (3 + 1)
+ if self.image_gan_weight > 0:
+ logits_image_real, pred_image_real = self.image_discriminator(
+ frames)
+ for i in range(len(pred_image_fake)-1):
+ image_gan_feat_loss += feat_weights * \
+ F.l1_loss(pred_image_fake[i], pred_image_real[i].detach(
+ )) * (self.image_gan_weight > 0)
+ if self.video_gan_weight > 0:
+ logits_video_real, pred_video_real = self.video_discriminator(
+ x)
+ for i in range(len(pred_video_fake)-1):
+ video_gan_feat_loss += feat_weights * \
+ F.l1_loss(pred_video_fake[i], pred_video_real[i].detach(
+ )) * (self.video_gan_weight > 0)
+ gan_feat_loss = disc_factor * self.gan_feat_weight * \
+ (image_gan_feat_loss + video_gan_feat_loss)
+
+ self.log("train/g_image_loss", g_image_loss,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/g_video_loss", g_video_loss,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/image_gan_feat_loss", image_gan_feat_loss,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/video_gan_feat_loss", video_gan_feat_loss,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/perceptual_loss", perceptual_loss,
+ prog_bar=True, logger=True, on_step=True, on_epoch=True)
+ self.log("train/recon_loss", recon_loss, prog_bar=True,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/aeloss", aeloss, prog_bar=True,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/commitment_loss", vq_output['commitment_loss'],
+ prog_bar=True, logger=True, on_step=True, on_epoch=True)
+ self.log('train/perplexity', vq_output['perplexity'],
+ prog_bar=True, logger=True, on_step=True, on_epoch=True)
+ return recon_loss, x_recon, vq_output, aeloss, perceptual_loss, gan_feat_loss
+
+ if optimizer_idx == 1:
+ # Train discriminator
+ logits_image_real, _ = self.image_discriminator(frames.detach())
+ logits_video_real, _ = self.video_discriminator(x.detach())
+
+ logits_image_fake, _ = self.image_discriminator(
+ frames_recon.detach())
+ logits_video_fake, _ = self.video_discriminator(x_recon.detach())
+
+ d_image_loss = self.disc_loss(logits_image_real, logits_image_fake)
+ d_video_loss = self.disc_loss(logits_video_real, logits_video_fake)
+ disc_factor = adopt_weight(
+ self.global_step, threshold=self.cfg.model.discriminator_iter_start)
+ discloss = disc_factor * \
+ (self.image_gan_weight*d_image_loss +
+ self.video_gan_weight*d_video_loss)
+
+ self.log("train/logits_image_real", logits_image_real.mean().detach(),
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/logits_image_fake", logits_image_fake.mean().detach(),
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/logits_video_real", logits_video_real.mean().detach(),
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/logits_video_fake", logits_video_fake.mean().detach(),
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/d_image_loss", d_image_loss,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/d_video_loss", d_video_loss,
+ logger=True, on_step=True, on_epoch=True)
+ self.log("train/discloss", discloss, prog_bar=True,
+ logger=True, on_step=True, on_epoch=True)
+ return discloss
+
+ perceptual_loss = self.perceptual_model(
+ frames, frames_recon) * self.perceptual_weight
+ return recon_loss, x_recon, vq_output, perceptual_loss
+
+ def training_step(self, batch, batch_idx, optimizer_idx):
+ x = batch['image']
+ if optimizer_idx == 0:
+ recon_loss, _, vq_output, aeloss, perceptual_loss, gan_feat_loss = self.forward(
+ x, optimizer_idx)
+ commitment_loss = vq_output['commitment_loss']
+ loss = recon_loss + commitment_loss + aeloss + perceptual_loss + gan_feat_loss
+ if optimizer_idx == 1:
+ discloss = self.forward(x, optimizer_idx)
+ loss = discloss
+ return loss
+
+ def validation_step(self, batch, batch_idx):
+ x = batch['image'] # TODO: batch['stft']
+ recon_loss, _, vq_output, perceptual_loss = self.forward(x)
+ self.log('val/recon_loss', recon_loss, prog_bar=True)
+ self.log('val/perceptual_loss', perceptual_loss, prog_bar=True)
+ self.log('val/perplexity', vq_output['perplexity'], prog_bar=True)
+ self.log('val/commitment_loss',
+ vq_output['commitment_loss'], prog_bar=True)
+
+ def configure_optimizers(self):
+ lr = self.cfg.model.lr
+ opt_ae = torch.optim.Adam(list(self.encoder.parameters()) +
+ list(self.decoder.parameters()) +
+ list(self.pre_vq_conv.parameters()) +
+ list(self.post_vq_conv.parameters()) +
+ list(self.codebook.parameters()),
+ lr=lr, betas=(0.5, 0.9))
+ opt_disc = torch.optim.Adam(list(self.image_discriminator.parameters()) +
+ list(self.video_discriminator.parameters()),
+ lr=lr, betas=(0.5, 0.9))
+ return [opt_ae, opt_disc], []
+
+ def log_images(self, batch, **kwargs):
+ log = dict()
+ x = batch['image']
+ x = x.to(self.device)
+ frames, frames_rec, _, _ = self(x, log_image=True)
+ log["inputs"] = frames
+ log["reconstructions"] = frames_rec
+ #log['mean_org'] = batch['mean_org']
+ #log['std_org'] = batch['std_org']
+ return log
+
+ def log_videos(self, batch, **kwargs):
+ log = dict()
+ x = batch['image']
+ _, _, x, x_rec = self(x, log_image=True)
+ log["inputs"] = x
+ log["reconstructions"] = x_rec
+ #log['mean_org'] = batch['mean_org']
+ #log['std_org'] = batch['std_org']
+ return log
+
+
+def Normalize(in_channels, norm_type='group', num_groups=32):
+ assert norm_type in ['group', 'batch']
+ if norm_type == 'group':
+ # TODO Changed num_groups from 32 to 8
+ return torch.nn.GroupNorm(num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True)
+ elif norm_type == 'batch':
+ return torch.nn.SyncBatchNorm(in_channels)
+
+
+class Encoder(nn.Module):
+ def __init__(self, n_hiddens, downsample, image_channel=3, norm_type='group', padding_type='replicate', num_groups=32):
+ super().__init__()
+ n_times_downsample = np.array([int(math.log2(d)) for d in downsample])
+ self.conv_blocks = nn.ModuleList()
+ max_ds = n_times_downsample.max()
+
+ self.conv_first = SamePadConv3d(
+ image_channel, n_hiddens, kernel_size=3, padding_type=padding_type)
+
+ for i in range(max_ds):
+ block = nn.Module()
+ in_channels = n_hiddens * 2**i
+ out_channels = n_hiddens * 2**(i+1)
+ stride = tuple([2 if d > 0 else 1 for d in n_times_downsample])
+ block.down = SamePadConv3d(
+ in_channels, out_channels, 4, stride=stride, padding_type=padding_type)
+ block.res = ResBlock(
+ out_channels, out_channels, norm_type=norm_type, num_groups=num_groups)
+ self.conv_blocks.append(block)
+ n_times_downsample -= 1
+
+ self.final_block = nn.Sequential(
+ Normalize(out_channels, norm_type, num_groups=num_groups),
+ SiLU()
+ )
+
+ self.out_channels = out_channels
+
+ def forward(self, x):
+ h = self.conv_first(x)
+ for block in self.conv_blocks:
+ h = block.down(h)
+ h = block.res(h)
+ h = self.final_block(h)
+ return h
+
+
+class Decoder(nn.Module):
+ def __init__(self, n_hiddens, upsample, image_channel, norm_type='group', num_groups=32):
+ super().__init__()
+
+ n_times_upsample = np.array([int(math.log2(d)) for d in upsample])
+ max_us = n_times_upsample.max()
+
+ in_channels = n_hiddens*2**max_us
+ self.final_block = nn.Sequential(
+ Normalize(in_channels, norm_type, num_groups=num_groups),
+ SiLU()
+ )
+
+ self.conv_blocks = nn.ModuleList()
+ for i in range(max_us):
+ block = nn.Module()
+ in_channels = in_channels if i == 0 else n_hiddens*2**(max_us-i+1)
+ out_channels = n_hiddens*2**(max_us-i)
+ us = tuple([2 if d > 0 else 1 for d in n_times_upsample])
+ block.up = SamePadConvTranspose3d(
+ in_channels, out_channels, 4, stride=us)
+ block.res1 = ResBlock(
+ out_channels, out_channels, norm_type=norm_type, num_groups=num_groups)
+ block.res2 = ResBlock(
+ out_channels, out_channels, norm_type=norm_type, num_groups=num_groups)
+ self.conv_blocks.append(block)
+ n_times_upsample -= 1
+
+ self.conv_last = SamePadConv3d(
+ out_channels, image_channel, kernel_size=3)
+
+ def forward(self, x):
+ h = self.final_block(x)
+ for i, block in enumerate(self.conv_blocks):
+ h = block.up(h)
+ h = block.res1(h)
+ h = block.res2(h)
+ h = self.conv_last(h)
+ return h
+
+
+class ResBlock(nn.Module):
+ def __init__(self, in_channels, out_channels=None, conv_shortcut=False, dropout=0.0, norm_type='group', padding_type='replicate', num_groups=32):
+ super().__init__()
+ self.in_channels = in_channels
+ out_channels = in_channels if out_channels is None else out_channels
+ self.out_channels = out_channels
+ self.use_conv_shortcut = conv_shortcut
+
+ self.norm1 = Normalize(in_channels, norm_type, num_groups=num_groups)
+ self.conv1 = SamePadConv3d(
+ in_channels, out_channels, kernel_size=3, padding_type=padding_type)
+ self.dropout = torch.nn.Dropout(dropout)
+ self.norm2 = Normalize(in_channels, norm_type, num_groups=num_groups)
+ self.conv2 = SamePadConv3d(
+ out_channels, out_channels, kernel_size=3, padding_type=padding_type)
+ if self.in_channels != self.out_channels:
+ self.conv_shortcut = SamePadConv3d(
+ in_channels, out_channels, kernel_size=3, padding_type=padding_type)
+
+ def forward(self, x):
+ h = x
+ h = self.norm1(h)
+ h = silu(h)
+ h = self.conv1(h)
+ h = self.norm2(h)
+ h = silu(h)
+ h = self.conv2(h)
+
+ if self.in_channels != self.out_channels:
+ x = self.conv_shortcut(x)
+
+ return x+h
+
+
+# Does not support dilation
+class SamePadConv3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, bias=True, padding_type='replicate'):
+ super().__init__()
+ if isinstance(kernel_size, int):
+ kernel_size = (kernel_size,) * 3
+ if isinstance(stride, int):
+ stride = (stride,) * 3
+
+ # assumes that the input shape is divisible by stride
+ total_pad = tuple([k - s for k, s in zip(kernel_size, stride)])
+ pad_input = []
+ for p in total_pad[::-1]: # reverse since F.pad starts from last dim
+ pad_input.append((p // 2 + p % 2, p // 2))
+ pad_input = sum(pad_input, tuple())
+ self.pad_input = pad_input
+ self.padding_type = padding_type
+
+ self.conv = nn.Conv3d(in_channels, out_channels, kernel_size,
+ stride=stride, padding=0, bias=bias)
+
+ def forward(self, x):
+ return self.conv(F.pad(x, self.pad_input, mode=self.padding_type))
+
+
+class SamePadConvTranspose3d(nn.Module):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, bias=True, padding_type='replicate'):
+ super().__init__()
+ if isinstance(kernel_size, int):
+ kernel_size = (kernel_size,) * 3
+ if isinstance(stride, int):
+ stride = (stride,) * 3
+
+ total_pad = tuple([k - s for k, s in zip(kernel_size, stride)])
+ pad_input = []
+ for p in total_pad[::-1]: # reverse since F.pad starts from last dim
+ pad_input.append((p // 2 + p % 2, p // 2))
+ pad_input = sum(pad_input, tuple())
+ self.pad_input = pad_input
+ self.padding_type = padding_type
+
+ self.convt = nn.ConvTranspose3d(in_channels, out_channels, kernel_size,
+ stride=stride, bias=bias,
+ padding=tuple([k - 1 for k in kernel_size]))
+
+ def forward(self, x):
+ return self.convt(F.pad(x, self.pad_input, mode=self.padding_type))
+
+
+class NLayerDiscriminator(nn.Module):
+ def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.SyncBatchNorm, use_sigmoid=False, getIntermFeat=True):
+ # def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_sigmoid=False, getIntermFeat=True):
+ super(NLayerDiscriminator, self).__init__()
+ self.getIntermFeat = getIntermFeat
+ self.n_layers = n_layers
+
+ kw = 4
+ padw = int(np.ceil((kw-1.0)/2))
+ sequence = [[nn.Conv2d(input_nc, ndf, kernel_size=kw,
+ stride=2, padding=padw), nn.LeakyReLU(0.2, True)]]
+
+ nf = ndf
+ for n in range(1, n_layers):
+ nf_prev = nf
+ nf = min(nf * 2, 512)
+ sequence += [[
+ nn.Conv2d(nf_prev, nf, kernel_size=kw, stride=2, padding=padw),
+ norm_layer(nf), nn.LeakyReLU(0.2, True)
+ ]]
+
+ nf_prev = nf
+ nf = min(nf * 2, 512)
+ sequence += [[
+ nn.Conv2d(nf_prev, nf, kernel_size=kw, stride=1, padding=padw),
+ norm_layer(nf),
+ nn.LeakyReLU(0.2, True)
+ ]]
+
+ sequence += [[nn.Conv2d(nf, 1, kernel_size=kw,
+ stride=1, padding=padw)]]
+
+ if use_sigmoid:
+ sequence += [[nn.Sigmoid()]]
+
+ if getIntermFeat:
+ for n in range(len(sequence)):
+ setattr(self, 'model'+str(n), nn.Sequential(*sequence[n]))
+ else:
+ sequence_stream = []
+ for n in range(len(sequence)):
+ sequence_stream += sequence[n]
+ self.model = nn.Sequential(*sequence_stream)
+
+ def forward(self, input):
+ if self.getIntermFeat:
+ res = [input]
+ for n in range(self.n_layers+2):
+ model = getattr(self, 'model'+str(n))
+ res.append(model(res[-1]))
+ return res[-1], res[1:]
+ else:
+ return self.model(input), _
+
+
+class NLayerDiscriminator3D(nn.Module):
+ def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.SyncBatchNorm, use_sigmoid=False, getIntermFeat=True):
+ super(NLayerDiscriminator3D, self).__init__()
+ self.getIntermFeat = getIntermFeat
+ self.n_layers = n_layers
+
+ kw = 4
+ padw = int(np.ceil((kw-1.0)/2))
+ sequence = [[nn.Conv3d(input_nc, ndf, kernel_size=kw,
+ stride=2, padding=padw), nn.LeakyReLU(0.2, True)]]
+
+ nf = ndf
+ for n in range(1, n_layers):
+ nf_prev = nf
+ nf = min(nf * 2, 512)
+ sequence += [[
+ nn.Conv3d(nf_prev, nf, kernel_size=kw, stride=2, padding=padw),
+ norm_layer(nf), nn.LeakyReLU(0.2, True)
+ ]]
+
+ nf_prev = nf
+ nf = min(nf * 2, 512)
+ sequence += [[
+ nn.Conv3d(nf_prev, nf, kernel_size=kw, stride=1, padding=padw),
+ norm_layer(nf),
+ nn.LeakyReLU(0.2, True)
+ ]]
+
+ sequence += [[nn.Conv3d(nf, 1, kernel_size=kw,
+ stride=1, padding=padw)]]
+
+ if use_sigmoid:
+ sequence += [[nn.Sigmoid()]]
+
+ if getIntermFeat:
+ for n in range(len(sequence)):
+ setattr(self, 'model'+str(n), nn.Sequential(*sequence[n]))
+ else:
+ sequence_stream = []
+ for n in range(len(sequence)):
+ sequence_stream += sequence[n]
+ self.model = nn.Sequential(*sequence_stream)
+
+ def forward(self, input):
+ if self.getIntermFeat:
+ res = [input]
+ for n in range(self.n_layers+2):
+ model = getattr(self, 'model'+str(n))
+ res.append(model(res[-1]))
+ return res[-1], res[1:]
+ else:
+ return self.model(input), _

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/ldm/vq_gan_3d/utils.py

@@ -0,0 +1,177 @@
+""" Adapted from https://github.com/SongweiGe/TATS"""
+# Copyright (c) Meta Platforms, Inc. All Rights Reserved
+
+import warnings
+import torch
+import imageio
+
+import math
+import numpy as np
+
+import sys
+import pdb as pdb_original
+import logging
+
+import imageio.core.util
+logging.getLogger("imageio_ffmpeg").setLevel(logging.ERROR)
+
+
+class ForkedPdb(pdb_original.Pdb):
+ """A Pdb subclass that may be used
+ from a forked multiprocessing child
+
+ """
+
+ def interaction(self, *args, **kwargs):
+ _stdin = sys.stdin
+ try:
+ sys.stdin = open('/dev/stdin')
+ pdb_original.Pdb.interaction(self, *args, **kwargs)
+ finally:
+ sys.stdin = _stdin
+
+
+# Shifts src_tf dim to dest dim
+# i.e. shift_dim(x, 1, -1) would be (b, c, t, h, w) -> (b, t, h, w, c)
+def shift_dim(x, src_dim=-1, dest_dim=-1, make_contiguous=True):
+ n_dims = len(x.shape)
+ if src_dim < 0:
+ src_dim = n_dims + src_dim
+ if dest_dim < 0:
+ dest_dim = n_dims + dest_dim
+
+ assert 0 <= src_dim < n_dims and 0 <= dest_dim < n_dims
+
+ dims = list(range(n_dims))
+ del dims[src_dim]
+
+ permutation = []
+ ctr = 0
+ for i in range(n_dims):
+ if i == dest_dim:
+ permutation.append(src_dim)
+ else:
+ permutation.append(dims[ctr])
+ ctr += 1
+ x = x.permute(permutation)
+ if make_contiguous:
+ x = x.contiguous()
+ return x
+
+
+# reshapes tensor start from dim i (inclusive)
+# to dim j (exclusive) to the desired shape
+# e.g. if x.shape = (b, thw, c) then
+# view_range(x, 1, 2, (t, h, w)) returns
+# x of shape (b, t, h, w, c)
+def view_range(x, i, j, shape):
+ shape = tuple(shape)
+
+ n_dims = len(x.shape)
+ if i < 0:
+ i = n_dims + i
+
+ if j is None:
+ j = n_dims
+ elif j < 0:
+ j = n_dims + j
+
+ assert 0 <= i < j <= n_dims
+
+ x_shape = x.shape
+ target_shape = x_shape[:i] + shape + x_shape[j:]
+ return x.view(target_shape)
+
+
+def accuracy(output, target, topk=(1,)):
+ """Computes the accuracy over the k top predictions for the specified values of k"""
+ with torch.no_grad():
+ maxk = max(topk)
+ batch_size = target.size(0)
+
+ _, pred = output.topk(maxk, 1, True, True)
+ pred = pred.t()
+ correct = pred.eq(target.reshape(1, -1).expand_as(pred))
+
+ res = []
+ for k in topk:
+ correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)
+ res.append(correct_k.mul_(100.0 / batch_size))
+ return res
+
+
+def tensor_slice(x, begin, size):
+ assert all([b >= 0 for b in begin])
+ size = [l - b if s == -1 else s
+ for s, b, l in zip(size, begin, x.shape)]
+ assert all([s >= 0 for s in size])
+
+ slices = [slice(b, b + s) for b, s in zip(begin, size)]
+ return x[slices]
+
+
+def adopt_weight(global_step, threshold=0, value=0.):
+ weight = 1
+ if global_step < threshold:
+ weight = value
+ return weight
+
+
+def save_video_grid(video, fname, nrow=None, fps=6):
+ b, c, t, h, w = video.shape
+ video = video.permute(0, 2, 3, 4, 1)
+ video = (video.cpu().numpy() * 255).astype('uint8')
+ if nrow is None:
+ nrow = math.ceil(math.sqrt(b))
+ ncol = math.ceil(b / nrow)
+ padding = 1
+ video_grid = np.zeros((t, (padding + h) * nrow + padding,
+ (padding + w) * ncol + padding, c), dtype='uint8')
+ for i in range(b):
+ r = i // ncol
+ c = i % ncol
+ start_r = (padding + h) * r
+ start_c = (padding + w) * c
+ video_grid[:, start_r:start_r + h, start_c:start_c + w] = video[i]
+ video = []
+ for i in range(t):
+ video.append(video_grid[i])
+ imageio.mimsave(fname, video, fps=fps)
+ ## skvideo.io.vwrite(fname, video_grid, inputdict={'-r': '5'})
+ #print('saved videos to', fname)
+
+
+def comp_getattr(args, attr_name, default=None):
+ if hasattr(args, attr_name):
+ return getattr(args, attr_name)
+ else:
+ return default
+
+
+def visualize_tensors(t, name=None, nest=0):
+ if name is not None:
+ print(name, "current nest: ", nest)
+ print("type: ", type(t))
+ if 'dict' in str(type(t)):
+ print(t.keys())
+ for k in t.keys():
+ if t[k] is None:
+ print(k, "None")
+ else:
+ if 'Tensor' in str(type(t[k])):
+ print(k, t[k].shape)
+ elif 'dict' in str(type(t[k])):
+ print(k, 'dict')
+ visualize_tensors(t[k], name, nest + 1)
+ elif 'list' in str(type(t[k])):
+ print(k, len(t[k]))
+ visualize_tensors(t[k], name, nest + 1)
+ elif 'list' in str(type(t)):
+ print("list length: ", len(t))
+ for t2 in t:
+ visualize_tensors(t2, name, nest + 1)
+ elif 'Tensor' in str(type(t)):
+ print(t.shape)
+ else:
+ print(t)
+ return ""

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/model_weight/diff_kidney_fold0_early.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d889b3561803f7490f4050c03a02163f099633e4f00fea4cb10b5b993685e5cc
+size 290138333

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/model_weight/diff_kidney_fold0_noearly_t200.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26bc7847ae15377a5586535cbb2e6a1ec5b6a98732f7f795c284d7dcda208c97
+size 290156765

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/model_weight/diff_liver_fold0_early.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0135000f031f741252b3e706748b674d33e7278402a7cb2500fec5f4966847bd
+size 290138333

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/model_weight/diff_liver_fold0_noearly_t200.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2a21980e53efd6758ae92e79a82668f0e1e6d9b52fdf6b2a709cb929ebedb3b
+size 290156765

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/model_weight/diff_pancreas_fold0_early.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9438e39a44af92bb0fbaf5cc50a3ac3aaa260978a69ac341ed7ec23512c080a5
+size 290138333

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/model_weight/diff_pancreas_fold0_noearly_t200.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb37011840156f548fd2348dbb5578f9bc81de16719ec226fbef2de6f0244f9d
+size 290156765

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/model_weight/recon_96d4_all.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ef88523af9590a7325bc9ca41999de191c3fbc41afc6186a8c4db5528446bb1f
+size 242615727

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/utils.py

@@ -0,0 +1,465 @@
+### Tumor Generateion
+import random
+import cv2
+import elasticdeform
+import numpy as np
+from scipy.ndimage import gaussian_filter
+from TumorGeneration.ldm.ddpm.ddim import DDIMSampler
+
+# Step 1: Random select (numbers) location for tumor.
+def random_select(mask_scan, organ_type):
+ # we first find z index and then sample point with z slice
+ # print('mask_scan',np.unique(mask_scan))
+ # print('pixel num', (mask_scan == 1).sum())
+ z_start, z_end = np.where(np.any(mask_scan, axis=(0, 1)))[0].min(), np.where(np.any(mask_scan, axis=(0, 1)))[0].max()
+ # print('z_start, z_end',z_start, z_end)
+ # we need to strict number z's position (0.3 - 0.7 in the middle of liver)
+ while 1:
+ z = round(random.uniform(0.3, 0.7) * (z_end - z_start)) + z_start
+ liver_mask = mask_scan[..., z]
+ # erode the mask (we don't want the edge points)
+ if organ_type == 'liver':
+ kernel = np.ones((5,5), dtype=np.uint8)
+ liver_mask = cv2.erode(liver_mask, kernel, iterations=1)
+ if (liver_mask == 1).sum() > 0:
+ break
+
+ 
+
+ # print('liver_mask', (liver_mask == 1).sum())
+ coordinates = np.argwhere(liver_mask == 1)
+ random_index = np.random.randint(0, len(coordinates))
+ xyz = coordinates[random_index].tolist() # get x,y
+ xyz.append(z)
+ potential_points = xyz
+
+ return potential_points
+
+def center_select(mask_scan):
+ z_start, z_end = np.where(np.any(mask_scan, axis=(0, 1)))[0].min(), np.where(np.any(mask_scan, axis=(0, 1)))[0].max()
+ x_start, x_end = np.where(np.any(mask_scan, axis=(1, 2)))[0].min(), np.where(np.any(mask_scan, axis=(1, 2)))[0].max()
+ y_start, y_end = np.where(np.any(mask_scan, axis=(0, 2)))[0].min(), np.where(np.any(mask_scan, axis=(0, 2)))[0].max()
+
+ z = round(0.5 * (z_end - z_start)) + z_start
+ x = round(0.5 * (x_end - x_start)) + x_start
+ y = round(0.5 * (y_end - y_start)) + y_start
+
+ xyz = [x, y, z]
+ potential_points = xyz
+
+ return potential_points
+
+# Step 2 : generate the ellipsoid
+def get_ellipsoid(x, y, z):
+ """"
+ x, y, z is the radius of this ellipsoid in x, y, z direction respectly.
+ """
+ sh = (4*x, 4*y, 4*z)
+ out = np.zeros(sh, int)
+ aux = np.zeros(sh)
+ radii = np.array([x, y, z])
+ com = np.array([2*x, 2*y, 2*z]) # center point
+
+ # calculate the ellipsoid 
+ bboxl = np.floor(com-radii).clip(0,None).astype(int)
+ bboxh = (np.ceil(com+radii)+1).clip(None, sh).astype(int)
+ roi = out[tuple(map(slice,bboxl,bboxh))]
+ roiaux = aux[tuple(map(slice,bboxl,bboxh))]
+ logrid = *map(np.square,np.ogrid[tuple(
+ map(slice,(bboxl-com)/radii,(bboxh-com-1)/radii,1j*(bboxh-bboxl)))]),
+ dst = (1-sum(logrid)).clip(0,None)
+ mask = dst>roiaux
+ roi[mask] = 1
+ np.copyto(roiaux,dst,where=mask)
+
+ return out
+
+def get_fixed_geo(mask_scan, tumor_type, organ_type):
+ if tumor_type == 'large':
+ enlarge_x, enlarge_y, enlarge_z = 280, 280, 280
+ else:
+ enlarge_x, enlarge_y, enlarge_z = 160, 160, 160
+ geo_mask = np.zeros((mask_scan.shape[0] + enlarge_x, mask_scan.shape[1] + enlarge_y, mask_scan.shape[2] + enlarge_z), dtype=np.int8)
+ tiny_radius, small_radius, medium_radius, large_radius = 4, 8, 16, 32
+
+ if tumor_type == 'tiny':
+ num_tumor = random.randint(1,3)
+ # num_tumor = 1
+ for _ in range(num_tumor):
+ # Tiny tumor
+ x = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ y = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ z = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ sigma = random.uniform(0.5,1)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ point = random_select(mask_scan, organ_type)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+
+ if tumor_type == 'small':
+ num_tumor = random.randint(1,3)
+ # num_tumor = 1
+ for _ in range(num_tumor):
+ # Small tumor
+ x = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ y = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ z = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ sigma = random.randint(1, 2)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan, organ_type)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+
+ if tumor_type == 'medium':
+ # num_tumor = random.randint(1, 3)
+ num_tumor = 1
+ for _ in range(num_tumor):
+ # medium tumor
+ x = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ y = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ z = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ sigma = random.randint(3, 6)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan, organ_type)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste medium tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+
+ if tumor_type == 'large':
+ num_tumor = 1 # random.randint(1,3)
+ for _ in range(num_tumor):
+ # Large tumor
+ 
+ x = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ y = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ z = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ sigma = random.randint(5, 10)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ if organ_type == 'liver' or organ_type == 'kidney' :
+ point = random_select(mask_scan, organ_type)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ else:
+ x_start, x_end = np.where(np.any(geo, axis=(1, 2)))[0].min(), np.where(np.any(geo, axis=(1, 2)))[0].max()
+ y_start, y_end = np.where(np.any(geo, axis=(0, 2)))[0].min(), np.where(np.any(geo, axis=(0, 2)))[0].max()
+ z_start, z_end = np.where(np.any(geo, axis=(0, 1)))[0].min(), np.where(np.any(geo, axis=(0, 1)))[0].max()
+ geo = geo[x_start:x_end, y_start:y_end, z_start:z_end]
+
+ point = center_select(mask_scan)
+
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low = new_point[0] - geo.shape[0]//2
+ y_low = new_point[1] - geo.shape[1]//2
+ z_low = new_point[2] - geo.shape[2]//2
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_low+geo.shape[0], y_low:y_low+geo.shape[1], z_low:z_low+geo.shape[2]] += geo
+ 
+ geo_mask = geo_mask[enlarge_x//2:-enlarge_x//2, enlarge_y//2:-enlarge_y//2, enlarge_z//2:-enlarge_z//2]
+ # texture_map = texture_map[enlarge_x//2:-enlarge_x//2, enlarge_y//2:-enlarge_y//2, enlarge_z//2:-enlarge_z//2]
+ if ((tumor_type == 'medium') or (tumor_type == 'large')) and (organ_type == 'kidney'):
+ if random.random() > 0.5:
+ geo_mask = (geo_mask>=1)
+ else:
+ geo_mask = (geo_mask * mask_scan) >=1
+ else:
+ geo_mask = (geo_mask * mask_scan) >=1
+
+ return geo_mask
+
+
+from .ldm.vq_gan_3d.model.vqgan import VQGAN
+import matplotlib.pyplot as plt
+import SimpleITK as sitk
+from .ldm.ddpm import Unet3D, GaussianDiffusion, Tester
+from hydra import initialize, compose
+import torch
+import yaml
+def synt_model_prepare(device, vqgan_ckpt='TumorGeneration/model_weight/recon_96d4_all.ckpt', diffusion_ckpt='TumorGeneration/model_weight/', fold=0, organ='liver'):
+ with initialize(config_path="diffusion_config/"):
+ cfg=compose(config_name="ddpm.yaml")
+ print('diffusion_ckpt',diffusion_ckpt)
+ vqgan = VQGAN.load_from_checkpoint(vqgan_ckpt)
+ vqgan = vqgan.to(device)
+ vqgan.eval()
+ 
+ early_Unet3D = Unet3D(
+ dim=cfg.diffusion_img_size,
+ dim_mults=cfg.dim_mults,
+ channels=cfg.diffusion_num_channels,
+ out_dim=cfg.out_dim
+ ).to(device)
+
+ early_diffusion = GaussianDiffusion(
+ early_Unet3D,
+ vqgan_ckpt= vqgan_ckpt, # cfg.vqgan_ckpt,
+ image_size=cfg.diffusion_img_size,
+ num_frames=cfg.diffusion_depth_size,
+ channels=cfg.diffusion_num_channels,
+ timesteps=4, # cfg.timesteps,
+ loss_type=cfg.loss_type,
+ device=device
+ ).to(device)
+ 
+ noearly_Unet3D = Unet3D(
+ dim=cfg.diffusion_img_size,
+ dim_mults=cfg.dim_mults,
+ channels=cfg.diffusion_num_channels,
+ out_dim=cfg.out_dim
+ ).to(device)
+ 
+ noearly_diffusion = GaussianDiffusion(
+ noearly_Unet3D,
+ vqgan_ckpt= vqgan_ckpt, # cfg.vqgan_ckpt,
+ image_size=cfg.diffusion_img_size,
+ num_frames=cfg.diffusion_depth_size,
+ channels=cfg.diffusion_num_channels,
+ timesteps=200, # cfg.timesteps,
+ loss_type=cfg.loss_type,
+ device=device
+ ).to(device)
+ 
+ early_tester = Tester(early_diffusion)
+ # noearly_tester = Tester(noearly_diffusion)
+ early_tester.load(diffusion_ckpt+'diff_{}_fold{}_early.pt'.format(organ, fold), map_location=device)
+ # noearly_tester.load(diffusion_ckpt+'diff_liver_fold{}_noearly_t200.pt'.format(fold), map_location=device)
+
+ # early_checkpoint = torch.load(diffusion_ckpt+'diff_liver_fold{}_early.pt'.format(fold), map_location=device)
+ noearly_checkpoint = torch.load(diffusion_ckpt+'diff_{}_fold{}_noearly_t200.pt'.format(organ, fold), map_location=device)
+ # early_diffusion.load_state_dict(early_checkpoint['ema'])
+ noearly_diffusion.load_state_dict(noearly_checkpoint['ema'])
+ # early_sampler = DDIMSampler(early_diffusion, schedule="cosine")
+ noearly_sampler = DDIMSampler(noearly_diffusion, schedule="cosine")
+ # breakpoint()
+ return vqgan, early_tester, noearly_sampler
+
+def synthesize_early_tumor(ct_volume, organ_mask, organ_type, vqgan, tester):
+ device=ct_volume.device
+
+ # generate tumor mask
+ tumor_types = ['tiny', 'small']
+ # tumor_probs = np.array([0.5, 0.5])
+ tumor_probs = np.array([0.2, 0.8])
+ total_tumor_mask = []
+ organ_mask_np = organ_mask.cpu().numpy()
+ with torch.no_grad():
+ # get model input
+ for bs in range(organ_mask_np.shape[0]):
+ synthetic_tumor_type = np.random.choice(tumor_types, p=tumor_probs.ravel())
+ tumor_mask = get_fixed_geo(organ_mask_np[bs,0], synthetic_tumor_type, organ_type)
+ total_tumor_mask.append(torch.from_numpy(tumor_mask)[None,:])
+ total_tumor_mask = torch.stack(total_tumor_mask, dim=0).to(dtype=torch.float32, device=device)
+
+ volume = ct_volume*2.0 - 1.0
+ mask = total_tumor_mask*2.0 - 1.0
+ mask_ = 1-total_tumor_mask
+ masked_volume = (volume*mask_).detach()
+ 
+ volume = volume.permute(0,1,-1,-3,-2)
+ masked_volume = masked_volume.permute(0,1,-1,-3,-2)
+ mask = mask.permute(0,1,-1,-3,-2)
+
+ # vqgan encoder inference
+ masked_volume_feat = vqgan.encode(masked_volume, quantize=False, include_embeddings=True)
+ masked_volume_feat = ((masked_volume_feat - vqgan.codebook.embeddings.min()) /
+ (vqgan.codebook.embeddings.max() - vqgan.codebook.embeddings.min())) * 2.0 - 1.0
+ 
+ cc = torch.nn.functional.interpolate(mask, size=masked_volume_feat.shape[-3:])
+ cond = torch.cat((masked_volume_feat, cc), dim=1)
+
+ # diffusion inference and decoder
+ tester.ema_model.eval()
+ sample = tester.ema_model.sample(batch_size=volume.shape[0], cond=cond)
+
+ # if organ_type == 'liver' or organ_type == 'kidney' :
+
+ mask_01 = torch.clamp((mask+1.0)/2.0, min=0.0, max=1.0)
+ sigma = np.random.uniform(0, 4) # (1, 2)
+ mask_01_np_blur = gaussian_filter(mask_01.cpu().numpy()*1.0, sigma=[0,0,sigma,sigma,sigma])
+ # mask_01_np_blur = mask_01_np_blur*mask_01.cpu().numpy()
+
+ volume_ = torch.clamp((volume+1.0)/2.0, min=0.0, max=1.0)
+ sample_ = torch.clamp((sample+1.0)/2.0, min=0.0, max=1.0)
+
+ mask_01_blur = torch.from_numpy(mask_01_np_blur).to(device=device)
+ final_volume_ = (1-mask_01_blur)*volume_ +mask_01_blur*sample_
+ final_volume_ = torch.clamp(final_volume_, min=0.0, max=1.0)
+ # elif organ_type == 'pancreas':
+ # final_volume_ = (sample+1.0)/2.0
+ final_volume_ = final_volume_.permute(0,1,-2,-1,-3)
+ organ_tumor_mask = torch.ones_like(organ_mask)
+ organ_tumor_mask[total_tumor_mask==1] = 2
+
+ return final_volume_, organ_tumor_mask
+
+def synthesize_medium_tumor(ct_volume, organ_mask, organ_type, vqgan, sampler, ddim_ts=50):
+ device=ct_volume.device
+
+ # generate tumor mask
+ # tumor_types = ['large']
+ # tumor_probs = np.array([1.0])
+ total_tumor_mask = []
+ organ_mask_np = organ_mask.cpu().numpy()
+ with torch.no_grad():
+ # get model input
+ for bs in range(organ_mask_np.shape[0]):
+ # synthetic_tumor_type = np.random.choice(tumor_types, p=tumor_probs.ravel())
+ synthetic_tumor_type = 'medium'
+ tumor_mask = get_fixed_geo(organ_mask_np[bs,0], synthetic_tumor_type, organ_type)
+ total_tumor_mask.append(torch.from_numpy(tumor_mask)[None,:])
+ total_tumor_mask = torch.stack(total_tumor_mask, dim=0).to(dtype=torch.float32, device=device)
+
+ volume = ct_volume*2.0 - 1.0
+ mask = total_tumor_mask*2.0 - 1.0
+ mask_ = 1-total_tumor_mask
+ masked_volume = (volume*mask_).detach()
+ 
+ volume = volume.permute(0,1,-1,-3,-2)
+ masked_volume = masked_volume.permute(0,1,-1,-3,-2)
+ mask = mask.permute(0,1,-1,-3,-2)
+
+ # vqgan encoder inference
+ masked_volume_feat = vqgan.encode(masked_volume, quantize=False, include_embeddings=True)
+ masked_volume_feat = ((masked_volume_feat - vqgan.codebook.embeddings.min()) /
+ (vqgan.codebook.embeddings.max() - vqgan.codebook.embeddings.min())) * 2.0 - 1.0
+ 
+ cc = torch.nn.functional.interpolate(mask, size=masked_volume_feat.shape[-3:])
+ cond = torch.cat((masked_volume_feat, cc), dim=1)
+
+ # diffusion inference and decoder
+ shape = masked_volume_feat.shape[-4:]
+ samples_ddim, _ = sampler.sample(S=ddim_ts,
+ conditioning=cond,
+ batch_size=1,
+ shape=shape,
+ verbose=False)
+ samples_ddim = (((samples_ddim + 1.0) / 2.0) * (vqgan.codebook.embeddings.max() -
+ vqgan.codebook.embeddings.min())) + vqgan.codebook.embeddings.min()
+
+ sample = vqgan.decode(samples_ddim, quantize=True)
+ 
+ # if organ_type == 'liver' or organ_type == 'kidney':
+ # post-process
+ mask_01 = torch.clamp((mask+1.0)/2.0, min=0.0, max=1.0)
+ sigma = np.random.uniform(0, 4) # (1, 2)
+ mask_01_np_blur = gaussian_filter(mask_01.cpu().numpy()*1.0, sigma=[0,0,sigma,sigma,sigma])
+ # mask_01_np_blur = mask_01_np_blur*mask_01.cpu().numpy()
+
+ volume_ = torch.clamp((volume+1.0)/2.0, min=0.0, max=1.0)
+ sample_ = torch.clamp((sample+1.0)/2.0, min=0.0, max=1.0)
+
+ mask_01_blur = torch.from_numpy(mask_01_np_blur).to(device=device)
+ final_volume_ = (1-mask_01_blur)*volume_ +mask_01_blur*sample_
+ final_volume_ = torch.clamp(final_volume_, min=0.0, max=1.0)
+ # elif organ_type == 'pancreas':
+ # final_volume_ = (sample+1.0)/2.0
+
+ final_volume_ = final_volume_.permute(0,1,-2,-1,-3)
+ organ_tumor_mask = torch.ones_like(organ_mask)
+ organ_tumor_mask[total_tumor_mask==1] = 2
+
+ return final_volume_, organ_tumor_mask
+
+def synthesize_large_tumor(ct_volume, organ_mask, organ_type, vqgan, sampler, ddim_ts=50):
+ device=ct_volume.device
+
+ # generate tumor mask
+ # tumor_types = ['large']
+ # tumor_probs = np.array([1.0])
+ total_tumor_mask = []
+ organ_mask_np = organ_mask.cpu().numpy()
+ with torch.no_grad():
+ # get model input
+ for bs in range(organ_mask_np.shape[0]):
+ # synthetic_tumor_type = np.random.choice(tumor_types, p=tumor_probs.ravel())
+ synthetic_tumor_type = 'large'
+ tumor_mask = get_fixed_geo(organ_mask_np[bs,0], synthetic_tumor_type, organ_type)
+ total_tumor_mask.append(torch.from_numpy(tumor_mask)[None,:])
+ total_tumor_mask = torch.stack(total_tumor_mask, dim=0).to(dtype=torch.float32, device=device)
+
+ volume = ct_volume*2.0 - 1.0
+ mask = total_tumor_mask*2.0 - 1.0
+ mask_ = 1-total_tumor_mask
+ masked_volume = (volume*mask_).detach()
+ 
+ volume = volume.permute(0,1,-1,-3,-2)
+ masked_volume = masked_volume.permute(0,1,-1,-3,-2)
+ mask = mask.permute(0,1,-1,-3,-2)
+
+ # vqgan encoder inference
+ masked_volume_feat = vqgan.encode(masked_volume, quantize=False, include_embeddings=True)
+ masked_volume_feat = ((masked_volume_feat - vqgan.codebook.embeddings.min()) /
+ (vqgan.codebook.embeddings.max() - vqgan.codebook.embeddings.min())) * 2.0 - 1.0
+ 
+ cc = torch.nn.functional.interpolate(mask, size=masked_volume_feat.shape[-3:])
+ cond = torch.cat((masked_volume_feat, cc), dim=1)
+
+ # diffusion inference and decoder
+ shape = masked_volume_feat.shape[-4:]
+ samples_ddim, _ = sampler.sample(S=ddim_ts,
+ conditioning=cond,
+ batch_size=1,
+ shape=shape,
+ verbose=False)
+ samples_ddim = (((samples_ddim + 1.0) / 2.0) * (vqgan.codebook.embeddings.max() -
+ vqgan.codebook.embeddings.min())) + vqgan.codebook.embeddings.min()
+
+ sample = vqgan.decode(samples_ddim, quantize=True)
+
+ # if organ_type == 'liver' or organ_type == 'kidney':
+ # post-process
+ mask_01 = torch.clamp((mask+1.0)/2.0, min=0.0, max=1.0)
+ sigma = np.random.uniform(0, 4) # (1, 2)
+ mask_01_np_blur = gaussian_filter(mask_01.cpu().numpy()*1.0, sigma=[0,0,sigma,sigma,sigma])
+ # mask_01_np_blur = mask_01_np_blur*mask_01.cpu().numpy()
+
+ volume_ = torch.clamp((volume+1.0)/2.0, min=0.0, max=1.0)
+ sample_ = torch.clamp((sample+1.0)/2.0, min=0.0, max=1.0)
+
+ mask_01_blur = torch.from_numpy(mask_01_np_blur).to(device=device)
+ final_volume_ = (1-mask_01_blur)*volume_ +mask_01_blur*sample_
+ final_volume_ = torch.clamp(final_volume_, min=0.0, max=1.0)
+ # elif organ_type == 'pancreas':
+ # final_volume_ = (sample+1.0)/2.0
+ 
+ final_volume_ = final_volume_.permute(0,1,-2,-1,-3)
+ organ_tumor_mask = torch.ones_like(organ_mask)
+ organ_tumor_mask[total_tumor_mask==1] = 2
+
+ return final_volume_, organ_tumor_mask

Generation_Pipeline_filter_all2/syn_pancreas/TumorGeneration/utils_.py

@@ -0,0 +1,298 @@
+### Tumor Generateion
+import random
+import cv2
+import elasticdeform
+import numpy as np
+from scipy.ndimage import gaussian_filter
+
+# Step 1: Random select (numbers) location for tumor.
+def random_select(mask_scan):
+ # we first find z index and then sample point with z slice
+ z_start, z_end = np.where(np.any(mask_scan, axis=(0, 1)))[0][[0, -1]]
+
+ # we need to strict number z's position (0.3 - 0.7 in the middle of liver)
+ z = round(random.uniform(0.3, 0.7) * (z_end - z_start)) + z_start
+
+ liver_mask = mask_scan[..., z]
+
+ # erode the mask (we don't want the edge points)
+ kernel = np.ones((5,5), dtype=np.uint8)
+ liver_mask = cv2.erode(liver_mask, kernel, iterations=1)
+
+ coordinates = np.argwhere(liver_mask == 1)
+ random_index = np.random.randint(0, len(coordinates))
+ xyz = coordinates[random_index].tolist() # get x,y
+ xyz.append(z)
+ potential_points = xyz
+
+ return potential_points
+
+# Step 2 : generate the ellipsoid
+def get_ellipsoid(x, y, z):
+ """"
+ x, y, z is the radius of this ellipsoid in x, y, z direction respectly.
+ """
+ sh = (4*x, 4*y, 4*z)
+ out = np.zeros(sh, int)
+ aux = np.zeros(sh)
+ radii = np.array([x, y, z])
+ com = np.array([2*x, 2*y, 2*z]) # center point
+
+ # calculate the ellipsoid 
+ bboxl = np.floor(com-radii).clip(0,None).astype(int)
+ bboxh = (np.ceil(com+radii)+1).clip(None, sh).astype(int)
+ roi = out[tuple(map(slice,bboxl,bboxh))]
+ roiaux = aux[tuple(map(slice,bboxl,bboxh))]
+ logrid = *map(np.square,np.ogrid[tuple(
+ map(slice,(bboxl-com)/radii,(bboxh-com-1)/radii,1j*(bboxh-bboxl)))]),
+ dst = (1-sum(logrid)).clip(0,None)
+ mask = dst>roiaux
+ roi[mask] = 1
+ np.copyto(roiaux,dst,where=mask)
+
+ return out
+
+def get_fixed_geo(mask_scan, tumor_type):
+
+ enlarge_x, enlarge_y, enlarge_z = 160, 160, 160
+ geo_mask = np.zeros((mask_scan.shape[0] + enlarge_x, mask_scan.shape[1] + enlarge_y, mask_scan.shape[2] + enlarge_z), dtype=np.int8)
+ tiny_radius, small_radius, medium_radius, large_radius = 4, 8, 16, 32
+
+ if tumor_type == 'tiny':
+ num_tumor = random.randint(3,10)
+ for _ in range(num_tumor):
+ # Tiny tumor
+ x = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ y = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ z = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ sigma = random.uniform(0.5,1)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+
+ if tumor_type == 'small':
+ num_tumor = random.randint(3,10)
+ for _ in range(num_tumor):
+ # Small tumor
+ x = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ y = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ z = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ sigma = random.randint(1, 2)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+
+ if tumor_type == 'medium':
+ num_tumor = random.randint(2, 5)
+ for _ in range(num_tumor):
+ # medium tumor
+ x = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ y = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ z = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ sigma = random.randint(3, 6)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste medium tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+
+ if tumor_type == 'large':
+ num_tumor = random.randint(1,3)
+ for _ in range(num_tumor):
+ # Large tumor
+ x = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ y = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ z = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ sigma = random.randint(5, 10)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+
+ if tumor_type == "mix":
+ # tiny
+ num_tumor = random.randint(3,10)
+ for _ in range(num_tumor):
+ # Tiny tumor
+ x = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ y = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ z = random.randint(int(0.75*tiny_radius), int(1.25*tiny_radius))
+ sigma = random.uniform(0.5,1)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+
+ # small
+ num_tumor = random.randint(5,10)
+ for _ in range(num_tumor):
+ # Small tumor
+ x = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ y = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ z = random.randint(int(0.75*small_radius), int(1.25*small_radius))
+ sigma = random.randint(1, 2)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+ 
+ # medium
+ num_tumor = random.randint(2, 5)
+ for _ in range(num_tumor):
+ # medium tumor
+ x = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ y = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ z = random.randint(int(0.75*medium_radius), int(1.25*medium_radius))
+ sigma = random.randint(3, 6)
+ 
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste medium tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+
+ # large
+ num_tumor = random.randint(1,3)
+ for _ in range(num_tumor):
+ # Large tumor
+ x = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ y = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ z = random.randint(int(0.75*large_radius), int(1.25*large_radius))
+ sigma = random.randint(5, 10)
+ geo = get_ellipsoid(x, y, z)
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,1))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(1,2))
+ geo = elasticdeform.deform_random_grid(geo, sigma=sigma, points=3, order=0, axis=(0,2))
+ # texture = get_texture((4*x, 4*y, 4*z))
+ point = random_select(mask_scan)
+ new_point = [point[0] + enlarge_x//2, point[1] + enlarge_y//2, point[2] + enlarge_z//2]
+ x_low, x_high = new_point[0] - geo.shape[0]//2, new_point[0] + geo.shape[0]//2 
+ y_low, y_high = new_point[1] - geo.shape[1]//2, new_point[1] + geo.shape[1]//2 
+ z_low, z_high = new_point[2] - geo.shape[2]//2, new_point[2] + geo.shape[2]//2 
+ 
+ # paste small tumor geo into test sample
+ geo_mask[x_low:x_high, y_low:y_high, z_low:z_high] += geo
+ # texture_map[x_low:x_high, y_low:y_high, z_low:z_high] = texture
+
+ geo_mask = geo_mask[enlarge_x//2:-enlarge_x//2, enlarge_y//2:-enlarge_y//2, enlarge_z//2:-enlarge_z//2]
+ # texture_map = texture_map[enlarge_x//2:-enlarge_x//2, enlarge_y//2:-enlarge_y//2, enlarge_z//2:-enlarge_z//2]
+ geo_mask = (geo_mask * mask_scan) >=1
+ 
+ return geo_mask
+
+
+def get_tumor(volume_scan, mask_scan, tumor_type):
+ tumor_mask = get_fixed_geo(mask_scan, tumor_type)
+
+ sigma = np.random.uniform(1, 2)
+ # difference = np.random.uniform(65, 145)
+ difference = 1
+
+ # blur the boundary
+ tumor_mask_blur = gaussian_filter(tumor_mask*1.0, sigma)
+ 
+ 
+ abnormally_full = volume_scan * (1 - mask_scan) + abnormally
+ abnormally_mask = mask_scan + geo_mask
+
+ return abnormally_full, abnormally_mask
+
+def SynthesisTumor(volume_scan, mask_scan, tumor_type):
+ # for speed_generate_tumor, we only send the liver part into the generate program
+ x_start, x_end = np.where(np.any(mask_scan, axis=(1, 2)))[0][[0, -1]]
+ y_start, y_end = np.where(np.any(mask_scan, axis=(0, 2)))[0][[0, -1]]
+ z_start, z_end = np.where(np.any(mask_scan, axis=(0, 1)))[0][[0, -1]]
+
+ # shrink the boundary
+ x_start, x_end = max(0, x_start+1), min(mask_scan.shape[0], x_end-1)
+ y_start, y_end = max(0, y_start+1), min(mask_scan.shape[1], y_end-1)
+ z_start, z_end = max(0, z_start+1), min(mask_scan.shape[2], z_end-1)
+
+ ct_volume = volume_scan[x_start:x_end, y_start:y_end, z_start:z_end]
+ organ_mask = mask_scan[x_start:x_end, y_start:y_end, z_start:z_end]
+
+ # input texture shape: 420, 300, 320
+ # we need to cut it into the shape of liver_mask
+ # for examples, the liver_mask.shape = 286, 173, 46; we should change the texture shape
+ x_length, y_length, z_length = 64, 64, 64
+ crop_x = random.randint(x_start, x_end - x_length - 1) # random select the start point, -1 is to avoid boundary check
+ crop_y = random.randint(y_start, y_end - y_length - 1) 
+ crop_z = random.randint(z_start, z_end - z_length - 1) 
+
+ ct_volume, organ_tumor_mask = get_tumor(ct_volume, organ_mask, tumor_type)
+ volume_scan[x_start:x_end, y_start:y_end, z_start:z_end] = ct_volume
+ mask_scan[x_start:x_end, y_start:y_end, z_start:z_end] = organ_tumor_mask
+
+ return volume_scan, mask_scan

Generation_Pipeline_filter_all2/syn_pancreas/healthy_pancreas_1k.txt

@@ -0,0 +1,774 @@
+BDMAP_00004652
+BDMAP_00002164
+BDMAP_00000439
+BDMAP_00004775
+BDMAP_00001148
+BDMAP_00003384
+BDMAP_00003634
+BDMAP_00000030
+BDMAP_00005119
+BDMAP_00003580
+BDMAP_00000320
+BDMAP_00002185
+BDMAP_00002487
+BDMAP_00002775
+BDMAP_00000159
+BDMAP_00004475
+BDMAP_00004278
+BDMAP_00004131
+BDMAP_00000244
+BDMAP_00001966
+BDMAP_00000939
+BDMAP_00003928
+BDMAP_00003031
+BDMAP_00000568
+BDMAP_00001309
+BDMAP_00004232
+BDMAP_00004431
+BDMAP_00001794
+BDMAP_00001752
+BDMAP_00004228
+BDMAP_00002363
+BDMAP_00001020
+BDMAP_00002739
+BDMAP_00004462
+BDMAP_00003749
+BDMAP_00002472
+BDMAP_00003455
+BDMAP_00003911
+BDMAP_00003486
+BDMAP_00001496
+BDMAP_00004378
+BDMAP_00002282
+BDMAP_00001343
+BDMAP_00001747
+BDMAP_00004450
+BDMAP_00000607
+BDMAP_00000100
+BDMAP_00001620
+BDMAP_00004415
+BDMAP_00004897
+BDMAP_00001737
+BDMAP_00000604
+BDMAP_00004922
+BDMAP_00004870
+BDMAP_00002060
+BDMAP_00003412
+BDMAP_00004850
+BDMAP_00000794
+BDMAP_00000989
+BDMAP_00000205
+BDMAP_00003151
+BDMAP_00001255
+BDMAP_00000667
+BDMAP_00003343
+BDMAP_00001237
+BDMAP_00000023
+BDMAP_00003281
+BDMAP_00000907
+BDMAP_00000432
+BDMAP_00001782
+BDMAP_00002166
+BDMAP_00004481
+BDMAP_00003363
+BDMAP_00001474
+BDMAP_00001995
+BDMAP_00002854
+BDMAP_00003603
+BDMAP_00001383
+BDMAP_00002656
+BDMAP_00004427
+BDMAP_00001563
+BDMAP_00001809
+BDMAP_00002114
+BDMAP_00000304
+BDMAP_00001692
+BDMAP_00001688
+BDMAP_00001119
+BDMAP_00000449
+BDMAP_00004014
+BDMAP_00002524
+BDMAP_00000725
+BDMAP_00000918
+BDMAP_00000642
+BDMAP_00001238
+BDMAP_00002373
+BDMAP_00002326
+BDMAP_00004373
+BDMAP_00003615
+BDMAP_00003324
+BDMAP_00002654
+BDMAP_00002849
+BDMAP_00003491
+BDMAP_00002655
+BDMAP_00002712
+BDMAP_00001516
+BDMAP_00000469
+BDMAP_00001549
+BDMAP_00000713
+BDMAP_00000745
+BDMAP_00000259
+BDMAP_00003569
+BDMAP_00005067
+BDMAP_00004185
+BDMAP_00003357
+BDMAP_00002419
+BDMAP_00002598
+BDMAP_00002167
+BDMAP_00000137
+BDMAP_00003448
+BDMAP_00000965
+BDMAP_00000232
+BDMAP_00004608
+BDMAP_00003680
+BDMAP_00000716
+BDMAP_00002403
+BDMAP_00004216
+BDMAP_00001359
+BDMAP_00004175
+BDMAP_00002791
+BDMAP_00002940
+BDMAP_00000355
+BDMAP_00004294
+BDMAP_00001426
+BDMAP_00001475
+BDMAP_00002986
+BDMAP_00002884
+BDMAP_00000400
+BDMAP_00002410
+BDMAP_00000297
+BDMAP_00001636
+BDMAP_00005113
+BDMAP_00004074
+BDMAP_00002333
+BDMAP_00003976
+BDMAP_00002383
+BDMAP_00000161
+BDMAP_00001212
+BDMAP_00000366
+BDMAP_00003070
+BDMAP_00003943
+BDMAP_00003930
+BDMAP_00003164
+BDMAP_00001906
+BDMAP_00002889
+BDMAP_00004163
+BDMAP_00001456
+BDMAP_00003972
+BDMAP_00004586
+BDMAP_00000626
+BDMAP_00001095
+BDMAP_00000532
+BDMAP_00003377
+BDMAP_00003225
+BDMAP_00001289
+BDMAP_00001275
+BDMAP_00004509
+BDMAP_00000998
+BDMAP_00000836
+BDMAP_00001015
+BDMAP_00004650
+BDMAP_00005186
+BDMAP_00000608
+BDMAP_00003898
+BDMAP_00002696
+BDMAP_00003560
+BDMAP_00004578
+BDMAP_00000828
+BDMAP_00000690
+BDMAP_00003564
+BDMAP_00005174
+BDMAP_00000132
+BDMAP_00005105
+BDMAP_00000902
+BDMAP_00003947
+BDMAP_00002184
+BDMAP_00001785
+BDMAP_00002361
+BDMAP_00003255
+BDMAP_00000971
+BDMAP_00003493
+BDMAP_00002267
+BDMAP_00005154
+BDMAP_00000982
+BDMAP_00005157
+BDMAP_00004384
+BDMAP_00003063
+BDMAP_00001982
+BDMAP_00002273
+BDMAP_00001102
+BDMAP_00002689
+BDMAP_00000034
+BDMAP_00001514
+BDMAP_00005081
+BDMAP_00001786
+BDMAP_00004033
+BDMAP_00004457
+BDMAP_00000710
+BDMAP_00001198
+BDMAP_00004479
+BDMAP_00000873
+BDMAP_00000362
+BDMAP_00004616
+BDMAP_00003128
+BDMAP_00001607
+BDMAP_00004104
+BDMAP_00001517
+BDMAP_00004639
+BDMAP_00005170
+BDMAP_00002305
+BDMAP_00004746
+BDMAP_00003333
+BDMAP_00001807
+BDMAP_00004579
+BDMAP_00002260
+BDMAP_00004416
+BDMAP_00003932
+BDMAP_00001316
+BDMAP_00003411
+BDMAP_00000839
+BDMAP_00004738
+BDMAP_00001438
+BDMAP_00003435
+BDMAP_00001697
+BDMAP_00001911
+BDMAP_00001735
+BDMAP_00002902
+BDMAP_00001834
+BDMAP_00000069
+BDMAP_00004066
+BDMAP_00000434
+BDMAP_00004744
+BDMAP_00000347
+BDMAP_00001246
+BDMAP_00003150
+BDMAP_00003957
+BDMAP_00001768
+BDMAP_00002663
+BDMAP_00004147
+BDMAP_00003510
+BDMAP_00002242
+BDMAP_00005016
+BDMAP_00002275
+BDMAP_00001924
+BDMAP_00002214
+BDMAP_00002529
+BDMAP_00000562
+BDMAP_00000122
+BDMAP_00002707
+BDMAP_00000874
+BDMAP_00000176
+BDMAP_00002804
+BDMAP_00005005
+BDMAP_00001422
+BDMAP_00005017
+BDMAP_00000653
+BDMAP_00002609
+BDMAP_00003327
+BDMAP_00002484
+BDMAP_00004673
+BDMAP_00004493
+BDMAP_00003740
+BDMAP_00002271
+BDMAP_00002742
+BDMAP_00002826
+BDMAP_00001035
+BDMAP_00002068
+BDMAP_00003815
+BDMAP_00003052
+BDMAP_00004499
+BDMAP_00002065
+BDMAP_00001025
+BDMAP_00004888
+BDMAP_00002592
+BDMAP_00004030
+BDMAP_00001024
+BDMAP_00002041
+BDMAP_00002807
+BDMAP_00002751
+BDMAP_00003272
+BDMAP_00004600
+BDMAP_00004154
+BDMAP_00003774
+BDMAP_00000948
+BDMAP_00002173
+BDMAP_00004510
+BDMAP_00000104
+BDMAP_00004374
+BDMAP_00000429
+BDMAP_00004420
+BDMAP_00001853
+BDMAP_00003600
+BDMAP_00002349
+BDMAP_00001863
+BDMAP_00004830
+BDMAP_00002981
+BDMAP_00001941
+BDMAP_00001128
+BDMAP_00005151
+BDMAP_00003890
+BDMAP_00003640
+BDMAP_00004257
+BDMAP_00004943
+BDMAP_00001068
+BDMAP_00001305
+BDMAP_00000414
+BDMAP_00000465
+BDMAP_00003727
+BDMAP_00002199
+BDMAP_00001769
+BDMAP_00004187
+BDMAP_00001891
+BDMAP_00000980
+BDMAP_00003923
+BDMAP_00000942
+BDMAP_00001114
+BDMAP_00001602
+BDMAP_00002845
+BDMAP_00003178
+BDMAP_00003409
+BDMAP_00001562
+BDMAP_00002909
+BDMAP_00003808
+BDMAP_00001169
+BDMAP_00001104
+BDMAP_00001483
+BDMAP_00005009
+BDMAP_00001957
+BDMAP_00003153
+BDMAP_00001444
+BDMAP_00000851
+BDMAP_00005191
+BDMAP_00000687
+BDMAP_00003722
+BDMAP_00003330
+BDMAP_00002347
+BDMAP_00002955
+BDMAP_00001089
+BDMAP_00004529
+BDMAP_00003268
+BDMAP_00001522
+BDMAP_00001502
+BDMAP_00000240
+BDMAP_00004867
+BDMAP_00000480
+BDMAP_00000452
+BDMAP_00002918
+BDMAP_00002953
+BDMAP_00002039
+BDMAP_00000889
+BDMAP_00002746
+BDMAP_00003608
+BDMAP_00003664
+BDMAP_00003299
+BDMAP_00001445
+BDMAP_00000113
+BDMAP_00001705
+BDMAP_00000044
+BDMAP_00003513
+BDMAP_00001261
+BDMAP_00004990
+BDMAP_00003143
+BDMAP_00003111
+BDMAP_00002319
+BDMAP_00004664
+BDMAP_00003717
+BDMAP_00004717
+BDMAP_00004745
+BDMAP_00000671
+BDMAP_00002990
+BDMAP_00004901
+BDMAP_00002545
+BDMAP_00004980
+BDMAP_00000913
+BDMAP_00000437
+BDMAP_00002864
+BDMAP_00000364
+BDMAP_00004195
+BDMAP_00000162
+BDMAP_00002840
+BDMAP_00000233
+BDMAP_00002744
+BDMAP_00001218
+BDMAP_00002289
+BDMAP_00000229
+BDMAP_00005114
+BDMAP_00000279
+BDMAP_00003832
+BDMAP_00000241
+BDMAP_00002251
+BDMAP_00001676
+BDMAP_00001635
+BDMAP_00003444
+BDMAP_00002265
+BDMAP_00002498
+BDMAP_00001209
+BDMAP_00001138
+BDMAP_00002407
+BDMAP_00003798
+BDMAP_00001325
+BDMAP_00002631
+BDMAP_00004304
+BDMAP_00001078
+BDMAP_00002562
+BDMAP_00003576
+BDMAP_00001977
+BDMAP_00002396
+BDMAP_00001333
+BDMAP_00004925
+BDMAP_00004903
+BDMAP_00000273
+BDMAP_00000571
+BDMAP_00001027
+BDMAP_00000149
+BDMAP_00001962
+BDMAP_00003481
+BDMAP_00001256
+BDMAP_00000871
+BDMAP_00000926
+BDMAP_00000572
+BDMAP_00004558
+BDMAP_00000435
+BDMAP_00000837
+BDMAP_00003713
+BDMAP_00002875
+BDMAP_00004645
+BDMAP_00001711
+BDMAP_00001296
+BDMAP_00002648
+BDMAP_00004561
+BDMAP_00002318
+BDMAP_00001835
+BDMAP_00003524
+BDMAP_00002959
+BDMAP_00002422
+BDMAP_00004597
+BDMAP_00000487
+BDMAP_00002359
+BDMAP_00005001
+BDMAP_00004817
+BDMAP_00001539
+BDMAP_00002936
+BDMAP_00002719
+BDMAP_00005167
+BDMAP_00001265
+BDMAP_00001471
+BDMAP_00001511
+BDMAP_00005139
+BDMAP_00002426
+BDMAP_00002288
+BDMAP_00004808
+BDMAP_00002085
+BDMAP_00004435
+BDMAP_00000319
+BDMAP_00003614
+BDMAP_00001109
+BDMAP_00000331
+BDMAP_00004491
+BDMAP_00002440
+BDMAP_00003373
+BDMAP_00005065
+BDMAP_00005006
+BDMAP_00002509
+BDMAP_00003973
+BDMAP_00004417
+BDMAP_00000935
+BDMAP_00004624
+BDMAP_00003364
+BDMAP_00005085
+BDMAP_00003073
+BDMAP_00002730
+BDMAP_00004825
+BDMAP_00000039
+BDMAP_00004615
+BDMAP_00003736
+BDMAP_00005097
+BDMAP_00003074
+BDMAP_00000662
+BDMAP_00001122
+BDMAP_00002252
+BDMAP_00001396
+BDMAP_00004011
+BDMAP_00004981
+BDMAP_00004165
+BDMAP_00003920
+BDMAP_00001215
+BDMAP_00003867
+BDMAP_00000923
+BDMAP_00002626
+BDMAP_00003315
+BDMAP_00000660
+BDMAP_00000329
+BDMAP_00004508
+BDMAP_00001518
+BDMAP_00003849
+BDMAP_00003897
+BDMAP_00003300
+BDMAP_00002253
+BDMAP_00003514
+BDMAP_00000117
+BDMAP_00002421
+BDMAP_00001413
+BDMAP_00004328
+BDMAP_00001130
+BDMAP_00000043
+BDMAP_00001410
+BDMAP_00000245
+BDMAP_00004117
+BDMAP_00002401
+BDMAP_00003857
+BDMAP_00000921
+BDMAP_00000138
+BDMAP_00003113
+BDMAP_00003358
+BDMAP_00002099
+BDMAP_00004016
+BDMAP_00003439
+BDMAP_00002152
+BDMAP_00003767
+BDMAP_00001598
+BDMAP_00003482
+BDMAP_00003520
+BDMAP_00002075
+BDMAP_00000987
+BDMAP_00003946
+BDMAP_00005160
+BDMAP_00001286
+BDMAP_00003359
+BDMAP_00002661
+BDMAP_00004704
+BDMAP_00003994
+BDMAP_00002226
+BDMAP_00000968
+BDMAP_00003556
+BDMAP_00003236
+BDMAP_00001791
+BDMAP_00004712
+BDMAP_00001077
+BDMAP_00003955
+BDMAP_00002479
+BDMAP_00001865
+BDMAP_00001059
+BDMAP_00002704
+BDMAP_00000656
+BDMAP_00001379
+BDMAP_00000883
+BDMAP_00002856
+BDMAP_00004199
+BDMAP_00001200
+BDMAP_00005083
+BDMAP_00004552
+BDMAP_00000616
+BDMAP_00004834
+BDMAP_00004815
+BDMAP_00001826
+BDMAP_00000615
+BDMAP_00001045
+BDMAP_00002695
+BDMAP_00004017
+BDMAP_00002103
+BDMAP_00002057
+BDMAP_00004620
+BDMAP_00000128
+BDMAP_00001185
+BDMAP_00002612
+BDMAP_00005073
+BDMAP_00001753
+BDMAP_00004196
+BDMAP_00004281
+BDMAP_00002717
+BDMAP_00000263
+BDMAP_00004103
+BDMAP_00003381
+BDMAP_00001093
+BDMAP_00000373
+BDMAP_00000881
+BDMAP_00002230
+BDMAP_00001707
+BDMAP_00002476
+BDMAP_00003294
+BDMAP_00004482
+BDMAP_00003267
+BDMAP_00002710
+BDMAP_00002451
+BDMAP_00001270
+BDMAP_00004878
+BDMAP_00001784
+BDMAP_00001281
+BDMAP_00002283
+BDMAP_00001183
+BDMAP_00001945
+BDMAP_00004604
+BDMAP_00000413
+BDMAP_00003506
+BDMAP_00002458
+BDMAP_00000977
+BDMAP_00000833
+BDMAP_00001055
+BDMAP_00002495
+BDMAP_00000887
+BDMAP_00002496
+BDMAP_00002942
+BDMAP_00000574
+BDMAP_00001868
+BDMAP_00000547
+BDMAP_00001230
+BDMAP_00003762
+BDMAP_00003971
+BDMAP_00000321
+BDMAP_00004876
+BDMAP_00003833
+BDMAP_00003461
+BDMAP_00003301
+BDMAP_00002846
+BDMAP_00002582
+BDMAP_00001710
+BDMAP_00001487
+BDMAP_00000936
+BDMAP_00004121
+BDMAP_00004459
+BDMAP_00000219
+BDMAP_00000091
+BDMAP_00001283
+BDMAP_00000084
+BDMAP_00000516
+BDMAP_00004250
+BDMAP_00001732
+BDMAP_00003694
+BDMAP_00004031
+BDMAP_00001557
+BDMAP_00002437
+BDMAP_00002933
+BDMAP_00000264
+BDMAP_00005099
+BDMAP_00004296
+BDMAP_00001917
+BDMAP_00003252
+BDMAP_00004389
+BDMAP_00002463
+BDMAP_00004253
+BDMAP_00004910
+BDMAP_00003172
+BDMAP_00001624
+BDMAP_00003484
+BDMAP_00001907
+BDMAP_00003952
+BDMAP_00002653
+BDMAP_00000368
+BDMAP_00000569
+BDMAP_00004995
+BDMAP_00003956
+BDMAP_00003497
+BDMAP_00003058
+BDMAP_00000552
+BDMAP_00000481
+BDMAP_00000805
+BDMAP_00003002
+BDMAP_00000698
+BDMAP_00004783
+BDMAP_00001324
+BDMAP_00002133
+BDMAP_00005120
+BDMAP_00003581
+BDMAP_00004890
+BDMAP_00001533
+BDMAP_00004039
+BDMAP_00000190
+BDMAP_00004028
+BDMAP_00004130
+BDMAP_00001370
+BDMAP_00002805
+BDMAP_00001397
+BDMAP_00001126
+BDMAP_00001875
+BDMAP_00005130
+BDMAP_00003361
+BDMAP_00002485
+BDMAP_00001273
+BDMAP_00000582
+BDMAP_00003672
+BDMAP_00000778
+BDMAP_00002841
+BDMAP_00001242
+BDMAP_00000345
+BDMAP_00000036
+BDMAP_00003996
+BDMAP_00003701
+BDMAP_00003425
+BDMAP_00001656
+BDMAP_00001802
+BDMAP_00001420
+BDMAP_00003752
+BDMAP_00002924
+BDMAP_00003202
+BDMAP_00000831
+BDMAP_00003392
+BDMAP_00002022
+BDMAP_00001223
+BDMAP_00003457
+BDMAP_00001236
+BDMAP_00000810
+BDMAP_00004676
+BDMAP_00003847
+BDMAP_00001225
+BDMAP_00005168
+BDMAP_00004113
+BDMAP_00002828
+BDMAP_00004087
+BDMAP_00004407
+BDMAP_00002748
+BDMAP_00003516
+BDMAP_00004395
+BDMAP_00001985
+BDMAP_00001171
+BDMAP_00000101
+BDMAP_00002117
+BDMAP_00001434
+BDMAP_00000139
+BDMAP_00002465
+BDMAP_00001251
+BDMAP_00001908
+BDMAP_00002354
+BDMAP_00002776
+BDMAP_00004887
+BDMAP_00000066
+BDMAP_00003549
+BDMAP_00000812
+BDMAP_00000353
+BDMAP_00004894
+BDMAP_00004956
+BDMAP_00002871
+BDMAP_00004764
+BDMAP_00004551
+BDMAP_00002404
+BDMAP_00000059
+BDMAP_00002017
+BDMAP_00003558
+BDMAP_00004065
+BDMAP_00003406
+BDMAP_00002471
+BDMAP_00000941
+BDMAP_00003109
+BDMAP_00000511
+BDMAP_00000826
+BDMAP_00004839
+BDMAP_00004671
+BDMAP_00002930
+BDMAP_00004331
+BDMAP_00001664
+BDMAP_00001001
+BDMAP_00001766
+BDMAP_00003827
+BDMAP_00001258
+BDMAP_00001892
+BDMAP_00000062
+BDMAP_00000867
+BDMAP_00002803
+BDMAP_00000285
+BDMAP_00001647
+BDMAP_00005077
+BDMAP_00000152
+BDMAP_00000709
+BDMAP_00002172
+BDMAP_00004148
+BDMAP_00001010

Generation_Pipeline_filter_all2/syn_pancreas/requirements.txt

@@ -0,0 +1,94 @@
+absl-py==1.1.0
+accelerate==0.11.0
+aiohttp==3.8.1
+aiosignal==1.2.0
+antlr4-python3-runtime==4.9.3
+async-timeout==4.0.2
+attrs==21.4.0
+autopep8==1.6.0
+cachetools==5.2.0
+certifi==2022.6.15
+charset-normalizer==2.0.12
+click==8.1.3
+cycler==0.11.0
+Deprecated==1.2.13
+docker-pycreds==0.4.0
+einops==0.4.1
+einops-exts==0.0.3
+ema-pytorch==0.0.8
+fonttools==4.34.4
+frozenlist==1.3.0
+fsspec==2022.5.0
+ftfy==6.1.1
+future==0.18.2
+gitdb==4.0.9
+GitPython==3.1.27
+google-auth==2.9.0
+google-auth-oauthlib==0.4.6
+grpcio==1.47.0
+h5py==3.7.0
+humanize==4.2.2
+hydra-core==1.2.0
+idna==3.3
+imageio==2.19.3
+imageio-ffmpeg==0.4.7
+importlib-metadata==4.12.0
+importlib-resources==5.9.0
+joblib==1.1.0
+kiwisolver==1.4.3
+lxml==4.9.1
+Markdown==3.3.7
+matplotlib==3.5.2
+multidict==6.0.2
+networkx==2.8.5
+nibabel==4.0.1
+nilearn==0.9.1
+numpy==1.23.0
+oauthlib==3.2.0
+omegaconf==2.2.3
+pandas==1.4.3
+Pillow==9.1.1
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pycodestyle==2.8.0
+pyDeprecate==0.3.1
+pydicom==2.3.0
+pytorch-lightning==1.6.4
+pytz==2022.1
+PyWavelets==1.3.0
+PyYAML==6.0
+pyzmq==19.0.2
+regex==2022.6.2
+requests==2.28.0
+requests-oauthlib==1.3.1
+rotary-embedding-torch==0.1.5
+rsa==4.8
+scikit-image==0.19.3
+scikit-learn==1.1.2
+scikit-video==1.1.11
+scipy==1.8.1
+seaborn==0.11.2
+sentry-sdk==1.7.2
+setproctitle==1.2.3
+shortuuid==1.0.9
+SimpleITK==2.1.1.2
+smmap==5.0.0
+tensorboard==2.9.1
+tensorboard-data-server==0.6.1
+tensorboard-plugin-wit==1.8.1
+threadpoolctl==3.1.0
+tifffile==2022.8.3
+toml==0.10.2
+torch-tb-profiler==0.4.0
+torchio==0.18.80
+torchmetrics==0.9.1
+tqdm==4.64.0
+typing_extensions==4.2.0
+urllib3==1.26.9
+wandb==0.12.21
+Werkzeug==2.1.2
+wrapt==1.14.1
+yarl==1.7.2
+zipp==3.8.0
+wandb
+tensorboardX==2.4.1

Generation_Pipeline_filter_all2/val_set/bodymap_colon.txt

@@ -0,0 +1,25 @@
+BDMAP_00004910
+BDMAP_00001438
+BDMAP_00000568
+BDMAP_00002828
+BDMAP_00003634
+BDMAP_00004121
+BDMAP_00004764
+BDMAP_00003972
+BDMAP_00003113
+BDMAP_00005001
+BDMAP_00001785
+BDMAP_00005016
+BDMAP_00002739
+BDMAP_00003299
+BDMAP_00003357
+BDMAP_00001078
+BDMAP_00000874
+BDMAP_00003560
+BDMAP_00003373
+BDMAP_00003172
+BDMAP_00002875
+BDMAP_00000552
+BDMAP_00003510
+BDMAP_00004604
+BDMAP_00002598

Generation_Pipeline_filter_all2/val_set/bodymap_kidney.txt

@@ -0,0 +1,24 @@
+BDMAP_00000487
+BDMAP_00002631
+BDMAP_00002744
+BDMAP_00000833
+BDMAP_00002648
+BDMAP_00002840
+BDMAP_00000608
+BDMAP_00002804
+BDMAP_00002775
+BDMAP_00004551
+BDMAP_00001413
+BDMAP_00000511
+BDMAP_00003150
+BDMAP_00000794
+BDMAP_00001255
+BDMAP_00002242
+BDMAP_00004746
+BDMAP_00002864
+BDMAP_00003486
+BDMAP_00004250
+BDMAP_00003143
+BDMAP_00003164
+BDMAP_00004578
+BDMAP_00001735

Generation_Pipeline_filter_all2/val_set/bodymap_liver.txt

@@ -0,0 +1,25 @@
+BDMAP_00004281
+BDMAP_00003481
+BDMAP_00004890
+BDMAP_00001786
+BDMAP_00000101
+BDMAP_00004117
+BDMAP_00000615
+BDMAP_00000921
+BDMAP_00005130
+BDMAP_00004378
+BDMAP_00004704
+BDMAP_00003439
+BDMAP_00002717
+BDMAP_00004878
+BDMAP_00000100
+BDMAP_00001309
+BDMAP_00002214
+BDMAP_00001198
+BDMAP_00001962
+BDMAP_00002463
+BDMAP_00005139
+BDMAP_00000831
+BDMAP_00002955
+BDMAP_00003272
+BDMAP_00000745

Generation_Pipeline_filter_all2/val_set/bodymap_pancreas.txt

@@ -0,0 +1,24 @@
+BDMAP_00000332
+BDMAP_00004858
+BDMAP_00005155
+BDMAP_00001205
+BDMAP_00004770
+BDMAP_00001361
+BDMAP_00002944
+BDMAP_00003961
+BDMAP_00000430
+BDMAP_00000679
+BDMAP_00003809
+BDMAP_00004115
+BDMAP_00003367
+BDMAP_00002899
+BDMAP_00003771
+BDMAP_00003502
+BDMAP_00001628
+BDMAP_00003884
+BDMAP_00005074
+BDMAP_00003114
+BDMAP_00004741
+BDMAP_00001746
+BDMAP_00002603
+BDMAP_00004128