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