Upload 16 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+utils/dicom_headerfile.dcm filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,3 @@
+[server]
+maxUploadSize = 2048      # MB
+maxMessageSize = 2048     # MB

Dockerfile

@@ -1,21 +1,33 @@
-FROM python:3.9-slim
+# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.245.0/containers/python-3/.devcontainer/base.Dockerfile
 
-WORKDIR /app
+# [Choice] Python version (use -bullseye variants on local arm64/Apple Silicon): 3, 3.10, 3.9, 3.8, 3.7, 3.6, 3-bullseye, 3.10-bullseye, 3.9-bullseye, 3.8-bullseye, 3.7-bullseye, 3.6-bullseye, 3-buster, 3.10-buster, 3.9-buster, 3.8-buster, 3.7-buster, 3.6-buster
+FROM tensorflow/tensorflow:2.9.1-gpu
+RUN apt-get install libopenexr-dev -y
+RUN pip install tensorflow-mri
+RUN pip install tqdm
+RUN pip install h5py
+RUN pip install tensorflow-addons
+RUN pip install scikit-learn
+RUN pip install scikit-image
+RUN pip install neptune-client
+RUN pip install matplotlib
+RUN pip install scipy
+RUN pip install pydicom
+RUN pip install streamlit
+RUN pip install protobuf==3.20.*
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Create non-root user.
+ARG USERNAME=vscode
+ARG USER_UID=1003
+ARG USER_GID=$USER_UID
 
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+RUN groupadd --gid $USER_GID $USERNAME && \
+    useradd --uid $USER_UID --gid $USER_GID -m $USERNAME && \
+    # Add user to sudoers.
+    apt-get update && \
+    apt-get install -y sudo && \
+    echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME && \
+    chmod 0440 /etc/sudoers.d/$USERNAME && \
+    # Change default shell to bash.
+    usermod --shell /bin/bash $USERNAME

README.md

@@ -1,19 +1,20 @@
+
 ---
-title: 3DCine
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
+title: 3D Cine MRI (Streamlit)
+emoji: 🧠
+colorFrom: indigo
+colorTo: pink
+sdk: streamlit
+app_file: app.py
+pinned: true
 ---
 
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Setup (Hugging Face Spaces — free CPU)
+1. Create a Space with **SDK: Streamlit**, hardware **CPU Basic**.
+2. In **Settings → Variables**, add:
+   - `HF_HOME=/data/.huggingface` (speeds up caching)
+   - `MODEL_REPO=your-username/your-model-repo` (where your models live on the Hub)
+   - *(optional)* `MODEL_SUBDIR=subfolder-inside-repo`
+   - *(optional)* `PERSIST_BASE=/data`
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+Your models will be downloaded at runtime into persistent storage and reused after restarts.

app.py

@@ -0,0 +1,198 @@
+from utils.process_utils import *
+import skimage
+import streamlit as st
+import zipfile
+import tempfile
+import os
+import shutil
+
+import os
+from huggingface_hub import snapshot_download
+
+MODEL_REPO = os.getenv("MODEL_REPO")  # e.g. "username/3d-cine-models"
+MODEL_SUBDIR = os.getenv("MODEL_SUBDIR", "")  # optional subfolder in the repo
+PERSIST_BASE = os.getenv("PERSIST_BASE", "/data")  # HF Spaces persistent storage
+
+def get_models_base():
+    # cache models inside persistent storage to avoid re-downloads
+    os.makedirs(PERSIST_BASE, exist_ok=True)
+    if MODEL_REPO:
+        repo_dir = snapshot_download(repo_id=MODEL_REPO, repo_type="model", local_dir=os.path.join(PERSIST_BASE, "hf_models"), local_dir_use_symlinks=False)
+        base = os.path.join(repo_dir, MODEL_SUBDIR) if MODEL_SUBDIR else repo_dir
+    else:
+        # fallback to a local folder in persistent storage
+        base = os.path.join(PERSIST_BASE, MODELS_BASE)
+        os.makedirs(base, exist_ok=True)
+    return base
+
+MODELS_BASE = get_models_base()
+
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
+if "initialized" not in st.session_state:
+    for d in ("./out_dir", "./out_dicoms"):
+        if os.path.exists(d):
+            shutil.rmtree(d)
+        os.makedirs(d, exist_ok=True)
+    st.session_state.initialized = True
+
+# --- Session state defaults ---
+if "volume" not in st.session_state:
+    st.session_state.volume = None
+if "data_processed" not in st.session_state:
+    st.session_state.data_processed = False
+if "gif_ready" not in st.session_state:
+    st.session_state.gif_ready = False
+if "dicom_create" not in st.session_state:
+    st.session_state.dicom_create = False
+if "want_gif" not in st.session_state:
+    st.session_state.want_gif = True
+if "num_phases" not in st.session_state:
+    st.session_state.num_phases = None
+
+# --- Title ---
+st.title("3D Cine")
+
+# --- Upload ---
+st.header("Data Upload")
+uploaded_zip = st.file_uploader("Upload ZIP file of MRI folders", type="zip")
+
+_ = st.toggle("Generate a GIF preview after processing", key="want_gif")
+
+if uploaded_zip is not None:
+
+    if st.button("Process Data"):
+        with st.spinner("Processing ZIP..."):
+            temp_dir = tempfile.mkdtemp()
+            zip_path = os.path.join(temp_dir, "upload.zip")
+            with open(zip_path, "wb") as f:
+                f.write(uploaded_zip.read())
+
+            extract_zip(zip_path, temp_dir)
+            st.session_state.volume, st.session_state.num_phases = load_cine_any(temp_dir, number_of_scans=None)
+            num_phases = st.session_state.num_phases
+        if st.session_state.volume is None or len(st.session_state.volume) == 0:
+            st.error("Failed to load volume.")
+        else:
+            with st.spinner("Cropping..."):
+                time_steps = num_phases
+                sag_vols = np.array(st.session_state.volume)
+                
+                if sag_vols.shape[1] !=28:
+                    diff = sag_vols.shape[1] -28
+                    sag_vols = sag_vols[:,diff:,:,:]
+                    
+                if sag_vols.shape[2] ==512:
+                    sag_vols = skimage.transform.rescale(sag_vols,(1,1,0.5,0.5),order =3, anti_aliasing=True)
+
+                sag_vols_cropped = []
+                for j in range(time_steps):
+                    sag_cropped = []
+                    for i in range(sag_vols.shape[1]):    
+                        sag_cropped.append(resize(sag_vols[j,i,:,:], 256, 128))
+                    sag_cropped = np.dstack(sag_cropped)
+                    sag_cropped = np.swapaxes(sag_cropped, 0, 1)
+                    sag_cropped = np.swapaxes(sag_cropped, 0, 2)
+                    sag_vols_cropped.append(sag_cropped)
+
+                sag_vols_cropped = norm(sag_vols_cropped)
+                
+                if st.session_state.want_gif:
+                    raw_us = skimage.transform.rescale(sag_vols_cropped, (1,4,1,1), order=2)
+                
+            with st.spinner("Contrast correction..."):
+                debanded = apply_debanding_model(sag_vols_cropped, frames=time_steps)
+                debanded = norm(debanded)
+                debanded_us = debanded[:,0,...,0]
+                if st.session_state.want_gif:
+                    debanded_us = skimage.transform.rescale(debanded_us, (1,4,1,1), order=2)
+
+            with st.spinner("Respiratory correction..."):
+                def_fields, resp_cor = apply_resp_model_28(debanded, frames=time_steps)
+                resp_cor = norm(resp_cor)
+                resp_cor_us = resp_cor[:,0,...,0]
+                if st.session_state.want_gif:
+                    resp_cor_us = skimage.transform.rescale(resp_cor_us, (1,4,1,1), order=2)
+
+            with st.spinner("Super-resolution..."):
+                super_resed_E2E = apply_SR_model(resp_cor, frames=time_steps)
+                super_resed_E2E = norm(super_resed_E2E)
+                super_resed_E2E = super_resed_E2E[:,0,...,0]
+
+                os.makedirs('./out_dir/', exist_ok=True)
+                for i in range(time_steps):
+                    np.save(f'./out_dir/3D_cine_{i}.npy', super_resed_E2E[i])
+                    if st.session_state.want_gif:
+                        np.save(f'./out_dir/resp_cor_{i}.npy', resp_cor_us[i])
+                        np.save(f'./out_dir/debanded_{i}.npy', debanded_us[i])
+                        np.save(f'./out_dir/raw_{i}.npy', raw_us[i])
+
+            st.success("✅ All models complete and data saved!")
+            st.session_state.data_processed = True
+            st.session_state.gif_ready = False  # Reset gif status
+            
+            if not st.session_state.want_gif:
+                st.session_state.dicom_create = True
+
+# --- GIF Generation Section ---
+if st.session_state.want_gif:
+    num_phases = st.session_state.num_phases
+    if st.session_state.data_processed:
+        st.header("GIF Generator")
+
+        axis_option = st.radio(
+            "Select axis for slicing",
+            options=["Axial", "Coronal"],
+            index=0,
+            key="axis_selector"
+        )
+        axis_mapping = {"Axial": 1, "Coronal": 2}
+        axis = axis_mapping[axis_option]
+
+        slice_index = st.number_input("Select slice number", 0, 256, 60, 1)
+        framerate = st.number_input("Framerate", 1, 100, num_phases, 1)
+
+        if st.button("Generate and Show GIF"):
+            gif_path = make_gif('./out_dir/', timepoints=num_phases, axis=axis, slice=slice_index, frame_rate=framerate)
+            st.image(gif_path, caption="Generated GIF", use_container_width=True)
+            st.session_state.gif_ready = True
+
+# --- Next Steps Section ---
+if st.session_state.gif_ready:
+    next_action = st.radio(
+        "What would you like to do next?",
+        options=["Generate another GIF", "Proceed to DICOM export"],
+        index=0
+    )
+
+    if next_action == "Generate another GIF":
+        st.info("Adjust your settings above and click the button again.")
+
+    elif next_action == "Proceed to DICOM export":
+        st.session_state.dicom_create = True
+
+# --- DICOM Export Section ---
+if st.session_state.dicom_create:
+    num_phases = st.session_state.num_phases
+    st.header("DICOM Export")
+    to_dicom(num_phases, patient_number=0)
+    st.success("✅ Created DICOMs.")
+    
+    src_dir = "./out_dicoms"
+
+    # build zip once per session so we don't recompress on every rerun
+    if "dicom_zip" not in st.session_state:
+        if os.path.isdir(src_dir) and any(os.scandir(src_dir)):
+            st.session_state.dicom_zip = zip_dir_to_memory(src_dir)
+            st.session_state.dicom_zip_name = f"dicoms_{time.strftime('%Y%m%d-%H%M%S')}.zip"
+        else:
+            st.warning("No DICOMs found to package.")
+
+    if "dicom_zip" in st.session_state:
+        st.download_button(
+            label="⬇️ Download DICOMs (ZIP)",
+            data=st.session_state.dicom_zip,
+            file_name=st.session_state.dicom_zip_name,
+            mime="application/zip",
+            use_container_width=True
+        )

devcontainer.json

@@ -0,0 +1,59 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
+// https://github.com/microsoft/vscode-dev-containers/tree/v0.245.0/containers/python-3
+{
+	"name": "Python 3",
+	"build": {
+		"dockerfile": "Dockerfile",
+		"context": ".."
+	},
+
+	// Enable GPUs
+	"runArgs": [
+		"--gpus=all"
+	],
+	// Enable plotting.
+	"mounts": [
+		"type=bind,source=/tmp/.X11-unix,target=/tmp/.X11-unix"
+	],
+	// Enable plotting.
+	"containerEnv": {
+		"DISPLAY": "${localEnv:DISPLAY}"
+	},
+	
+	// Configure tool-specific properties.
+	"customizations": {
+		// Configure properties specific to VS Code.
+		"vscode": {
+			// Set *default* container specific settings.json values on container create.
+			"settings": { 
+				"python.defaultInterpreterPath": "/usr/local/bin/python",
+				"python.linting.enabled": true,
+				"python.linting.pylintEnabled": true,
+				"python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
+				"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+				"python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
+				"python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
+				"python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
+				"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
+				"python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
+				"python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
+				"python.linting.pylintPath": "/usr/local/py-utils/bin/pylint"
+			},
+			
+			// Add the IDs of extensions you want installed when the container is created.
+			"extensions": [
+				"ms-python.python",
+				"ms-python.vscode-pylance"
+			]
+		}
+	},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "pip3 install --user -r requirements.txt",
+
+	// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
+	"remoteUser": "vscode"
+}

docker-compose.yml

@@ -0,0 +1,18 @@
+version: "3.9"
+
+services:
+  run_code:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "8501:8501"
+    volumes:
+      - .:/app
+    working_dir: /app
+    command: streamlit run app.py --server.address=0.0.0.0
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - capabilities: [gpu]

requirements.txt

@@ -1,3 +1,13 @@
-altair
-pandas
-streamlit
+streamlit
+tensorflow==2.9.1
+tensorflow-mri
+tqdm
+h5py
+tensorflow-addons
+scikit-learn
+scikit-image
+matplotlib
+scipy
+pydicom
+huggingface_hub>=0.21
+numpy<2

utils/custom_unet_code.py

@@ -0,0 +1,111 @@
+import tensorflow as tf 
+from tensorflow.keras import layers, models
+
+def time_distributed_conv_block(input_tensor, num_filters):
+    x = layers.Conv3D(num_filters, (3, 3, 3), padding="same")(input_tensor)
+    x = layers.ReLU()(x)
+    
+    x = layers.Conv3D(num_filters, (3, 3, 3), padding="same")(x)
+    x = layers.ReLU()(x)
+    return x
+
+def time_distributed_encoder_block_resp(input_tensor, num_filters, temporal_maxpool=True):
+    x = time_distributed_conv_block(input_tensor, num_filters)
+
+    p = layers.MaxPooling3D((1, 4, 4))(x)
+
+    if temporal_maxpool:
+
+        p = tf.transpose(p, (0,2,3,1,4))
+        p2 = layers.TimeDistributed(layers.TimeDistributed(layers.MaxPooling1D((2))))(p)
+        p2 = tf.transpose(p2, (0,3,1,2,4))
+        return x, p2
+    else:
+        return x, p
+
+def time_distributed_decoder_block_resp(input_tensor, skip_tensor, num_filters):
+    
+    x = layers.TimeDistributed(layers.UpSampling2D(( 4, 4), interpolation='bilinear'))(input_tensor)
+    x = layers.Conv3D(num_filters, (3, 3, 3), padding="same")(x)
+    x = layers.Conv3D(num_filters, (3, 3, 3), padding="same")(x)
+
+    x = layers.Concatenate()([x, skip_tensor])
+    x = time_distributed_conv_block(x, num_filters)
+    return x
+
+def build_3d_unet_resp(input_shape, num_classes):
+    inputs = layers.Input(shape=input_shape)
+
+    # Encoding path
+    s1, p1 = time_distributed_encoder_block_resp(inputs, 32,temporal_maxpool=False)
+    s2, p2 = time_distributed_encoder_block_resp(p1, 64,temporal_maxpool=False)
+
+    # Bridge
+    b1 = time_distributed_conv_block(p2, 128)
+
+    d1 = time_distributed_decoder_block_resp(b1, s2, 64)
+    d2 = time_distributed_decoder_block_resp(d1, s1, 32)
+
+    outputs = layers.Conv3D(num_classes, (1, 1, 1))(d2)
+
+    model = models.Model(inputs, outputs, name="3D-U-Net-resp")
+    return model
+
+def time_distributed_encoder_block(input_tensor, num_filters, temporal_maxpool=True):
+    x = time_distributed_conv_block(input_tensor, num_filters)
+
+    p = layers.TimeDistributed(layers.MaxPooling2D((2, 2)))(x)
+    if temporal_maxpool:
+
+        p = tf.transpose(p, (0,2,3,1,4))
+        p2 = layers.TimeDistributed(layers.TimeDistributed(layers.MaxPooling1D((2))))(p)
+        p2 = tf.transpose(p2, (0,3,1,2,4))
+        return x, p2
+    else:
+        return x, p
+
+def time_distributed_decoder_block(input_tensor, skip_tensor, num_filters, temporal_upsamp=True):
+    x = layers.TimeDistributed(layers.UpSampling2D(( 2, 2)))(input_tensor)
+    x = layers.TimeDistributed(layers.Conv2D(num_filters, (3, 3), padding="same"))(x)
+    if temporal_upsamp:
+        x = tf.transpose(x, (0,2,3,1,4))
+        x = layers.TimeDistributed(layers.TimeDistributed(layers.UpSampling1D((2))))(x)
+        x = layers.TimeDistributed(layers.TimeDistributed(layers.Conv1D(num_filters, (2),padding="same")))(x)
+        x = tf.transpose(x, (0,3,1,2,4))
+
+    if x.shape[4] == 64:
+        skip_tensor = tf.transpose(skip_tensor, (0,2,3,1,4))
+        skip_tensor = layers.TimeDistributed(layers.TimeDistributed(layers.Conv1DTranspose(num_filters,kernel_size=2,strides=2)))(skip_tensor)
+        skip_tensor = tf.transpose(skip_tensor, (0,3,1,2,4))
+
+    if x.shape[4] == 32:
+        skip_tensor = tf.transpose(skip_tensor, (0,2,3,1,4))
+        skip_tensor = layers.TimeDistributed(layers.TimeDistributed(layers.Conv1DTranspose(num_filters,kernel_size=2,strides=2)))(skip_tensor)
+        skip_tensor = layers.TimeDistributed(layers.TimeDistributed(layers.Conv1DTranspose(num_filters,kernel_size=2,strides=2)))(skip_tensor)
+        skip_tensor = tf.transpose(skip_tensor, (0,3,1,2,4))
+
+    x = layers.Concatenate()([x, skip_tensor])
+    x = time_distributed_conv_block(x, num_filters)
+    return x
+
+def build_3d_unet(input_shape, num_classes):
+    inputs = layers.Input(shape=input_shape)
+
+    # Encoding path
+    s1, p1 = time_distributed_encoder_block(inputs, 32,temporal_maxpool=False)
+    s2, p2 = time_distributed_encoder_block(p1, 64,temporal_maxpool=False)
+    s3, p3 = time_distributed_encoder_block(p2, 128,temporal_maxpool=True)
+
+    # Bridge
+    b1 = time_distributed_conv_block(p3, 256)
+
+    # Decoding path
+    d1 = time_distributed_decoder_block(b1, s3, 128,temporal_upsamp=True)
+    d2 = time_distributed_decoder_block(d1, s2, 64,temporal_upsamp=True)
+    d3 = time_distributed_decoder_block(d2, s1, 32,temporal_upsamp=True)
+
+    # Output layer
+    outputs = layers.Conv3D(num_classes, (1, 1, 1))(d3)
+
+    model = models.Model(inputs, outputs, name="3D-U-Net")
+    return model

utils/dicom_headerfile.dcm

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

utils/layer_util.py

@@ -0,0 +1,89 @@
+# Copyright 2021 University College London. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Layer utilities."""
+
+import tensorflow as tf
+
+# from tensorflow_mri.python.layers import convolutional
+# from tensorflow_mri.python.layers import signal_layers
+
+
+def get_nd_layer(name, rank):
+  """Get an N-D layer object.
+
+  Args:
+    name: A `str`. The name of the requested layer.
+    rank: An `int`. The rank of the requested layer.
+
+  Returns:
+    A `tf.keras.layers.Layer` object.
+
+  Raises:
+    ValueError: If the requested layer is unknown to TFMRI.
+  """
+  try:
+    return _ND_LAYERS[(name, rank)]
+  except KeyError as err:
+    raise ValueError(
+        f"Could not find a layer with name '{name}' and rank {rank}.") from err
+
+
+_ND_LAYERS = {
+    ('AveragePooling', 1): tf.keras.layers.AveragePooling1D,
+    ('AveragePooling', 2): tf.keras.layers.AveragePooling2D,
+    ('AveragePooling', 3): tf.keras.layers.AveragePooling3D,
+    ('Conv', 1): tf.keras.layers.Conv1D,
+    ('Conv', 2): tf.keras.layers.Conv2D,
+    ('Conv', 3): tf.keras.layers.Conv3D,
+    ('ConvLSTM', 1): tf.keras.layers.ConvLSTM1D,
+    ('ConvLSTM', 2): tf.keras.layers.ConvLSTM2D,
+    ('ConvLSTM', 3): tf.keras.layers.ConvLSTM3D,
+    ('ConvTranspose', 1): tf.keras.layers.Conv1DTranspose,
+    ('ConvTranspose', 2): tf.keras.layers.Conv2DTranspose,
+    ('ConvTranspose', 3): tf.keras.layers.Conv3DTranspose,
+    ('Cropping', 1): tf.keras.layers.Cropping1D,
+    ('Cropping', 2): tf.keras.layers.Cropping2D,
+    ('Cropping', 3): tf.keras.layers.Cropping3D,
+    ('DepthwiseConv', 1): tf.keras.layers.DepthwiseConv1D,
+    ('DepthwiseConv', 2): tf.keras.layers.DepthwiseConv2D,
+#     ('DWT', 1): signal_layers.DWT1D,
+#     ('DWT', 2): signal_layers.DWT2D,
+#     ('DWT', 3): signal_layers.DWT3D,
+    ('GlobalAveragePooling', 1): tf.keras.layers.GlobalAveragePooling1D,
+    ('GlobalAveragePooling', 2): tf.keras.layers.GlobalAveragePooling2D,
+    ('GlobalAveragePooling', 3): tf.keras.layers.GlobalAveragePooling3D,
+    ('GlobalMaxPool', 1): tf.keras.layers.GlobalMaxPool1D,
+    ('GlobalMaxPool', 2): tf.keras.layers.GlobalMaxPool2D,
+    ('GlobalMaxPool', 3): tf.keras.layers.GlobalMaxPool3D,
+#     ('IDWT', 1): signal_layers.IDWT1D,
+#     ('IDWT', 2): signal_layers.IDWT2D,
+#     ('IDWT', 3): signal_layers.IDWT3D,
+    ('LocallyConnected', 1): tf.keras.layers.LocallyConnected1D,
+    ('LocallyConnected', 2): tf.keras.layers.LocallyConnected2D,
+    ('MaxPool', 1): tf.keras.layers.MaxPool1D,
+    ('MaxPool', 2): tf.keras.layers.MaxPool2D,
+    ('MaxPool', 3): tf.keras.layers.MaxPool3D,
+    ('SeparableConv', 1): tf.keras.layers.SeparableConv1D,
+    ('SeparableConv', 2): tf.keras.layers.SeparableConv2D,
+    ('SpatialDropout', 1): tf.keras.layers.SpatialDropout1D,
+    ('SpatialDropout', 2): tf.keras.layers.SpatialDropout2D,
+    ('SpatialDropout', 3): tf.keras.layers.SpatialDropout3D,
+    ('UpSampling', 1): tf.keras.layers.UpSampling1D,
+    ('UpSampling', 2): tf.keras.layers.UpSampling2D,
+    ('UpSampling', 3): tf.keras.layers.UpSampling3D,
+    ('ZeroPadding', 1): tf.keras.layers.ZeroPadding1D,
+    ('ZeroPadding', 2): tf.keras.layers.ZeroPadding2D,
+    ('ZeroPadding', 3): tf.keras.layers.ZeroPadding3D
+}

utils/process_utils.py

@@ -0,0 +1,665 @@
+import numpy as np
+import tensorflow as tf
+import tensorflow_addons as tfa
+import tensorflow_mri as tfmri
+import tqdm
+import os
+import pydicom as dicom
+import glob
+from utils.unet3plusnew import *
+from utils.custom_unet_code import *
+from pydicom.tag import Tag
+import imageio
+from PIL import Image
+import streamlit as st
+import zipfile
+from collections import defaultdict
+import re
+from pydicom.tag import Tag
+from collections import defaultdict, Counter
+import io, shutil, zipfile, time
+
+#Resizes image
+def resize(t1,x,y):
+	# Adding new axis for the channels 
+	t1 = tf.expand_dims(t1, -1)
+
+	im1 = tf.image.resize_with_crop_or_pad(t1,x,y)
+	return (im1)
+
+#Function that normalises image
+def norm(t1):
+	im1= t1
+	im1 = (im1-np.min(im1)) / np.max(im1)
+	return (im1)
+
+#Applies debanding model to any number of slices
+def apply_debanding_model(input_im,frames =32):
+
+	debanding_model = "./models_final/Deband_model"
+	debanding = tf.keras.models.load_model(debanding_model, compile=False)
+	weights = debanding.get_weights()
+
+	inputs = tf.keras.Input(shape = [None,None,None,1])
+	unet = tfmri.models.UNet3D([32,64,128], kernel_size=3, out_channels=1,use_global_residual=False) 
+	DB = unet(inputs)
+	de_banding_model = tf.keras.Model(inputs = inputs, outputs = DB)
+	de_banding_model.set_weights(weights)
+
+	de_banded = []
+	for i in range(frames):
+		temp = de_banding_model.predict(tf.expand_dims(tf.expand_dims(input_im[i],0),-1),verbose = 0)
+		de_banded.append(temp)
+
+	return de_banded
+
+#Function that applies deformations to 28 slice data
+def deformation_28(x):
+
+	sagittal_deformed = []
+
+	for i in range(28):
+		
+		input_img = tf.expand_dims(x[0][0,i,:,:], -1) 
+		dy = tf.expand_dims(tf.expand_dims(x[1][0,i,:,:], -1),0)
+		dx = tf.expand_dims(tf.expand_dims(x[2][0,i,:,:], -1),0)
+		
+		displacement = tf.concat((dy[0,...],dx[0,...]), axis=-1)
+
+		img = tf.image.convert_image_dtype(tf.expand_dims(input_img, 0), tf.dtypes.float32)
+		displacement = tf.image.convert_image_dtype(displacement, tf.dtypes.float32)
+		dense_img_warp = tfa.image.dense_image_warp(img, displacement)
+		im_deformed = tf.squeeze(dense_img_warp, 0)
+		sagittal_deformed.append(im_deformed)
+
+	sagittal_deformed = tf.image.convert_image_dtype(sagittal_deformed, tf.dtypes.float32)
+	sagittal_deformed = tf.expand_dims(sagittal_deformed,axis= 0)
+
+	return sagittal_deformed
+
+#Applies respiratory correction model
+def apply_resp_model_28(input_im,frames = 32):
+
+	inputs = tf.keras.Input(shape = [None,256,128,1])
+	unet = build_3d_unet_resp([None,256,128,1],2) # Acts as aa deformation field generator
+	deformation_fields = unet(inputs) # Outputs the deformation fields
+	lambda_deformation = tf.keras.layers.Lambda(deformation_28)
+	out_2 = lambda_deformation([inputs[:,:,:,:,0],deformation_fields[:,:,:,:,0],deformation_fields[:,:,:,:,1]]) # Outputs the deformed volume
+	outputs  = [deformation_fields,out_2] 
+	complete_model = tf.keras.Model(inputs = inputs, outputs = outputs)
+	complete_model.load_weights('./models_final/Resp_Correction_model/variables/variables')
+
+	resp_corrected = []
+	deformations = []
+	for i in range(frames):
+
+		def_fields, resp_cor = complete_model.predict(input_im[i][:,:,:,:,:],verbose=0)
+		resp_corrected.append(resp_cor)
+		deformations.append(def_fields)
+
+	return deformations, resp_corrected
+
+#Applies super resolution model
+def apply_SR_model(input_im,frames = 32):
+	E2E_model = "./models_final/E2E_SR_model"
+	E2E = tf.keras.models.load_model(E2E_model, compile=False)
+	weights = E2E.get_weights()
+	sr_weights = weights[22:]
+
+	inputs = tf.keras.Input(shape = [None,None,None,1])
+	SR_model = build_3d_unet(input_shape=(None, None,None,1), num_classes=1)
+	SR = SR_model(inputs)
+	SR_model_done = tf.keras.Model(inputs = inputs, outputs = SR)
+	SR_model_done.set_weights(sr_weights)
+
+	super_resed = []
+	for i in range(frames):
+		super_resed.append(SR_model_done.predict(input_im[i],verbose=0))
+
+	return super_resed
+
+t = Tag(0x0019, 0x10D7)
+#Reads in example RT sagittal stack
+def load_data_samples(path_to_data):
+	sag_volumes = []
+	filename=f"{path_to_data}/*"
+	if not os.path.exists(path_to_data):
+		raise Exception("Error with file path.")
+	else:
+			
+		clean_ims_1 = []
+		locations_1 = []
+		
+		clean_ims_final =[]
+		locations_final = []
+		test = sorted(glob.glob(filename))
+		for file in test:
+			ds = dicom.dcmread(file)
+
+			locations_1.append(ds.SliceLocation)
+			clean_ims_1.append(ds.pixel_array)
+			if ds[t].value ==30:
+				clean_ims_final.append(np.array(clean_ims_1))
+				locations_final.append(locations_1)
+				clean_ims_1 = []
+				locations_1 = []
+				
+	
+		#clean_ims_1 = [x for _,x in sorted(zip(locations_1,clean_ims_1))]
+		#sag_volumes.append(clean_ims_1)
+		final = np.array(clean_ims_final)
+		final = np.transpose(final, (1,0,2,3))
+
+	return final
+
+
+def load_data_samples_from_folder(base_dir, number_of_scans=32):
+	"""
+	Recursively find all DICOM files under the first valid subfolder of base_dir,
+	group them by InstanceNumber (time), sort by SliceLocation (z), and return
+	a NumPy array of shape (time, z, H, W).
+	"""
+	# 1. Find the real nested folder (skip macOS junk)
+	candidates = [
+		d for d in os.listdir(base_dir)
+		if os.path.isdir(os.path.join(base_dir, d))
+		and not d.startswith("._")
+		and "__MACOSX" not in d
+	]
+	if not candidates:
+		st.error("No valid data folder found in ZIP.")
+		return np.array([])
+	nested_base = os.path.join(base_dir, candidates[0])
+
+	# 2. Recursively collect every file; we'll filter for DICOMs next
+	all_paths = glob.glob(os.path.join(nested_base, "**", "*"), recursive=True)
+	all_paths = [p for p in all_paths if os.path.isfile(p) and not os.path.basename(p).startswith("._")]
+
+	# 3. Filter valid DICOMs
+	dicom_files = []
+	for p in all_paths:
+		try:
+			ds = dicom.dcmread(p, force=True, stop_before_pixels=True)
+			if hasattr(ds, "InstanceNumber"):
+				dicom_files.append(p)
+		except:
+			continue
+
+	st.write(f"🧾 Found {len(dicom_files)} DICOM files.")
+
+	if not dicom_files:
+		st.error("No valid DICOMs found.")
+		return np.array([])
+
+	# 4. Group by InstanceNumber (temporal frames)
+	grouped = defaultdict(list)
+	for p in dicom_files:
+		try:
+			ds = dicom.dcmread(p, force=True)
+			inst = ds.InstanceNumber
+			loc  = getattr(ds, "SliceLocation", 0.0)
+			grouped[inst].append((loc, ds.pixel_array))
+		except:
+			continue
+
+	# 5. Build volume up to number_of_scans frames
+	vols = []
+	for inst in sorted(grouped.keys())[:number_of_scans]:
+		slices = grouped[inst]
+		# sort along z
+		slices.sort(key=lambda x: x[0])
+		vols.append([img for _, img in slices])
+
+	volume = np.array(vols)  # shape (T, Z, H, W)
+	st.write(f"✅ Found data shape: {volume.shape}")
+	return volume
+
+def load_cine_any(
+    base_dir: str,
+    number_of_scans: int = None,                 # if None, use all detected phases
+    private_phase_tag: Tag = Tag(0x0019, 0x10D7),# your private phase tag (if present)
+    verbose: bool = True
+):
+    """
+    Universal DICOM cine loader (flat or nested folders).
+
+    Scans recursively from `base_dir`, detects cardiac phases, sorts slices,
+    and returns (T, Z, H, W) along with the total number of phases detected.
+
+    Returns:
+        volume: np.ndarray with shape (T, Z, H, W)
+        num_phases_detected: int (total phases found in the dataset)
+    """
+    def log(msg):
+        if verbose:
+            try: st.write(msg)
+            except Exception: print(msg)
+
+    if not os.path.isdir(base_dir):
+        raise FileNotFoundError(f"No such directory: {base_dir}")
+
+    # --- Collect candidate files (recursive), skip junk/zips
+    candidates = glob.glob(os.path.join(base_dir, "**", "*"), recursive=True)
+    candidates = [
+        p for p in candidates
+        if os.path.isfile(p)
+        and "__MACOSX" not in p
+        and not os.path.basename(p).startswith("._")
+        and not p.lower().endswith(".zip")
+    ]
+    if not candidates:
+        log("No files found under the provided directory.")
+        return np.array([]), 0
+
+    # --- Keep only files that parse as DICOM headers
+    dicom_files = []
+    for p in candidates:
+        try:
+            _ = dicom.dcmread(p, force=True, stop_before_pixels=True)
+            dicom_files.append(p)
+        except Exception:
+            pass
+
+    log(f"🧾 Candidate DICOM files: {len(dicom_files)}")
+    if not dicom_files:
+        log("No valid DICOM files found.")
+        return np.array([]), 0
+
+    # --- NEW: detect flat folder layout (all files in the same directory)
+    dicom_dirs = {os.path.dirname(p) for p in dicom_files}
+    is_flat = (len(dicom_dirs) == 1)
+
+    # --- Probe to choose the best phase key
+    def _try_get(ds, tag):
+        try: return ds[tag].value
+        except Exception: return None
+
+    uniq_priv, uniq_tpi, uniq_inst = set(), set(), set()
+    for p in dicom_files[:min(len(dicom_files), 200)]:
+        try:
+            ds = dicom.dcmread(p, force=True, stop_before_pixels=True)
+            v_priv = _try_get(ds, private_phase_tag)
+            if v_priv is not None:
+                try: uniq_priv.add(int(v_priv))
+                except Exception: pass
+            if hasattr(ds, "TemporalPositionIdentifier"):
+                try: uniq_tpi.add(int(ds.TemporalPositionIdentifier))
+                except Exception: pass
+            if hasattr(ds, "InstanceNumber"):
+                try: uniq_inst.add(int(ds.InstanceNumber))
+                except Exception: pass
+        except Exception:
+            continue
+
+    if len(uniq_priv) > 1:
+        phase_key = ("private", private_phase_tag)
+    elif len(uniq_tpi) > 1:
+        phase_key = ("tpi", None)
+    elif len(uniq_inst) > 1:
+        phase_key = ("instance", None)
+    else:
+        log("Could not determine a phase key (no variation in private/TPI/InstanceNumber).")
+        return np.array([]), 0
+
+    def _get_phase(ds):
+        if phase_key[0] == "private":
+            v = _try_get(ds, phase_key[1]); return int(v) if v is not None else None
+        if phase_key[0] == "tpi":
+            return int(getattr(ds, "TemporalPositionIdentifier", None)) \
+                   if hasattr(ds, "TemporalPositionIdentifier") else None
+        if phase_key[0] == "instance":
+            return int(getattr(ds, "InstanceNumber", None)) \
+                   if hasattr(ds, "InstanceNumber") else None
+        return None
+
+    def _get_z(ds):
+        z = getattr(ds, "SliceLocation", None)
+        if z is None:
+            ipp = getattr(ds, "ImagePositionPatient", None)
+            if ipp is not None and len(ipp) >= 3:
+                try: z = float(ipp[2])
+                except Exception: z = 0.0
+            else:
+                z = 0.0
+        return float(z)
+
+    # --- Group by phase; sort by z
+    grouped = defaultdict(list)
+    for p in dicom_files:
+        try:
+            ds = dicom.dcmread(p, force=True)
+            ph = _get_phase(ds)
+            if ph is None:
+                continue
+            grouped[int(ph)].append((_get_z(ds), ds.pixel_array))
+        except Exception:
+            continue
+
+    if not grouped:
+        log("No groups formed (no phase could be read).")
+        return np.array([]), 0
+
+    all_phase_ids = sorted(grouped.keys())
+    num_phases_detected = len(all_phase_ids)
+    phases_to_use = all_phase_ids if number_of_scans is None else all_phase_ids[:number_of_scans]
+
+    stacks_T, slice_counts = [], []
+    for ph in phases_to_use:
+        pairs = grouped[ph]
+        if not pairs:
+            continue
+        pairs.sort(key=lambda x: x[0])                # sort by z
+        stack = [img for _, img in pairs]             # Z × H × W
+        stacks_T.append(stack)
+        slice_counts.append(len(stack))
+
+    if not stacks_T:
+        log("Groups existed but none had readable slices.")
+        return np.array([]), num_phases_detected
+
+    # Harmonize Z across phases (trim to the most common Z)
+    if len(set(slice_counts)) > 1:
+        common_Z = Counter(slice_counts).most_common(1)[0][0]
+        stacks_T = [s[:common_Z] for s in stacks_T if len(s) >= common_Z]
+        if not stacks_T:
+            log("All phases had inconsistent slice counts.")
+            return np.array([]), num_phases_detected
+
+    volume = np.array(stacks_T)  # (T, Z, H, W)
+
+    # --- NEW: flip slice order (Z) if data came from a flat single folder
+    if is_flat:
+        volume = volume[:, ::-1, :, :]
+
+    log(f"✅ Final volume shape: {volume[0,...].shape} , Phases detected = {num_phases_detected}")
+    return volume, num_phases_detected
+
+def load_data_samples_from_flat_folder(
+    base_dir: str,
+    number_of_scans: int = 32,
+    frame_tag: Tag = Tag(0x0019, 0x10D7)  # private phase tag (adjust if needed)
+) -> np.ndarray:
+    """
+    Robust loader when all DICOMs are under one folder (possibly nested).
+    - Steps into the single subfolder if present (ignores upload.zip, macOS junk).
+    - Recursively finds DICOMs (even without .dcm extension).
+    - Groups by phase from `frame_tag` or fallback (0020,0100).
+    - Sorts by SliceLocation/IPPs and returns (Z, T, H, W).
+    """
+    if not os.path.isdir(base_dir):
+        raise FileNotFoundError(f"No such directory: {base_dir}")
+
+    # --- Step 1: if there’s exactly one subfolder (plus upload.zip), dive into it
+    entries = [e for e in os.listdir(base_dir) if not e.startswith("._")]
+    subdirs = [os.path.join(base_dir, e) for e in entries
+               if os.path.isdir(os.path.join(base_dir, e)) and "__MACOSX" not in e]
+    # If precisely one subdir, prefer that as root; otherwise use base_dir as-is
+    root = subdirs[0] if len(subdirs) == 1 else base_dir
+
+    # --- Step 2: recursively collect candidate files (skip zips and junk)
+    candidates = glob.glob(os.path.join(root, "**", "*"), recursive=True)
+    candidates = [
+        p for p in candidates
+        if os.path.isfile(p)
+        and not os.path.basename(p).startswith("._")
+        and "__MACOSX" not in p
+        and not p.lower().endswith(".zip")
+    ]
+    if not candidates:
+        st.error("No files found under the provided directory.")
+        return np.array([])
+
+    # --- Step 3: keep only files that parse as DICOM headers
+    dicom_files = []
+    for p in candidates:
+        try:
+            ds = dicom.dcmread(p, force=True, stop_before_pixels=True)
+            dicom_files.append(p)
+        except Exception:
+            pass
+
+    st.write(f"🧾 Candidate DICOM files: {len(dicom_files)}")
+    if not dicom_files:
+        st.error("No valid DICOM files found.")
+        return np.array([])
+
+    # --- Helper: determine phase index
+    def _get_phase(ds):
+        # Preferred: private tag (your dataset)
+        if frame_tag in ds:
+            try:
+                return int(ds[frame_tag].value)
+            except Exception:
+                pass
+        # Fallback: standard TemporalPositionIdentifier (0020,0100)
+        if hasattr(ds, "TemporalPositionIdentifier"):
+            try:
+                return int(ds.TemporalPositionIdentifier)
+            except Exception:
+                pass
+        # Last resort: AcquisitionNumber (not always phase, but useful fallback)
+        if hasattr(ds, "AcquisitionNumber"):
+            try:
+                return int(ds.AcquisitionNumber)
+            except Exception:
+                pass
+        return None
+
+    # --- Step 4: group by phase; sort by z
+    grouped = defaultdict(list)
+    phase_missing = 0
+    for p in dicom_files:
+        try:
+            ds = dicom.dcmread(p, force=True)
+            phase = _get_phase(ds)
+            if phase is None:
+                phase_missing += 1
+                continue
+            # z-order: SliceLocation if present else IPP[2] else 0
+            z = getattr(ds, "SliceLocation", None)
+            if z is None:
+                ipp = getattr(ds, "ImagePositionPatient", None)
+                if ipp is not None and len(ipp) >= 3:
+                    z = float(ipp[2])
+                else:
+                    z = 0.0
+            img = ds.pixel_array
+            grouped[int(phase)].append((z, img))
+        except Exception:
+            continue
+
+    if not grouped:
+        st.error(
+            "Could not determine a phase tag for any files. "
+            "Check for (0019,10D7) or (0020,0100) in your dataset."
+        )
+        st.write(f"Files missing phase: {phase_missing} / {len(dicom_files)}")
+        # Optional: show attributes of one file to discover tags
+        try:
+            ds0 = dicom.dcmread(dicom_files[0], force=True, stop_before_pixels=True)
+            st.write("Sample DICOM attributes:", ds0.dir())
+        except Exception:
+            pass
+        return np.array([])
+
+    # keep up to number_of_scans phases
+    phases = sorted(grouped.keys())[:number_of_scans]
+
+    stacks_T = []
+    slice_counts = []
+    for ph in phases:
+        pairs = grouped[ph]
+        if not pairs:
+            continue
+        pairs.sort(key=lambda x: x[0])            # sort by z
+        stack = [img for _, img in pairs]         # Z × H × W
+        stacks_T.append(stack)
+        slice_counts.append(len(stack))
+
+    if not stacks_T:
+        st.error("No phases contained readable slices.")
+        return np.array([])
+
+    # Harmonize Z across phases (trim to the most common slice count)
+    if len(set(slice_counts)) > 1:
+        common_Z = Counter(slice_counts).most_common(1)[0][0]
+        stacks_T = [s[:common_Z] for s in stacks_T if len(s) >= common_Z]
+        if not stacks_T:
+            st.error("All phases had inconsistent slice counts.")
+            return np.array([])
+
+    vol = np.array(stacks_T)          # (T, Z, H, W)
+    st.write(f"✅ Final volume shape: {vol.shape} (T, S, H, W)")
+    return vol
+
+def extract_zip(zip_path, extract_to):
+	with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+		# Filter out __MACOSX and dotfiles
+		valid_files = [
+			f for f in zip_ref.namelist()
+			if "__MACOSX" not in f and not os.path.basename(f).startswith("._")
+		]
+		zip_ref.extractall(extract_to, members=valid_files)
+  
+def make_gif(path, timepoints, axis=-1, slice=60,frame_rate = 30):
+	# 1. Locate all .npy files
+	all_files = glob.glob(os.path.join(path, "*.npy"))
+	print("Found NPY files:", all_files)
+
+	# 2. Group them by prefix
+	scan_keys = ['raw', 'debanded', 'resp_cor', '3D_cine']
+	groups = {k: [] for k in scan_keys}
+
+	pattern = re.compile(r'(?P<prefix>raw|debanded|resp_cor|3D_cine)_(?P<index>\d+)\.npy')
+
+	for p in all_files:
+		fn = os.path.basename(p)
+		match = pattern.match(fn)
+		if match:
+			prefix = match.group("prefix")
+			t_idx = int(match.group("index"))
+			groups[prefix].append((t_idx, p))
+
+	# 3. Sanity check: do all groups exist & have equal lengths?
+	Ts = [len(v) for v in groups.values()]
+	print("Group counts:", Ts)
+	if not all(T == timepoints for T in Ts):
+		raise ValueError(f"Mismatch in timepoints across groups. Expected {timepoints}, got {Ts}")
+
+	for k in groups:
+		groups[k].sort(key=lambda x: x[0])  # sort by t_idx
+
+	# 4. Determine normalization range per group
+	stats = {}
+	for k in scan_keys:
+		mins, maxs = [], []
+		for _, p in groups[k]:
+			vol = np.load(p)
+			if axis == -1:
+				slice_ = vol[:, :, slice]
+			else:
+				slice_ = vol[:, slice, :] if axis == 1 else vol[slice, :, :]
+			mins.append(slice_.min())
+			maxs.append(slice_.max())
+		stats[k] = (min(mins), max(maxs))
+
+	# 5. Create frames
+	frames = []
+	for t in range(timepoints):
+		imgs_t = []
+		for k in scan_keys:
+			_, p = groups[k][t]
+			vol = np.load(p).astype(np.float32)
+
+			if axis == 2:
+				img = vol[::-1, :, slice]
+			elif axis == 1:
+				img = vol[:, slice, :]
+			elif axis == 0:
+				img = vol[slice, :, :]
+				img = np.transpose(img[:,::-1])
+
+			mn, mx = stats[k]
+			img = np.clip(img, mn, mx)
+			img8 = ((img - mn) / (mx - mn) * 255).astype(np.uint8)
+			img8 = img8.T[:, ::-1]  # flip + transpose
+			imgs_t.append(img8)
+
+		# Stitch side-by-side
+		composite = np.concatenate(imgs_t, axis=1)
+		resized = Image.fromarray(composite).resize((composite.shape[1]*3, composite.shape[0]*3), Image.NEAREST)
+		frames.append(np.array(resized))
+
+	# 6. Save and return
+	out_path = os.path.join(path, f"temp.gif")
+	imageio.mimsave(out_path, frames, duration=1000/frame_rate,loop =0)
+
+	return out_path
+
+def to_dicom(cardiac_frames, patient_number):
+	
+	filename="./utils/dicom_headerfile.dcm"
+	for file in glob.glob(filename):
+		ds = dicom.read_file(file)
+  
+	for i in range(cardiac_frames):
+		
+		volume = np.load(f'./out_dir/3D_cine_{i}.npy')
+		print(f"Volume: {i}")
+		for j in range(volume.shape[0]):
+			
+			PixelData = volume[j,:,:]
+
+			PixelData = (PixelData * 255).astype(np.uint16)
+
+			Dicoms = ds.copy()
+			
+			Dicoms.InstanceNumber = j
+			Dicoms.PatientID = 'Mark' 
+			Dicoms.PatientName = 'Mark'
+			Dicoms.StudyDescription = '3D Cine'
+			Dicoms.SeriesDescription = 'HR'
+			Dicoms.StudyInstanceUID = '1.3.12.2.1107.5.2.41.169828.3001002301121546102500000000' + str(patient_number)
+			
+			Dicoms.SliceThickness = 1.5
+			Dicoms.Rows = 256
+			Dicoms.Columns = 128
+			Dicoms.AcquisitionMatrix = [0, 256,128, 0]
+			Dicoms.ImageOrientationPatient = [1.0 ,0.0, 0.0, 0.0, 0.0, -1.0]
+			Dicoms.SliceLocation = -100.0 + ((j-1) * Dicoms.SliceThickness)
+			Dicoms.SamplesPerPixel = 1
+			
+			Dicoms.BitsAllocated = 16
+			Dicoms.BitsStored = 12
+			Dicoms.HighBit = 11
+			Dicoms.PixelRepresentation = 0
+			Dicoms.AcquisitionNumber = i
+			Dicoms.SeriesNumber = i
+			Dicoms.PixelSpacing = [1.5,1.5]
+			
+			Dicoms.SmallestImagePixelValue = 0
+			Dicoms.LargestImagePixelValue = 255
+			
+			Dicoms.PixelData = PixelData.tobytes()
+			
+			Dicoms.SeriesInstanceUID = '1.3.12.2.1107.5.2.41.169828.300100230112154610250000001' + str(i)
+			Dicoms.SOPInstanceUID = dicom.uid.generate_uid()
+			Dicoms.AcquisitionTime = str(i)
+			Dicoms.SeriesTime = str(i)
+
+			
+			dicom.filewriter.dcmwrite(filename=f'./out_dicoms/MARK_PATIENT_{patient_number}_VOL_{i}_SLICE_{j}.dcm',dataset=Dicoms)
+
+	return 42
+
+
+def zip_dir_to_memory(dir_path: str) -> io.BytesIO:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for root, _, files in os.walk(dir_path):
+            for f in files:
+                full = os.path.join(root, f)
+                arc = os.path.relpath(full, dir_path)  # keep relative paths in zip
+                zf.write(full, arc)
+    buf.seek(0)
+    return buf

utils/unet3plusnew.py

@@ -0,0 +1,186 @@
+# Python file containing unet3plus code used to train segmentation model
+
+import tensorflow as tf
+import numpy as np
+import utils.layer_util
+tf.random.set_seed(0)
+
+class unet3plus:
+   def __init__(self,
+                inputs,
+                filters = [32,64,128,256,512],
+                rank = 2,
+                out_channels = 3,
+                kernel_initializer=tf.keras.initializers.HeNormal(seed=0),
+                bias_initializer=tf.keras.initializers.Zeros(),
+                kernel_regularizer=None,
+                bias_regularizer=None,
+                add_dropout = False,
+                padding = 'same',
+                dropout_rate = 0.5,
+                kernel_size = 3,
+                out_kernel_size = 3,
+                pool_size = 2,
+                encoder_block_depth = 2,
+                decoder_block_depth = 1,
+                batch_norm = True,
+                activation = 'relu',
+                out_activation = None,
+                skip_batch_norm = True,
+                skip_type = 'encoder',
+                CGM = False,
+                deep_supervision = True):
+       
+       
+       self.inputs = inputs
+       self.filters = filters
+       self.scales = len(filters)
+       self.rank = rank
+       self.out_channels = out_channels
+       self.encoder_block_depth = encoder_block_depth
+       self.decoder_block_depth = decoder_block_depth
+       self.kernel_size = kernel_size
+       self.add_dropout = add_dropout
+       self.dropout_rate = dropout_rate
+       self.skip_type = skip_type  
+       self.skip_batch_norm = skip_batch_norm
+       self.batch_norm = batch_norm
+       if isinstance(activation, str):
+           self.activation = tf.keras.activations.get(activation)
+       else:
+           self.activation = activation
+       if isinstance(out_activation, str):
+           self.out_activation = tf.keras.activations.get(out_activation)
+       else:
+           self.out_activation = out_activation
+       # Assign pool size
+       if isinstance(pool_size,tuple):
+           self.pool_size = pool_size
+       else:
+           self.pool_size = tuple([pool_size for _ in range(rank)])
+       if isinstance(kernel_size,tuple):
+           self.kernel_size = kernel_size
+       else:
+           self.kernel_size = tuple([kernel_size for _ in range(rank)])
+       if isinstance(out_kernel_size,tuple):
+           self.out_kernel_size = out_kernel_size
+       else:
+           self.out_kernel_size = tuple([out_kernel_size for _ in range(rank)])
+       self.CGM = CGM
+       self.deep_supervision = deep_supervision
+       self.conv_config = dict(kernel_size = self.kernel_size,
+                          padding = padding,
+                          kernel_initializer = kernel_initializer,
+                          bias_initializer = bias_initializer,
+                          kernel_regularizer = kernel_regularizer,
+                          bias_regularizer = bias_regularizer)
+       self.out_conv_config = dict(kernel_size = out_kernel_size,
+                          padding = padding,
+                          kernel_initializer = kernel_initializer,
+                          bias_initializer = bias_initializer,
+                          kernel_regularizer = kernel_regularizer,
+                          bias_regularizer = bias_regularizer)
+   
+   def aggregate(self, scale_list, scale):
+       X = tf.keras.layers.Concatenate(name = f'D{scale}_input', axis = -1)(scale_list)
+       X = self.conv_block(X, self.filters[0] * self.scales, num_stacks = self.decoder_block_depth, layer_type = 'Decoder', scale=scale)
+       return X
+   
+   def deep_sup(self, inputs, scale):
+       conv = layer_util.get_nd_layer('Conv', self.rank)
+       upsamp = layer_util.get_nd_layer('UpSampling', self.rank)
+       size = tuple(np.array(self.pool_size)** (abs(scale-1)))
+       if self.rank == 2:
+           upsamp_config = dict(size=size, interpolation='bilinear')
+       else:
+           upsamp_config = dict(size=size)  
+       X = inputs  
+       X = conv(self.out_channels, activation = None, **self.out_conv_config, name = f'deepsup_conv_{scale}')(X)
+       if scale != 1:
+           X = upsamp(**upsamp_config, name = f'deepsup_upsamp_{scale}')(X)
+       #X = tf.keras.layers.Activation(activation = 'sigmoid' if self.out_channels == 1 else 'softmax', name = f'deepsup_activation_{scale}')(X)
+       X =self.out_activation(X)
+       return X
+       
+       
+       
+   def full_scale(self, inputs, to_layer, from_layer):
+       conv = layer_util.get_nd_layer('Conv', self.rank)
+       layer_diff = from_layer - to_layer  
+       size = tuple(np.array(self.pool_size)** (abs(layer_diff)))
+       maxpool = layer_util.get_nd_layer('MaxPool', self.rank)
+       upsamp = layer_util.get_nd_layer('UpSampling', self.rank)
+       if self.rank == 2:
+           upsamp_config = dict(size=size, interpolation='bilinear')
+       else:
+           upsamp_config = dict(size=size)
+       
+       X = inputs        
+       if to_layer < from_layer:
+           X = upsamp(**upsamp_config, name = f'Skip_Upsample_{from_layer}_{to_layer}')(X)
+       elif to_layer > from_layer:
+           X = maxpool(pool_size = size, name = f'Skip_Maxpool_{from_layer}_{to_layer}')(X)
+       
+       if self.skip_batch_norm:
+           X = self.conv_block(X, self.filters[0], num_stacks = self.decoder_block_depth, layer_type ='Skip', scale = f'{from_layer}_{to_layer}')
+       else:
+           X = conv(self.filters[0],**self.conv_config, name = f'Skip_Conv_{from_layer}_{to_layer}')(X)
+           
+       return X
+       
+   def conv_block(self, inputs, filters, num_stacks,layer_type, scale):
+       conv = layer_util.get_nd_layer('Conv', self.rank)
+       X = inputs
+       for i in range(num_stacks):
+           X = conv(filters, **self.conv_config, name = f'{layer_type}{scale}_Conv_{i+1}')(X)
+           if self.batch_norm:
+               X = tf.keras.layers.BatchNormalization(axis=-1, name = f'{layer_type}{scale}_BN_{i+1}')(X)
+           #X = tf.keras.layers.LeakyReLU(name = f'{layer_type}{scale}_Activation_{i+1}')(X)
+           X =  self.activation(X)
+       return X
+   
+   
+   def encode(self, inputs, scale, num_stacks):
+       maxpool = layer_util.get_nd_layer('MaxPool', self.rank)
+       scale -= 1 # python index
+       filters = self.filters[scale]
+       X = inputs
+       if scale != 0:
+           X = maxpool(pool_size=self.pool_size, name = f'encoding_{scale}_maxpool')(X)
+       X = self.conv_block(X, filters, num_stacks, layer_type = 'Encoder', scale = scale+1)
+       if scale == (self.scales-1) and self.add_dropout:
+           X = tf.keras.layers.Dropout(rate = self.dropout_rate, name = f'Encoder{scale+1}_dropout')(X)
+       return X
+       
+   def outputs(self):
+       XE  = [self.inputs]
+       for i in range(self.scales):
+           XE.append(self.encode(XE[i], scale = i+1, num_stacks = self.encoder_block_depth))
+       XD = [XE[-1]]
+       if self.skip_type == 'encoder':
+           for decoder_level in range(self.scales-1,0,-1):
+               input_contributions = []
+               for unet_level in range(1,self.scales+1):
+                   if unet_level == decoder_level+1:
+                       input_contributions.append(self.full_scale(XD[-1], decoder_level, unet_level))
+                   else:
+                       input_contributions.append(self.full_scale(XE[unet_level], decoder_level, unet_level))
+               XD.append(self.aggregate(input_contributions,decoder_level))
+       elif self.skip_type == 'decoder':
+           for decoder_level in range(self.scales-1,0,-1):
+               skip_contributions = []
+               # Append skips from encoder
+               for encoder_level in range(1,decoder_level+1):
+                   skip_contributions.append(self.full_scale(XE[encoder_level], decoder_level, encoder_level))
+               # Append skips from decoder
+               for i in range(len(XD)-1,-1,-1):
+                   skip_contributions.append(self.full_scale(XD[i], decoder_level, (self.scales-i)))
+               XD.append(self.aggregate(skip_contributions,decoder_level))
+       else:
+           raise ValueError(f"Invalid skip_type")
+       if self.deep_supervision == True:
+           XD = [self.deep_sup(xd, self.scales-i) for i,xd in enumerate(XD)]
+           return XD
+       else:
+           XD[-1] = self.deep_sup(XD[-1],1)
+           return XD[-1]