requirements, model weights, preprocessing and post processing

best_metric_model.pth

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

dicom_to_nii.py

@@ -0,0 +1,372 @@
+import pydicom
+import sys
+import os
+import numpy as np
+import nibabel as nib
+import scipy
+
+def convert_ct_dicom_to_nii(dir_dicom, dir_nii, outputname, newvoxelsize=None):
+    Patients = PatientList()  # initialize list of patient data
+    # search dicom files in the patient data folder, stores all files in the attributes (all CT images, dose file, struct file)
+    Patients.list_dicom_files(dir_dicom, 1)
+    patient = Patients.list[0]
+    patient_name = patient.PatientInfo.PatientName
+    patient.import_patient_data(newvoxelsize)
+    CT = patient.CTimages[0]
+    image_position_patient = CT.ImagePositionPatient
+    voxelsize = np.array(CT.PixelSpacing)
+    save_images(dst_dir=os.path.join(dir_nii), voxelsize=voxelsize,
+                image_position_patient=image_position_patient, image=CT.Image, outputname=outputname)
+    return CT
+
+
+def save_images(dst_dir, voxelsize, image_position_patient, image, outputname):
+
+    # encode in nii  and save at dst_dir
+    # IMPORTANT I NEED TO CONFIRM THE SIGNS OF THE ENTRIES IN THE AFFINE,
+    # ALTHOUGH MAYBE AT THE END THE IMPORTANCE IS HOW WE WILL USE THIS DATA ....
+    # also instead of changing field by field, the pixdim and affine can be encoded
+    # using the set_sform method --> info here: https://nipy.org/nibabel/nifti_images.html
+
+    # IMAGE (CT, MR ...)
+    image_shape = image.shape
+    # Separate Conversion from preprocessing
+    # image = overwrite_ct_threshold(image)
+    # for Nifti1 header, change for a Nifti2 type of header
+    image_nii = nib.Nifti1Image(image, affine=np.eye(4))
+    # Update header fields
+    image_nii = set_header_info(image_nii, voxelsize, image_position_patient)
+    
+    # Save  nii    
+    nib.save(image_nii, os.path.join(dst_dir, outputname))
+    
+    # nib.save(image_nii, os.path.join(dst_dir, 'ct.nii.gz'))
+
+
+# def overwrite_ct_threshold(ct_image, body, artefact=None, contrast=None):
+#     # Change the HU out of the body to air: -1000
+#     ct_image[body == 0] = -1000
+#     if artefact is not None:
+#         # Change the HU to muscle: 14
+#         ct_image[artefact == 1] = 14
+#     if contrast is not None:
+#         # Change the HU to water: 0 Houndsfield Unit: CT unit
+#         ct_image[contrast == 1] = 0
+#     # Threshold above 1560HU
+#     ct_image[ct_image > 1560] = 1560
+#     return ct_image
+
+
+def set_header_info(nii_file, voxelsize, image_position_patient, contours_exist=None):
+    nii_file.header['pixdim'][1] = voxelsize[0]
+    nii_file.header['pixdim'][2] = voxelsize[1]
+    nii_file.header['pixdim'][3] = voxelsize[2]
+
+    # affine - voxelsize
+    nii_file.affine[0][0] = voxelsize[0]
+    nii_file.affine[1][1] = voxelsize[1]
+    nii_file.affine[2][2] = voxelsize[2]
+    # affine - imagecorner
+    nii_file.affine[0][3] = image_position_patient[0]
+    nii_file.affine[1][3] = image_position_patient[1]
+    nii_file.affine[2][3] = image_position_patient[2]
+    if contours_exist:
+        nii_file.header.extensions.append(
+            nib.nifti1.Nifti1Extension(0, bytearray(contours_exist)))
+    return nii_file
+
+
+class PatientList:
+
+    def __init__(self):
+        self.list = []
+
+    def find_CT_image(self, display_id):
+        count = -1
+        for patient_id in range(len(self.list)):
+            for ct_id in range(len(self.list[patient_id].CTimages)):
+                if (self.list[patient_id].CTimages[ct_id].isLoaded == 1):
+                    count += 1
+                if (count == display_id):
+                    break
+            if (count == display_id):
+                break
+
+        return patient_id, ct_id
+
+    def find_dose_image(self, display_id):
+        count = -1
+        for patient_id in range(len(self.list)):
+            for dose_id in range(len(self.list[patient_id].RTdoses)):
+                if (self.list[patient_id].RTdoses[dose_id].isLoaded == 1):
+                    count += 1
+                if (count == display_id):
+                    break
+            if (count == display_id):
+                break
+
+        return patient_id, dose_id
+
+    def find_contour(self, ROIName):
+        for patient_id in range(len(self.list)):
+            for struct_id in range(len(self.list[patient_id].RTstructs)):
+                if (self.list[patient_id].RTstructs[struct_id].isLoaded == 1):
+                    for contour_id in range(len(self.list[patient_id].RTstructs[struct_id].Contours)):
+                        if (self.list[patient_id].RTstructs[struct_id].Contours[contour_id].ROIName == ROIName):
+                            return patient_id, struct_id, contour_id
+
+    def list_dicom_files(self, folder_path, recursive):
+        file_list = os.listdir(folder_path)
+        # print("len file_list", len(file_list), "folderpath",folder_path)
+        for file_name in file_list:
+            file_path = os.path.join(folder_path, file_name)
+
+            # folders
+            if os.path.isdir(file_path):
+                if recursive == True:
+                    subfolder_list = self.list_dicom_files(file_path, True)
+                    # join_patient_lists(Patients, subfolder_list)
+
+            # files
+            elif os.path.isfile(file_path):
+
+                try:
+                    dcm = pydicom.dcmread(file_path)
+                except:
+                    print("Invalid Dicom file: " + file_path)
+                    continue
+
+                patient_id = next((x for x, val in enumerate(
+                    self.list) if val.PatientInfo.PatientID == dcm.PatientID), -1)
+
+                if patient_id == -1:
+                    Patient = PatientData()
+                    Patient.PatientInfo.PatientID = dcm.PatientID
+                    Patient.PatientInfo.PatientName = str(dcm.PatientName)
+                    Patient.PatientInfo.PatientBirthDate = dcm.PatientBirthDate
+                    Patient.PatientInfo.PatientSex = dcm.PatientSex
+                    self.list.append(Patient)
+                    patient_id = len(self.list) - 1
+
+                # Dicom CT
+                if dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.2":
+                    ct_id = next((x for x, val in enumerate(
+                        self.list[patient_id].CTimages) if val.SeriesInstanceUID == dcm.SeriesInstanceUID), -1)
+                    if ct_id == -1:
+                        CT = CTimage()
+                        CT.SeriesInstanceUID = dcm.SeriesInstanceUID
+                        CT.SOPClassUID == "1.2.840.10008.5.1.4.1.1.2"
+                        CT.PatientInfo = self.list[patient_id].PatientInfo
+                        CT.StudyInfo = StudyInfo()
+                        CT.StudyInfo.StudyInstanceUID = dcm.StudyInstanceUID
+                        CT.StudyInfo.StudyID = dcm.StudyID
+                        CT.StudyInfo.StudyDate = dcm.StudyDate
+                        CT.StudyInfo.StudyTime = dcm.StudyTime
+                        if (hasattr(dcm, 'SeriesDescription') and dcm.SeriesDescription != ""):
+                            CT.ImgName = dcm.SeriesDescription
+                        else:
+                            CT.ImgName = dcm.SeriesInstanceUID
+                        self.list[patient_id].CTimages.append(CT)
+                        ct_id = len(self.list[patient_id].CTimages) - 1
+
+                    self.list[patient_id].CTimages[ct_id].DcmFiles.append(
+                        file_path)
+
+                else:
+                    print("Unknown SOPClassUID " +
+                          dcm.SOPClassUID + " for file " + file_path)
+
+            # other
+            else:
+                print("Unknown file type " + file_path)
+
+    def print_patient_list(self):
+        print("")
+        for patient in self.list:
+            patient.print_patient_info()
+
+        print("")
+
+
+class PatientData:
+
+    def __init__(self):
+        self.PatientInfo = PatientInfo()
+        self.CTimages = []
+
+    def print_patient_info(self, prefix=""):
+        print("")
+        print(prefix + "PatientName: " + self.PatientInfo.PatientName)
+        print(prefix + "PatientID: " + self.PatientInfo.PatientID)
+
+        for ct in self.CTimages:
+            print("")
+            ct.print_CT_info(prefix + "   ")
+
+    def import_patient_data(self, newvoxelsize=None):
+        # import CT images
+        for i, ct in enumerate(self.CTimages):
+            if (ct.isLoaded == 1):
+                continue
+            ct.import_Dicom_CT()
+        # Resample CT images
+        for i, ct in enumerate(self.CTimages):
+            ct.resample_CT(newvoxelsize)
+
+
+class PatientInfo:
+
+    def __init__(self):
+        self.PatientID = ''
+        self.PatientName = ''
+        self.PatientBirthDate = ''
+        self.PatientSex = ''
+
+
+class StudyInfo:
+
+    def __init__(self):
+        self.StudyInstanceUID = ''
+        self.StudyID = ''
+        self.StudyDate = ''
+        self.StudyTime = ''
+
+
+class CTimage:
+
+    def __init__(self):
+        self.SeriesInstanceUID = ""
+        self.PatientInfo = {}
+        self.StudyInfo = {}
+        self.FrameOfReferenceUID = ""
+        self.ImgName = ""
+        self.SOPClassUID = ""
+        self.DcmFiles = []
+        self.isLoaded = 0
+
+    def print_CT_info(self, prefix=""):
+        print(prefix + "CT series: " + self.SeriesInstanceUID)
+        for ct_slice in self.DcmFiles:
+            print(prefix + "   " + ct_slice)
+
+    def resample_CT(self, newvoxelsize):
+        ct = self.Image
+        # Rescaling to the newvoxelsize if given in parameter
+        if newvoxelsize is not None:
+            source_shape = self.GridSize
+            voxelsize = self.PixelSpacing
+            # print("self.ImagePositionPatient",self.ImagePositionPatient, "source_shape",source_shape,"voxelsize",voxelsize)
+            VoxelX_source = self.ImagePositionPatient[0] + \
+                np.arange(source_shape[0])*voxelsize[0]
+            VoxelY_source = self.ImagePositionPatient[1] + \
+                np.arange(source_shape[1])*voxelsize[1]
+            VoxelZ_source = self.ImagePositionPatient[2] + \
+                np.arange(source_shape[2])*voxelsize[2]
+
+            target_shape = np.ceil(np.array(source_shape).astype(
+                float)*np.array(voxelsize).astype(float)/newvoxelsize).astype(int)
+            VoxelX_target = self.ImagePositionPatient[0] + \
+                np.arange(target_shape[0])*newvoxelsize[0]
+            VoxelY_target = self.ImagePositionPatient[1] + \
+                np.arange(target_shape[1])*newvoxelsize[1]
+            VoxelZ_target = self.ImagePositionPatient[2] + \
+                np.arange(target_shape[2])*newvoxelsize[2]
+            # print("source_shape",source_shape,"target_shape",target_shape)
+            if (all(source_shape == target_shape) and np.linalg.norm(np.subtract(voxelsize, newvoxelsize) < 0.001)):
+                print("Image does not need filtering")
+            else:
+                # anti-aliasing filter
+                sigma = [0, 0, 0]
+                if (newvoxelsize[0] > voxelsize[0]):
+                    sigma[0] = 0.4 * (newvoxelsize[0]/voxelsize[0])
+                if (newvoxelsize[1] > voxelsize[1]):
+                    sigma[1] = 0.4 * (newvoxelsize[1]/voxelsize[1])
+                if (newvoxelsize[2] > voxelsize[2]):
+                    sigma[2] = 0.4 * (newvoxelsize[2]/voxelsize[2])
+
+                if (sigma != [0, 0, 0]):
+                    print("Image is filtered before downsampling")
+                    ct = scipy.ndimage.gaussian_filter(ct, sigma)
+
+                xi = np.array(np.meshgrid(
+                    VoxelX_target, VoxelY_target, VoxelZ_target))
+                xi = np.rollaxis(xi, 0, 4)
+                xi = xi.reshape((xi.size // 3, 3))
+
+                # get resized ct
+                ct = scipy.interpolate.interpn((VoxelX_source, VoxelY_source, VoxelZ_source), ct, xi, method='linear',
+                                               fill_value=-1000, bounds_error=False).reshape(target_shape).transpose(1, 0, 2)
+
+            self.PixelSpacing = newvoxelsize
+        self.GridSize = list(ct.shape)
+        self.NumVoxels = self.GridSize[0] * self.GridSize[1] * self.GridSize[2]
+        self.Image = ct
+        # print("self.ImagePositionPatient",self.ImagePositionPatient, "self.GridSize[0]",self.GridSize[0],"self.PixelSpacing",self.PixelSpacing)
+
+        self.VoxelX = self.ImagePositionPatient[0] + \
+            np.arange(self.GridSize[0])*self.PixelSpacing[0]
+        self.VoxelY = self.ImagePositionPatient[1] + \
+            np.arange(self.GridSize[1])*self.PixelSpacing[1]
+        self.VoxelZ = self.ImagePositionPatient[2] + \
+            np.arange(self.GridSize[2])*self.PixelSpacing[2]
+        self.isLoaded = 1
+
+    def import_Dicom_CT(self):
+
+        if (self.isLoaded == 1):
+            print("Warning: CT serries " +
+                  self.SeriesInstanceUID + " is already loaded")
+            return
+
+        images = []
+        SOPInstanceUIDs = []
+        SliceLocation = np.zeros(len(self.DcmFiles), dtype='float')
+
+        for i in range(len(self.DcmFiles)):
+            file_path = self.DcmFiles[i]
+            dcm = pydicom.dcmread(file_path)
+
+            if (hasattr(dcm, 'SliceLocation') and abs(dcm.SliceLocation - dcm.ImagePositionPatient[2]) > 0.001):
+                print("WARNING: SliceLocation (" + str(dcm.SliceLocation) +
+                      ") is different than ImagePositionPatient[2] (" + str(dcm.ImagePositionPatient[2]) + ") for " + file_path)
+
+            SliceLocation[i] = float(dcm.ImagePositionPatient[2])
+            images.append(dcm.pixel_array * dcm.RescaleSlope +
+                          dcm.RescaleIntercept)
+            SOPInstanceUIDs.append(dcm.SOPInstanceUID)
+
+        # sort slices according to their location in order to reconstruct the 3d image
+        sort_index = np.argsort(SliceLocation)
+        SliceLocation = SliceLocation[sort_index]
+        SOPInstanceUIDs = [SOPInstanceUIDs[n] for n in sort_index]
+        images = [images[n] for n in sort_index]
+        ct = np.dstack(images).astype("float32")
+
+        if ct.shape[0:2] != (dcm.Rows, dcm.Columns):
+            print("WARNING: GridSize " + str(ct.shape[0:2]) + " different from Dicom Rows (" + str(
+                dcm.Rows) + ") and Columns (" + str(dcm.Columns) + ")")
+
+        MeanSliceDistance = (
+            SliceLocation[-1] - SliceLocation[0]) / (len(images)-1)
+        if (abs(MeanSliceDistance - dcm.SliceThickness) > 0.001):
+            print("WARNING: MeanSliceDistance (" + str(MeanSliceDistance) +
+                  ") is different from SliceThickness (" + str(dcm.SliceThickness) + ")")
+
+        self.FrameOfReferenceUID = dcm.FrameOfReferenceUID
+        self.ImagePositionPatient = [float(dcm.ImagePositionPatient[0]), float(
+            dcm.ImagePositionPatient[1]), SliceLocation[0]]
+        self.PixelSpacing = [float(dcm.PixelSpacing[0]), float(
+            dcm.PixelSpacing[1]), MeanSliceDistance]
+        self.GridSize = list(ct.shape)
+        self.NumVoxels = self.GridSize[0] * self.GridSize[1] * self.GridSize[2]
+        self.Image = ct
+        self.SOPInstanceUIDs = SOPInstanceUIDs
+        self.VoxelX = self.ImagePositionPatient[0] + \
+            np.arange(self.GridSize[0])*self.PixelSpacing[0]
+        self.VoxelY = self.ImagePositionPatient[1] + \
+            np.arange(self.GridSize[1])*self.PixelSpacing[1]
+        self.VoxelZ = self.ImagePositionPatient[2] + \
+            np.arange(self.GridSize[2])*self.PixelSpacing[2]
+        self.isLoaded = 1
+
+print("Convert CT dicom to nii done")

nii_to_dicom.py

@@ -0,0 +1,501 @@
+import nibabel as nib
+import pydicom
+import os
+import glob
+import numpy as np
+from copy import deepcopy
+from matplotlib.patches import Polygon
+import warnings
+from scipy.ndimage import find_objects
+from scipy.ndimage.morphology import binary_fill_holes
+from skimage import measure
+from PIL import Image, ImageDraw
+import scipy
+import datetime
+
+def convert_nii_to_dicom(dicomctdir, predictedNiiFile, predictedDicomFile, predicted_structures=[], rtstruct_colors=[], refCT = None):
+    # img = nib.load(os.path.join(predniidir, patient_id, 'RTStruct.nii.gz'))
+    # data = img.get_fdata()[:,:,:,1]
+    # patient_list = PatientList() # initialize list of patient data
+    # patient_list.list_dicom_files(os.path.join(ct_ref_path,patient,inner_ct_ref_path), 1) # search dicom files in the patient data folder, stores all files in the attributes (all CT images, dose file, struct file)
+    # refCT = patient_list.list[0].CTimages[0]
+    # refCT.import_Dicom_CT()
+
+    struct = RTstruct()
+    struct.load_from_nii(predictedNiiFile, predicted_structures, rtstruct_colors) #TODO add already the refCT info in here because there are fields to do that
+    if not struct.Contours[0].Mask_PixelSpacing == refCT.PixelSpacing:
+      struct.resample_struct(refCT.PixelSpacing)
+    struct.export_Dicom(refCT, predictedDicomFile)
+
+    # create_RT_struct(dicomctdir, data.transpose([1,0,2]).astype(int), dicomdir, predicted_structures)
+
+class RTstruct:
+
+  def __init__(self):
+    self.SeriesInstanceUID = ""
+    self.PatientInfo = {}
+    self.StudyInfo = {}
+    self.CT_SeriesInstanceUID = ""
+    self.DcmFile = ""
+    self.isLoaded = 0
+    self.Contours = []
+    self.NumContours = 0
+    
+    
+  def print_struct_info(self, prefix=""):
+    print(prefix + "Struct: " + self.SeriesInstanceUID)
+    print(prefix + "   " + self.DcmFile)
+    
+    
+  def print_ROINames(self):
+    print("RT Struct UID: " + self.SeriesInstanceUID)
+    count = -1
+    for contour in self.Contours:
+      count += 1
+      print('  [' + str(count) + ']  ' + contour.ROIName)
+    
+  def resample_struct(self, newvoxelsize):
+    # Rescaling to the newvoxelsize if given in parameter
+    if newvoxelsize is not None: 
+      for i, Contour in enumerate(self.Contours):
+        source_shape = Contour.Mask_GridSize
+        voxelsize = Contour.Mask_PixelSpacing
+        VoxelX_source = Contour.Mask_Offset[0] + np.arange(source_shape[0])*voxelsize[0]
+        VoxelY_source = Contour.Mask_Offset[1] + np.arange(source_shape[1])*voxelsize[1]
+        VoxelZ_source = Contour.Mask_Offset[2] + np.arange(source_shape[2])*voxelsize[2]
+
+        target_shape = np.ceil(np.array(source_shape).astype(float)*np.array(voxelsize).astype(float)/newvoxelsize).astype(int)
+        VoxelX_target = Contour.Mask_Offset[0] + np.arange(target_shape[0])*newvoxelsize[0]
+        VoxelY_target = Contour.Mask_Offset[1] + np.arange(target_shape[1])*newvoxelsize[1]
+        VoxelZ_target = Contour.Mask_Offset[2] + np.arange(target_shape[2])*newvoxelsize[2]
+
+        contour = Contour.Mask
+        
+        if(all(source_shape == target_shape) and np.linalg.norm(np.subtract(voxelsize, newvoxelsize) < 0.001)):
+          print("! Image does not need filtering")
+        else:
+          # anti-aliasing filter
+          sigma = [0, 0, 0]
+          if(newvoxelsize[0] > voxelsize[0]): sigma[0] = 0.4 * (newvoxelsize[0]/voxelsize[0])
+          if(newvoxelsize[1] > voxelsize[1]): sigma[1] = 0.4 * (newvoxelsize[1]/voxelsize[1])
+          if(newvoxelsize[2] > voxelsize[2]): sigma[2] = 0.4 * (newvoxelsize[2]/voxelsize[2])
+          
+          if(sigma != [0, 0, 0]):
+              contour = scipy.ndimage.gaussian_filter(contour.astype(float), sigma)
+              #come back to binary
+              contour[np.where(contour>=0.5)] = 1
+              contour[np.where(contour<0.5)] = 0
+              
+          xi = np.array(np.meshgrid(VoxelX_target, VoxelY_target, VoxelZ_target))
+          xi = np.rollaxis(xi, 0, 4)
+          xi = xi.reshape((xi.size // 3, 3))
+          
+          # get resized ct
+          contour = scipy.interpolate.interpn((VoxelX_source,VoxelY_source,VoxelZ_source), contour, xi, method='nearest', fill_value=0, bounds_error=False).astype(bool).reshape(target_shape).transpose(1,0,2)
+        Contour.Mask_PixelSpacing = newvoxelsize
+        Contour.Mask_GridSize = list(contour.shape) 
+        Contour.NumVoxels = Contour.Mask_GridSize[0] * Contour.Mask_GridSize[1] * Contour.Mask_GridSize[2]
+        Contour.Mask = contour
+        self.Contours[i]=Contour
+        
+  
+  def import_Dicom_struct(self, CT):
+    if(self.isLoaded == 1):
+      print("Warning: RTstruct " + self.SeriesInstanceUID + " is already loaded")
+      return 
+    dcm = pydicom.dcmread(self.DcmFile)
+    
+    self.CT_SeriesInstanceUID = CT.SeriesInstanceUID
+    
+    for dcm_struct in dcm.StructureSetROISequence:  
+      ReferencedROI_id = next((x for x, val in enumerate(dcm.ROIContourSequence) if val.ReferencedROINumber == dcm_struct.ROINumber), -1)
+      dcm_contour = dcm.ROIContourSequence[ReferencedROI_id]
+    
+      Contour = ROIcontour()
+      Contour.SeriesInstanceUID = self.SeriesInstanceUID
+      Contour.ROIName = dcm_struct.ROIName
+      Contour.ROIDisplayColor = dcm_contour.ROIDisplayColor
+    
+      #print("Import contour " + str(len(self.Contours)) + ": " + Contour.ROIName)
+    
+      Contour.Mask = np.zeros((CT.GridSize[0], CT.GridSize[1], CT.GridSize[2]), dtype=np.bool)
+      Contour.Mask_GridSize = CT.GridSize
+      Contour.Mask_PixelSpacing = CT.PixelSpacing
+      Contour.Mask_Offset = CT.ImagePositionPatient
+      Contour.Mask_NumVoxels = CT.NumVoxels   
+      Contour.ContourMask = np.zeros((CT.GridSize[0], CT.GridSize[1], CT.GridSize[2]), dtype=np.bool)
+      
+      SOPInstanceUID_match = 1
+      
+      if not hasattr(dcm_contour, 'ContourSequence'):
+          print("This structure has no attribute ContourSequence. Skipping ...")
+          continue
+
+      for dcm_slice in dcm_contour.ContourSequence:
+        Slice = {}
+      
+        # list of Dicom coordinates
+        Slice["XY_dcm"] = list(zip( np.array(dcm_slice.ContourData[0::3]), np.array(dcm_slice.ContourData[1::3]) ))
+        Slice["Z_dcm"] = float(dcm_slice.ContourData[2])
+      
+        # list of coordinates in the image frame
+        Slice["XY_img"] = list(zip( ((np.array(dcm_slice.ContourData[0::3]) - CT.ImagePositionPatient[0]) / CT.PixelSpacing[0]), ((np.array(dcm_slice.ContourData[1::3]) - CT.ImagePositionPatient[1]) / CT.PixelSpacing[1]) ))
+        Slice["Z_img"] = (Slice["Z_dcm"] - CT.ImagePositionPatient[2]) / CT.PixelSpacing[2]
+        Slice["Slice_id"] = int(round(Slice["Z_img"]))
+      
+        # convert polygon to mask (based on matplotlib - slow)
+        #x, y = np.meshgrid(np.arange(CT.GridSize[0]), np.arange(CT.GridSize[1]))
+        #points = np.transpose((x.ravel(), y.ravel()))
+        #path = Path(Slice["XY_img"])
+        #mask = path.contains_points(points)
+        #mask = mask.reshape((CT.GridSize[0], CT.GridSize[1]))
+      
+        # convert polygon to mask (based on PIL - fast)
+        img = Image.new('L', (CT.GridSize[0], CT.GridSize[1]), 0)
+        if(len(Slice["XY_img"]) > 1): ImageDraw.Draw(img).polygon(Slice["XY_img"], outline=1, fill=1)
+        mask = np.array(img)
+        Contour.Mask[:,:,Slice["Slice_id"]] = np.logical_or(Contour.Mask[:,:,Slice["Slice_id"]], mask)
+        
+        # do the same, but only keep contour in the mask
+        img = Image.new('L', (CT.GridSize[0], CT.GridSize[1]), 0)
+        if(len(Slice["XY_img"]) > 1): ImageDraw.Draw(img).polygon(Slice["XY_img"], outline=1, fill=0)
+        mask = np.array(img)
+        Contour.ContourMask[:,:,Slice["Slice_id"]] = np.logical_or(Contour.ContourMask[:,:,Slice["Slice_id"]], mask)
+            
+        Contour.ContourSequence.append(Slice)
+      
+        # check if the contour sequence is imported on the correct CT slice:
+        if(hasattr(dcm_slice, 'ContourImageSequence') and CT.SOPInstanceUIDs[Slice["Slice_id"]] != dcm_slice.ContourImageSequence[0].ReferencedSOPInstanceUID):
+          SOPInstanceUID_match = 0
+      
+      if SOPInstanceUID_match != 1:
+        print("WARNING: some SOPInstanceUIDs don't match during importation of " + Contour.ROIName + " contour on CT image")
+      
+      self.Contours.append(Contour)
+      self.NumContours += 1
+    #print("self.NumContours",self.NumContours, len(self.Contours))
+    self.isLoaded = 1
+
+  def load_from_nii(self, struct_nii_path, rtstruct_labels, rtstruct_colors):
+      
+    # load the nii image 
+    struct_nib = nib.load(struct_nii_path)
+    struct_data = struct_nib.get_fdata()
+            
+    # get contourexists from header
+    if len(struct_nib.header.extensions)==0:
+      contoursexist = []
+    else:
+      contoursexist = list(struct_nib.header.extensions[0].get_content())
+    
+    # get number of rois in struct_data 
+    # for nii with consecutive integers
+    #roinumbers = np.unique(struct_data) 
+    # for nii with power of 2 format
+    roinumbers = list(np.arange(np.floor(np.log2(np.max(struct_data))).astype(int)+1)) # CAREFUL WITH THIS LINE, MIGHT NOT WORK ALWAYS IF WE HAVE OVERLAP OF 
+    nb_rois_in_struct = len(roinumbers)
+    
+    # check that they match
+    if len(contoursexist)!=0 and (not len(rtstruct_labels) == len(contoursexist) == nb_rois_in_struct):
+        #raise TypeError("The number or struct labels, contoursexist, and  masks in struct.nii.gz is not the same")
+        raise Warning("The number or struct labels, contoursexist, and estimated masks in struct.nii.gz is not the same. Taking len(contoursexist) as number of rois")
+        self.NumContours = len(contoursexist)
+    else:
+        self.NumContours = nb_rois_in_struct
+        
+    # fill in contours
+    #TODO fill in ContourSequence and ContourData to be faster later in writeDicomRTstruct
+    for c in range(self.NumContours):
+        
+        Contour = ROIcontour()
+        Contour.SeriesInstanceUID = self.SeriesInstanceUID
+        Contour.ROIName = rtstruct_labels[c]
+        if rtstruct_colors[c] == None:
+            Contour.ROIDisplayColor = [0, 0, 255] # default color is blue
+        else:
+            Contour.ROIDisplayColor = rtstruct_colors[c] 
+        if len(contoursexist)!=0 and contoursexist[c] == 0:
+            Contour.Mask = np.zeros((struct_nib.header['dim'][1], struct_nib.header['dim'][2], struct_nib.header['dim'][3]), dtype=np.bool_)
+        else:
+            Contour.Mask = np.bitwise_and(struct_data.astype(int), 2 ** c).astype(bool)
+        #TODO enable option for consecutive integers masks?
+        Contour.Mask_GridSize = [struct_nib.header['dim'][1], struct_nib.header['dim'][2], struct_nib.header['dim'][3]]
+        Contour.Mask_PixelSpacing = [struct_nib.header['pixdim'][1], struct_nib.header['pixdim'][2], struct_nib.header['pixdim'][3]]
+        Contour.Mask_Offset = [struct_nib.header['qoffset_x'], struct_nib.header['qoffset_y'], struct_nib.header['qoffset_z']]
+        Contour.Mask_NumVoxels = struct_nib.header['dim'][1].astype(int) * struct_nib.header['dim'][2].astype(int) * struct_nib.header['dim'][3].astype(int) 
+        # Contour.ContourMask --> this should be only the contour, so far we don't need it so I'll skip it
+      
+        # apend to self
+        self.Contours.append(Contour)
+        
+
+  def export_Dicom(self, refCT, outputFile):   
+                 
+    # meta data
+    
+    # generate UID
+    #uid_base = '' #TODO define one for us if we want? Siri is using: uid_base='1.2.826.0.1.3680043.10.230.',
+    # personal UID, applied for via https://www.medicalconnections.co.uk/FreeUID/
+    
+    SOPInstanceUID = pydicom.uid.generate_uid() #TODO verify this! Siri was using a uid_base, this line is taken from OpenTPS writeRTPlan
+    #SOPInstanceUID = pydicom.uid.generate_uid('1.2.840.10008.5.1.4.1.1.481.3.') # siri's version
+    
+    meta = pydicom.dataset.FileMetaDataset()
+    meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.481.3' # UID class for RTSTRUCT
+    meta.MediaStorageSOPInstanceUID = SOPInstanceUID
+    # meta.ImplementationClassUID = uid_base + '1.1.1' # Siri's
+    meta.ImplementationClassUID =  '1.2.250.1.59.3.0.3.5.0' # from OpenREGGUI
+    meta.TransferSyntaxUID = '1.2.840.10008.1.2' # Siri's and OpenREGGUI
+    meta.FileMetaInformationGroupLength = 188 # from Siri
+    # meta.ImplementationVersionName = 'DCIE 2.2' # from Siri
+    
+    
+    # Main data elements - only required fields, optional fields like StudyDescription are not included for simplicity
+    ds = pydicom.dataset.FileDataset(outputFile, {}, file_meta=meta, preamble=b"\0" * 128) # preamble is taken from this example https://pydicom.github.io/pydicom/dev/auto_examples/input_output/plot_write_dicom.html#sphx-glr-auto-examples-input-output-plot-write-dicom-py
+    
+    # Patient info - will take it from the referenced CT image
+    ds.PatientName = refCT.PatientInfo.PatientName
+    ds.PatientID = refCT.PatientInfo.PatientID
+    ds.PatientBirthDate = refCT.PatientInfo.PatientBirthDate
+    ds.PatientSex = refCT.PatientInfo.PatientSex
+    
+    # General Study 
+    dt = datetime.datetime.now()
+    ds.StudyDate = dt.strftime('%Y%m%d')
+    ds.StudyTime = dt.strftime('%H%M%S.%f')
+    ds.AccessionNumber = '1' # A RIS/PACS (Radiology Information System/picture archiving and communication system) generated number that identifies the order for the Study.
+    ds.ReferringPhysicianName = 'NA'
+    ds.StudyInstanceUID = refCT.StudyInfo.StudyInstanceUID # get from reference CT to indicate that they belong to the same study
+    ds.StudyID = refCT.StudyInfo.StudyID # get from reference CT to indicate that they belong to the same study
+    
+    # RT Series
+    #ds.SeriesDate # optional
+    #ds.SeriesTime # optional
+    ds.Modality = 'RTSTRUCT'
+    ds.SeriesDescription = 'AI-predicted' + dt.strftime('%Y%m%d') + dt.strftime('%H%M%S.%f')
+    ds.OperatorsName = 'MIRO AI team'
+    ds.SeriesInstanceUID = pydicom.uid.generate_uid() # if we have a uid_base --> pydicom.uid.generate_uid(uid_base)
+    ds.SeriesNumber = '1'
+    
+    # General Equipment
+    ds.Manufacturer = 'MIRO lab'
+    #ds.InstitutionName = 'MIRO lab' # optional
+    #ds.ManufacturerModelName = 'nnUNet' # optional, but can be a good tag to insert the model information or label
+    #ds.SoftwareVersions # optional, but can be used to insert the version of the code in PARROT or the version of the model
+    
+    # Frame of Reference
+    ds.FrameOfReferenceUID = refCT.FrameOfReferenceUID
+    ds.PositionReferenceIndicator = '' # empty if unknown - info here https://dicom.innolitics.com/ciods/rt-structure-set/frame-of-reference/00201040
+    
+    # Structure Set
+    ds.StructureSetLabel = 'AI predicted' # do not use - or spetial characters or the Dicom Validation in Raystation will give a warning
+    #ds.StructureSetName # optional
+    #ds.StructureSetDescription # optional
+    ds.StructureSetDate = dt.strftime('%Y%m%d')
+    ds.StructureSetTime = dt.strftime('%H%M%S.%f')
+    ds.ReferencedFrameOfReferenceSequence = pydicom.Sequence()# optional
+    # we assume there is only one, the CT
+    dssr = pydicom.Dataset()
+    dssr.FrameOfReferenceUID = refCT.FrameOfReferenceUID
+    dssr.RTReferencedStudySequence = pydicom.Sequence()
+    # fill in sequence
+    dssr_refStudy = pydicom.Dataset()
+    dssr_refStudy.ReferencedSOPClassUID = '1.2.840.10008.3.1.2.3.1' # Study Management Detached
+    dssr_refStudy.ReferencedSOPInstanceUID = refCT.StudyInfo.StudyInstanceUID
+    dssr_refStudy.RTReferencedSeriesSequence = pydicom.Sequence()
+    #initialize
+    dssr_refStudy_series = pydicom.Dataset()
+    dssr_refStudy_series.SeriesInstanceUID = refCT.SeriesInstanceUID
+    dssr_refStudy_series.ContourImageSequence = pydicom.Sequence()
+    # loop over slices of CT
+    for slc in range(len(refCT.SOPInstanceUIDs)):
+        dssr_refStudy_series_slc = pydicom.Dataset()
+        dssr_refStudy_series_slc.ReferencedSOPClassUID = refCT.SOPClassUID
+        dssr_refStudy_series_slc.ReferencedSOPInstanceUID = refCT.SOPInstanceUIDs[slc]
+        # append
+        dssr_refStudy_series.ContourImageSequence.append(dssr_refStudy_series_slc)
+    
+    # append
+    dssr_refStudy.RTReferencedSeriesSequence.append(dssr_refStudy_series)
+    # append
+    dssr.RTReferencedStudySequence.append(dssr_refStudy)
+    #append
+    ds.ReferencedFrameOfReferenceSequence.append(dssr)
+    #
+    ds.StructureSetROISequence = pydicom.Sequence()   
+    # loop over the ROIs to fill in the fields
+    for iroi in range(self.NumContours):
+        # initialize the Dataset        
+        dssr = pydicom.Dataset()
+        dssr.ROINumber = iroi + 1 # because iroi starts at zero and ROINumber cannot be zero
+        dssr.ReferencedFrameOfReferenceUID = ds.FrameOfReferenceUID # coming from refCT
+        dssr.ROIName = self.Contours[iroi].ROIName
+        #dssr.ROIDescription # optional 
+        dssr.ROIGenerationAlgorithm = 'AUTOMATIC' # can also be 'SEMIAUTOMATIC' OR 'MANUAL', info here https://dicom.innolitics.com/ciods/rt-structure-set/structure-set/30060020/30060036
+        #TODO enable a function to tell us which type of GenerationAlgorithm we have    
+        ds.StructureSetROISequence.append(dssr)
+
+    # delete to remove space
+    del dssr
+    
+    #TODO merge all loops into one to be faster, although like this the code is easier to follow I find
+    
+    # ROI Contour
+    ds.ROIContourSequence = pydicom.Sequence()
+    # loop over the ROIs to fill in the fields
+    for iroi in range(self.NumContours):
+        # initialize the Dataset
+        dssr = pydicom.Dataset()
+        dssr.ROIDisplayColor = self.Contours[iroi].ROIDisplayColor
+        dssr.ReferencedROINumber = iroi + 1 # because iroi starts at zero and ReferencedROINumber cannot be zero
+        dssr.ContourSequence = pydicom.Sequence() 
+        # mask to polygon
+        polygonMeshList = self.Contours[iroi].getROIContour()
+        # get z vector
+        z_coords = list(np.arange(self.Contours[iroi].Mask_Offset[2],self.Contours[iroi].Mask_Offset[2]+self.Contours[iroi].Mask_GridSize[2]*self.Contours[iroi].Mask_PixelSpacing[2], self.Contours[iroi].Mask_PixelSpacing[2]))
+        # loop over the polygonMeshList to fill in ContourSequence
+        for polygon in polygonMeshList:
+
+            # initialize the Dataset
+            dssr_slc = pydicom.Dataset()
+            dssr_slc.ContourGeometricType = 'CLOSED_PLANAR' # can also be 'POINT', 'OPEN_PLANAR', 'OPEN_NONPLANAR', info here https://dicom.innolitics.com/ciods/rt-structure-set/roi-contour/30060039/30060040/30060042
+            #TODO enable the proper selection of the ContourGeometricType
+
+            # fill in contour points and data
+            dssr_slc.NumberOfContourPoints = len(polygon[0::3])
+            #dssr_slc.ContourNumber # optional
+            dssr_slc.ContourData = polygon
+            
+            #get slice
+            polygon_z = polygon[2]
+            slc = z_coords.index(polygon_z)
+            # fill in ContourImageSequence
+            dssr_slc.ContourImageSequence = pydicom.Sequence() # Sequence of images containing the contour
+            # in our case, we assume we only have one, the reference CT (refCT)
+            dssr_slc_ref = pydicom.Dataset()
+            dssr_slc_ref.ReferencedSOPClassUID = refCT.SOPClassUID
+            dssr_slc_ref.ReferencedSOPInstanceUID = refCT.SOPInstanceUIDs[slc]
+            dssr_slc.ContourImageSequence.append(dssr_slc_ref)
+              
+            # append Dataset to Sequence
+            dssr.ContourSequence.append(dssr_slc)
+            
+        # append Dataset
+        ds.ROIContourSequence.append(dssr)
+    
+    # RT ROI Observations
+    ds.RTROIObservationsSequence = pydicom.Sequence()
+    # loop over the ROIs to fill in the fields
+    for iroi in range(self.NumContours):
+        # initialize the Dataset
+        dssr = pydicom.Dataset()
+        dssr.ObservationNumber = iroi + 1 # because iroi starts at zero and ReferencedROINumber cannot be zero
+        dssr.ReferencedROINumber = iroi + 1 ## because iroi starts at zero and ReferencedROINumber cannot be zero
+        dssr.ROIObservationLabel = self.Contours[iroi].ROIName #optional
+        dssr.RTROIInterpretedType = 'ORGAN' # we can have many types, see here https://dicom.innolitics.com/ciods/rt-structure-set/rt-roi-observations/30060080/300600a4
+        # TODO enable a better fill in of the RTROIInterpretedType
+        dssr.ROIInterpreter = '' # empty if unknown
+        # append Dataset
+        ds.RTROIObservationsSequence.append(dssr)
+    
+    # Approval
+    ds.ApprovalStatus = 'UNAPPROVED'#'APPROVED' 
+    # if ds.ApprovalStatus = 'APPROVED', then we need to fill in the reviewer information
+    #ds.ReviewDate = dt.strftime('%Y%m%d')
+    #ds.ReviewTime = dt.strftime('%H%M%S.%f')
+    #ds.ReviewerName = 'MIRO AI team'
+    
+    # SOP common
+    ds.SpecificCharacterSet = 'ISO_IR 100' # conditionally required - see info here https://dicom.innolitics.com/ciods/rt-structure-set/sop-common/00080005
+    #ds.InstanceCreationDate # optional
+    #ds.InstanceCreationTime # optional
+    ds.SOPClassUID = '1.2.840.10008.5.1.4.1.1.481.3' #RTSTRUCT file
+    ds.SOPInstanceUID = SOPInstanceUID# Siri's --> pydicom.uid.generate_uid(uid_base)
+    #ds.InstanceNumber # optional
+    
+    # save dicom file
+    print("Export dicom RTSTRUCT: " + outputFile)
+    ds.save_as(outputFile)
+
+
+
+      
+class ROIcontour:
+
+    def __init__(self):
+      self.SeriesInstanceUID = ""
+      self.ROIName = ""
+      self.ContourSequence = []
+      
+    def getROIContour(self): # this is from new version of OpenTPS, I(ana) have adapted it to work with old version of self.Contours[i].Mask
+    
+        try:
+            from skimage.measure import label, find_contours
+            from skimage.segmentation import find_boundaries
+        except:
+            print('Module skimage (scikit-image) not installed, ROIMask cannot be converted to ROIContour')
+            return 0
+    
+        polygonMeshList = []
+        for zSlice in range(self.Mask.shape[2]):
+    
+            labeledImg, numberOfLabel = label(self.Mask[:, :, zSlice], return_num=True)
+    
+            for i in range(1, numberOfLabel + 1):
+    
+                singleLabelImg = labeledImg == i
+                contours = find_contours(singleLabelImg.astype(np.uint8), level=0.6)
+    
+                if len(contours) > 0:
+    
+                    if len(contours) == 2:
+    
+                        ## use a different threshold in the case of an interior contour
+                        contours2 = find_contours(singleLabelImg.astype(np.uint8), level=0.4)
+    
+                        interiorContour = contours2[1]
+                        polygonMesh = []
+                        for point in interiorContour:
+    
+                            #xCoord = np.round(point[1]) * self.Mask_PixelSpacing[1] + self.Mask_Offset[1] # original Damien in OpenTPS
+                            #yCoord = np.round(point[0]) * self.Mask_PixelSpacing[0] + self.Mask_Offset[0] # original Damien in OpenTPS
+                            xCoord = np.round(point[1]) * self.Mask_PixelSpacing[0] + self.Mask_Offset[0] #AB
+                            yCoord = np.round(point[0]) * self.Mask_PixelSpacing[1] + self.Mask_Offset[1] #AB
+                            zCoord = zSlice * self.Mask_PixelSpacing[2] + self.Mask_Offset[2]
+    
+                            #polygonMesh.append(yCoord) # original Damien in OpenTPS
+                            #polygonMesh.append(xCoord) # original Damien in OpenTPS
+                            polygonMesh.append(xCoord) # AB
+                            polygonMesh.append(yCoord) # AB
+                            polygonMesh.append(zCoord)
+    
+                        polygonMeshList.append(polygonMesh)
+    
+                    contour = contours[0]
+    
+                    polygonMesh = []
+                    for point in contour:
+    
+                        #xCoord = np.round(point[1]) * self.Mask_PixelSpacing[1] + self.Mask_Offset[1] # original Damien in OpenTPS
+                        #yCoord = np.round(point[0]) * self.Mask_PixelSpacing[0] + self.Mask_Offset[0] # original Damien in OpenTPS
+                        xCoord = np.round(point[1]) * self.Mask_PixelSpacing[0] + self.Mask_Offset[0] #AB
+                        yCoord = np.round(point[0]) * self.Mask_PixelSpacing[1] + self.Mask_Offset[1] #AB
+                        zCoord = zSlice * self.Mask_PixelSpacing[2] + self.Mask_Offset[2]
+    
+                        polygonMesh.append(xCoord) # AB
+                        polygonMesh.append(yCoord) # AB
+                        #polygonMesh.append(yCoord) # original Damien in OpenTPS
+                        #polygonMesh.append(xCoord) # original Damien in OpenTPS
+                        polygonMesh.append(zCoord)
+    
+                    polygonMeshList.append(polygonMesh)
+    
+        ## I (ana) will comment this part since I will not use the class ROIContour for simplicity ###
+        #from opentps.core.data._roiContour import ROIContour  ## this is done here to avoir circular imports issue
+        #contour = ROIContour(name=self.ROIName, displayColor=self.ROIDisplayColor)
+        #contour.polygonMesh = polygonMeshList
+    
+        #return contour
+        
+        # instead returning the polygonMeshList directly
+        return polygonMeshList

postprocessing.py

@@ -0,0 +1,347 @@
+from monai.transforms import MapTransform, Transform
+from monai.config import KeysCollection
+from typing import Dict, Hashable, Mapping, Optional, Type, Union, Sequence
+import torch, sys
+from pathlib import Path
+from monai.config import DtypeLike, KeysCollection, PathLike
+from monai.data import image_writer
+from monai.transforms.transform import MapTransform
+from monai.utils import GridSamplePadMode, ensure_tuple, ensure_tuple_rep, optional_import
+from monai.data.meta_tensor import MetaTensor
+from monai.data.folder_layout import FolderLayout
+from pydoc import locate
+import numpy as np
+import nibabel as nib, os
+from monai.utils.enums import PostFix
+
+DEFAULT_POST_FIX = PostFix.meta()
+
+def set_header_info(nii_file, voxelsize, image_position_patient, contours_exist = None):
+    nii_file.header['pixdim'][1] = voxelsize[0]
+    nii_file.header['pixdim'][2] = voxelsize[1]
+    nii_file.header['pixdim'][3] = voxelsize[2]
+    
+    #affine - voxelsize
+    nii_file.affine[0][0] = voxelsize[0]
+    nii_file.affine[1][1] = voxelsize[1]
+    nii_file.affine[2][2] = voxelsize[2]
+    #affine - imagecorner
+    nii_file.affine[0][3] = image_position_patient[0]
+    nii_file.affine[1][3] = image_position_patient[1]
+    nii_file.affine[2][3] = image_position_patient[2]
+    if contours_exist:
+        nii_file.header.extensions.append(nib.nifti1.Nifti1Extension(0, bytearray(contours_exist)))
+    return nii_file
+
+
+def add_contours_exist(preddir, refCT):
+    img = nib.load(os.path.join(preddir, 'RTStruct.nii.gz'))
+    data = img.get_fdata().astype(int)
+    contours_exist = []
+    data_one_hot = np.zeros(data.shape[:3])
+    # We remove the first channel as it is the background
+    for i in range(data.shape[-1]-1):
+        if np.count_nonzero(data[:,:,:,i+1])>0:
+            contours_exist.append(1)
+            data_one_hot+=np.where(data[:,:,:,i+1]==1,2**i,0)
+        else:
+            contours_exist.append(0)    
+
+    data_one_hot_nii = nib.Nifti1Image(data_one_hot, affine=np.eye(4))
+    data_one_hot_nii = set_header_info(data_one_hot_nii, voxelsize=np.array(refCT.PixelSpacing), image_position_patient=refCT.ImagePositionPatient, contours_exist=contours_exist)
+    nib.save(data_one_hot_nii,os.path.join(preddir, 'RTStruct.nii.gz'))
+
+class SaveImaged(MapTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.transforms.SaveImage`.
+
+    Note:
+        Image should be channel-first shape: [C,H,W,[D]].
+        If the data is a patch of big image, will append the patch index to filename.
+
+    Args:
+        keys: keys of the corresponding items to be transformed.
+            See also: :py:class:`monai.transforms.compose.MapTransform`
+        meta_keys: explicitly indicate the key of the corresponding metadata dictionary.
+            For example, for data with key `image`, the metadata by default is in `image_meta_dict`.
+            The metadata is a dictionary contains values such as filename, original_shape.
+            This argument can be a sequence of string, map to the `keys`.
+            If `None`, will try to construct meta_keys by `key_{meta_key_postfix}`.
+        meta_key_postfix: if `meta_keys` is `None`, use `key_{meta_key_postfix}` to retrieve the metadict.
+        output_dir: output image directory.
+        output_postfix: a string appended to all output file names, default to `trans`.
+        output_ext: output file extension name, available extensions: `.nii.gz`, `.nii`, `.png`.
+        output_dtype: data type for saving data. Defaults to ``np.float32``.
+        resample: whether to resample image (if needed) before saving the data array,
+            based on the `spatial_shape` (and `original_affine`) from metadata.
+        mode: This option is used when ``resample=True``. Defaults to ``"nearest"``.
+            Depending on the writers, the possible options are:
+
+            - {``"bilinear"``, ``"nearest"``, ``"bicubic"``}.
+              See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
+            - {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}.
+              See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate
+
+        padding_mode: This option is used when ``resample = True``. Defaults to ``"border"``.
+            Possible options are {``"zeros"``, ``"border"``, ``"reflection"``}
+            See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
+        scale: {``255``, ``65535``} postprocess data by clipping to [0, 1] and scaling
+            [0, 255] (uint8) or [0, 65535] (uint16). Default is `None` (no scaling).
+        dtype: data type during resampling computation. Defaults to ``np.float64`` for best precision.
+            if None, use the data type of input data. To be compatible with other modules,
+        output_dtype: data type for saving data. Defaults to ``np.float32``.
+            it's used for NIfTI format only.
+        allow_missing_keys: don't raise exception if key is missing.
+        squeeze_end_dims: if True, any trailing singleton dimensions will be removed (after the channel
+            has been moved to the end). So if input is (C,H,W,D), this will be altered to (H,W,D,C), and
+            then if C==1, it will be saved as (H,W,D). If D is also 1, it will be saved as (H,W). If `false`,
+            image will always be saved as (H,W,D,C).
+        data_root_dir: if not empty, it specifies the beginning parts of the input file's
+            absolute path. It's used to compute `input_file_rel_path`, the relative path to the file from
+            `data_root_dir` to preserve folder structure when saving in case there are files in different
+            folders with the same file names. For example, with the following inputs:
+
+            - input_file_name: `/foo/bar/test1/image.nii`
+            - output_postfix: `seg`
+            - output_ext: `.nii.gz`
+            - output_dir: `/output`
+            - data_root_dir: `/foo/bar`
+
+            The output will be: /output/test1/image/image_seg.nii.gz
+
+        separate_folder: whether to save every file in a separate folder. For example: for the input filename
+            `image.nii`, postfix `seg` and folder_path `output`, if `separate_folder=True`, it will be saved as:
+            `output/image/image_seg.nii`, if `False`, saving as `output/image_seg.nii`. Default to `True`.
+        print_log: whether to print logs when saving. Default to `True`.
+        output_format: an optional string to specify the output image writer.
+            see also: `monai.data.image_writer.SUPPORTED_WRITERS`.
+        writer: a customised `monai.data.ImageWriter` subclass to save data arrays.
+            if `None`, use the default writer from `monai.data.image_writer` according to `output_ext`.
+            if it's a string, it's treated as a class name or dotted path;
+            the supported built-in writer classes are ``"NibabelWriter"``, ``"ITKWriter"``, ``"PILWriter"``.
+
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        meta_keys: Optional[KeysCollection] = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        output_dir: Union[Path, str] = "./",
+        output_postfix: str = "trans",
+        output_ext: str = ".nii.gz",
+        resample: bool = True,
+        mode: str = "nearest",
+        padding_mode: str = GridSamplePadMode.BORDER,
+        scale: Optional[int] = None,
+        dtype: DtypeLike = np.float64,
+        output_dtype: DtypeLike = np.float32,
+        allow_missing_keys: bool = False,
+        squeeze_end_dims: bool = True,
+        data_root_dir: str = "",
+        separate_folder: bool = True,
+        print_log: bool = True,
+        output_format: str = "",
+        writer: Union[Type[image_writer.ImageWriter], str, None] = None,
+    ) -> None:
+        super().__init__(keys, allow_missing_keys)
+        self.meta_keys = ensure_tuple_rep(meta_keys, len(self.keys))
+        self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys))
+        self.saver = SaveImage(
+            output_dir=output_dir,
+            output_postfix=output_postfix,
+            output_ext=output_ext,
+            resample=resample,
+            mode=mode,
+            padding_mode=padding_mode,
+            scale=scale,
+            dtype=dtype,
+            output_dtype=output_dtype,
+            squeeze_end_dims=squeeze_end_dims,
+            data_root_dir=data_root_dir,
+            separate_folder=separate_folder,
+            print_log=print_log,
+            output_format=output_format,
+            writer=writer,
+        )
+
+    def set_options(self, init_kwargs=None, data_kwargs=None, meta_kwargs=None, write_kwargs=None):
+        self.saver.set_options(init_kwargs, data_kwargs, meta_kwargs, write_kwargs)
+
+    def __call__(self, data):
+        d = dict(data)
+        for key, meta_key, meta_key_postfix in self.key_iterator(d, self.meta_keys, self.meta_key_postfix):
+            if meta_key is None and meta_key_postfix is not None:
+                meta_key = f"{key}_{meta_key_postfix}"
+            meta_data = d.get(meta_key) if meta_key is not None else None
+            self.saver(img=d[key], meta_data=meta_data)
+        return d
+
+
+class SaveImage(Transform):
+    """
+    Save the image (in the form of torch tensor or numpy ndarray) and metadata dictionary into files.
+
+    The name of saved file will be `{input_image_name}_{output_postfix}{output_ext}`,
+    where the `input_image_name` is extracted from the provided metadata dictionary.
+    If no metadata provided, a running index starting from 0 will be used as the filename prefix.
+
+    Args:
+        output_dir: output image directory.
+        output_postfix: a string appended to all output file names, default to `trans`.
+        output_ext: output file extension name.
+        output_dtype: data type for saving data. Defaults to ``np.float32``.
+        resample: whether to resample image (if needed) before saving the data array,
+            based on the `spatial_shape` (and `original_affine`) from metadata.
+        mode: This option is used when ``resample=True``. Defaults to ``"nearest"``.
+            Depending on the writers, the possible options are
+
+            - {``"bilinear"``, ``"nearest"``, ``"bicubic"``}.
+              See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
+            - {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}.
+              See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate
+
+        padding_mode: This option is used when ``resample = True``. Defaults to ``"border"``.
+            Possible options are {``"zeros"``, ``"border"``, ``"reflection"``}
+            See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
+        scale: {``255``, ``65535``} postprocess data by clipping to [0, 1] and scaling
+            [0, 255] (uint8) or [0, 65535] (uint16). Default is `None` (no scaling).
+        dtype: data type during resampling computation. Defaults to ``np.float64`` for best precision.
+            if None, use the data type of input data. To be compatible with other modules,
+        squeeze_end_dims: if True, any trailing singleton dimensions will be removed (after the channel
+            has been moved to the end). So if input is (C,H,W,D), this will be altered to (H,W,D,C), and
+            then if C==1, it will be saved as (H,W,D). If D is also 1, it will be saved as (H,W). If `false`,
+            image will always be saved as (H,W,D,C).
+        data_root_dir: if not empty, it specifies the beginning parts of the input file's
+            absolute path. It's used to compute `input_file_rel_path`, the relative path to the file from
+            `data_root_dir` to preserve folder structure when saving in case there are files in different
+            folders with the same file names. For example, with the following inputs:
+
+            - input_file_name: `/foo/bar/test1/image.nii`
+            - output_postfix: `seg`
+            - output_ext: `.nii.gz`
+            - output_dir: `/output`
+            - data_root_dir: `/foo/bar`
+
+            The output will be: /output/test1/image/image_seg.nii.gz
+
+        separate_folder: whether to save every file in a separate folder. For example: for the input filename
+            `image.nii`, postfix `seg` and folder_path `output`, if `separate_folder=True`, it will be saved as:
+            `output/image/image_seg.nii`, if `False`, saving as `output/image_seg.nii`. Default to `True`.
+        print_log: whether to print logs when saving. Default to `True`.
+        output_format: an optional string of filename extension to specify the output image writer.
+            see also: `monai.data.image_writer.SUPPORTED_WRITERS`.
+        writer: a customised `monai.data.ImageWriter` subclass to save data arrays.
+            if `None`, use the default writer from `monai.data.image_writer` according to `output_ext`.
+            if it's a string, it's treated as a class name or dotted path (such as ``"monai.data.ITKWriter"``);
+            the supported built-in writer classes are ``"NibabelWriter"``, ``"ITKWriter"``, ``"PILWriter"``.
+        channel_dim: the index of the channel dimension. Default to `0`.
+            `None` to indicate no channel dimension.
+    """
+
+    def __init__(
+        self,
+        output_dir: PathLike = "./",
+        output_postfix: str = "trans",
+        output_ext: str = ".nii.gz",
+        output_dtype: DtypeLike = np.float32,
+        resample: bool = True,
+        mode: str = "nearest",
+        padding_mode: str = GridSamplePadMode.BORDER,
+        scale: Optional[int] = None,
+        dtype: DtypeLike = np.float64,
+        squeeze_end_dims: bool = True,
+        data_root_dir: PathLike = "",
+        separate_folder: bool = True,
+        print_log: bool = True,
+        output_format: str = "",
+        writer: Union[Type[image_writer.ImageWriter], str, None] = None,
+        channel_dim: Optional[int] = 0,
+    ) -> None:
+        self.folder_layout = FolderLayout(
+            output_dir=output_dir,
+            postfix=output_postfix,
+            extension=output_ext,
+            parent=separate_folder,
+            makedirs=True,
+            data_root_dir=data_root_dir,
+        )
+
+        self.output_ext = output_ext.lower() or output_format.lower()
+        if isinstance(writer, str):
+            writer_, has_built_in = optional_import("monai.data", name=f"{writer}")  # search built-in
+            if not has_built_in:
+                writer_ = locate(f"{writer}")  # search dotted path
+            if writer_ is None:
+                raise ValueError(f"writer {writer} not found")
+            writer = writer_
+        self.writers = image_writer.resolve_writer(self.output_ext) if writer is None else (writer,)
+        self.writer_obj = None
+
+        _output_dtype = output_dtype
+        if self.output_ext == ".png" and _output_dtype not in (np.uint8, np.uint16):
+            _output_dtype = np.uint8
+        if self.output_ext == ".dcm" and _output_dtype not in (np.uint8, np.uint16):
+            _output_dtype = np.uint8
+        self.init_kwargs = {"output_dtype": _output_dtype, "scale": scale}
+        self.data_kwargs = {"squeeze_end_dims": squeeze_end_dims, "channel_dim": channel_dim}
+        self.meta_kwargs = {"resample": resample, "mode": mode, "padding_mode": padding_mode, "dtype": dtype}
+        self.write_kwargs = {"verbose": print_log}
+        self._data_index = 0
+
+    def set_options(self, init_kwargs=None, data_kwargs=None, meta_kwargs=None, write_kwargs=None):
+        """
+        Set the options for the underlying writer by updating the `self.*_kwargs` dictionaries.
+
+        The arguments correspond to the following usage:
+
+            - `writer = ImageWriter(**init_kwargs)`
+            - `writer.set_data_array(array, **data_kwargs)`
+            - `writer.set_metadata(meta_data, **meta_kwargs)`
+            - `writer.write(filename, **write_kwargs)`
+
+        """
+        if init_kwargs is not None:
+            self.init_kwargs.update(init_kwargs)
+        if data_kwargs is not None:
+            self.data_kwargs.update(data_kwargs)
+        if meta_kwargs is not None:
+            self.meta_kwargs.update(meta_kwargs)
+        if write_kwargs is not None:
+            self.write_kwargs.update(write_kwargs)
+
+
+    def __call__(self, img: Union[torch.Tensor, np.ndarray], meta_data: Optional[Dict] = None):
+        """
+        Args:
+            img: target data content that save into file. The image should be channel-first, shape: `[C,H,W,[D]]`.
+            meta_data: key-value pairs of metadata corresponding to the data.
+        """
+        meta_data = img.meta if isinstance(img, MetaTensor) else meta_data
+        subject = "RTStruct"#meta_data["patient_name"] if meta_data else str(self._data_index)
+        patch_index = None#meta_data.get(Key.PATCH_INDEX, None) if meta_data else None
+        filename = self.folder_layout.filename(subject=f"{subject}", idx=patch_index)
+        if meta_data and len(ensure_tuple(meta_data.get("spatial_shape", ()))) == len(img.shape):
+            self.data_kwargs["channel_dim"] = None
+
+        err = []
+        for writer_cls in self.writers:
+            try:
+                writer_obj = writer_cls(**self.init_kwargs)
+                writer_obj.set_data_array(data_array=img, **self.data_kwargs)
+                writer_obj.set_metadata(meta_dict=meta_data, **self.meta_kwargs)
+                writer_obj.write(filename, **self.write_kwargs)
+                self.writer_obj = writer_obj
+            except Exception as e:
+                print('err',e)
+            else:
+                self._data_index += 1
+                return img
+        msg = "\n".join([f"{e}" for e in err])
+        raise RuntimeError(
+            f"{self.__class__.__name__} cannot find a suitable writer for {filename}.\n"
+            "    Please install the writer libraries, see also the installation instructions:\n"
+            "    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies.\n"
+            f"   The current registered writers for {self.output_ext}: {self.writers}.\n{msg}"
+        )
+        

predict.py

@@ -0,0 +1,192 @@
+import os
+import os.path
+import sys
+import json
+import torch
+
+# +++++++++++++ Conversion imports +++++++++++++++++
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(os.path.abspath(".."))
+# +++++++++++++ Conversion imports +++++++++++++++++
+
+from dicom_to_nii import convert_ct_dicom_to_nii
+from nii_to_dicom import convert_nii_to_dicom
+
+
+# AI MONAI libraries
+from monai.networks.nets import UNet
+from monai.networks.layers import Norm
+from monai.inferers import sliding_window_inference
+from monai.data import CacheDataset, DataLoader, Dataset, decollate_batch, NibabelReader
+from monai.utils import first
+from monai.transforms import (
+    EnsureChannelFirstd,
+    Compose,
+    CropForegroundd,
+    ScaleIntensityRanged,
+    Invertd,
+    AsDiscreted,
+    ThresholdIntensityd,
+    RemoveSmallObjectsd,
+    KeepLargestConnectedComponentd,
+    Activationsd
+)
+# Preprocessing
+from preprocessing import LoadImaged
+# Postprocessing
+from postprocessing import SaveImaged, add_contours_exist
+import matplotlib.pyplot as plt
+import numpy as np
+from utils import *
+
+
+def predict(tempPath, patient_id, ctSeriesInstanceUID, runInterpreter):
+    
+    # Important: Check the input parameters #################
+    if not patient_id or patient_id == "":
+        sys.exit("No Patient dataset loaded: Load the patient dataset in Study Management.")
+        
+    if not ctSeriesInstanceUID or ctSeriesInstanceUID == "":
+        sys.exit("No CT series instance UID to load the CT images. Check for CT data in your study")
+    
+    print("+++ tempath: ", tempPath)
+    print("+++ patient_id: ", patient_id)
+    print("+++ CT SeriesInstanceUID: ", ctSeriesInstanceUID)
+    print("+++ runInterpreter", runInterpreter)
+    
+    # Important: Configure path ###########################   
+    dir_base = os.path.join(tempPath, patient_id)
+    createdir(dir_base)
+    dir_ct_dicom = os.path.join(dir_base, 'ct_dicom')
+    createdir(dir_ct_dicom)
+    dir_ct_nii = os.path.join(dir_base, "ct_nii")
+    createdir(dir_ct_nii)
+    dir_prediction_nii = os.path.join(dir_base, 'prediction_nii')
+    createdir(dir_prediction_nii)
+    dir_prediction_dicom = os.path.join(dir_base, 'prediction_dicom')
+    createdir(dir_prediction_dicom)
+    
+    # predicted files
+    predictedNiiFile = os.path.join(dir_prediction_nii, 'RTStruct.nii.gz')
+    predictedDicomFile = os.path.join(dir_prediction_dicom, 'predicted_rtstruct.dcm')
+
+    model_path = r'best_metric_model.pth'
+    if not os.path.exists(model_path):
+        sys.exit("Not found the trained model")
+        
+    # Important: Configure path ###########################   
+    print('** Use python interpreter: ', runInterpreter)
+    print('** Patient name: ', patient_id)
+    print('** CT Serial instance UID: ', ctSeriesInstanceUID)
+    
+    downloadSeriesInstanceByModality(ctSeriesInstanceUID, dir_ct_dicom, "CT")
+    print("Loading CT from Orthanc done")
+
+    # Conversion DICOM to nii
+    # if not os.path.exists(os.path.join(".", dir_ct_nii, patient_id)):
+    #     os.makedirs(os.path.join(dir_ct_nii, patient_id))
+        
+    refCT = convert_ct_dicom_to_nii(dir_dicom = dir_ct_dicom, dir_nii = dir_ct_nii, outputname='ct.nii.gz', newvoxelsize = None)
+
+    print("Conversion DICOM to nii done")
+
+    # Dictionary with patient to predict
+    test_Data = [{'image':os.path.join(dir_ct_nii,'ct.nii.gz')}]
+
+    # Transformations
+    test_pretransforms = Compose(
+        [
+            LoadImaged(keys=["image"], reader = NibabelReader(), patientname=patient_id),
+            EnsureChannelFirstd(keys=["image"]),
+            ThresholdIntensityd(keys=["image"], threshold=1560, above=False, cval=1560),
+            ThresholdIntensityd(keys=["image"], threshold=-50, above=True, cval=-1000),
+            # MaskIntensityd(keys=['image'], mask_key="body"),
+            ScaleIntensityRanged(
+                keys=["image"], a_min=-1000, a_max=1560,
+                b_min=0.0, b_max=1.0, clip=True,
+            ),
+            CropForegroundd(keys=["image"], source_key="image")
+        ]
+    )
+    test_posttransforms = Compose(
+        [
+            Activationsd(keys="pred", softmax=True),
+            Invertd(
+                keys="pred",  # invert the `pred` data field, also support multiple fields
+                transform=test_pretransforms,
+                orig_keys="image",  # get the previously applied pre_transforms information on the `img` data field,
+                                # then invert `pred` based on this information. we can use same info
+                                # for multiple fields, also support different orig_keys for different fields
+                nearest_interp=False,  # don't change the interpolation mode to "nearest" when inverting transforms
+                                    # to ensure a smooth output, then execute `AsDiscreted` transform
+                to_tensor=True,  # convert to PyTorch Tensor after inverting
+            ),
+            AsDiscreted(keys="pred",  argmax=True, to_onehot=2, threshold=0.5),
+            KeepLargestConnectedComponentd(keys="pred",is_onehot=True),
+            SaveImaged(keys="pred", output_postfix='', separate_folder=False, output_dir=dir_prediction_nii, resample=False)
+        ]
+    )
+
+    # Define DataLoader using MONAI, CacheDataset needs to be used
+    test_ds = CacheDataset(data=test_Data, transform=test_pretransforms)
+    test_loader = DataLoader(test_ds, batch_size=1, shuffle=True, num_workers=1)
+
+    # check_ds = Dataset(data=test_Data, transform=test_pretransforms)
+    # check_loader = DataLoader(check_ds, batch_size=1)
+
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    model_param = dict(
+        spatial_dims=3,
+        in_channels=1,
+        out_channels=2,
+        channels=(16, 32, 64, 128, 256),
+        strides=(2, 2, 2, 2),
+        num_res_units=2,
+        norm=Norm.BATCH
+    )                
+    model = UNet(**model_param)
+    # trained_model_dict = torch.load(model_path, map_location=torch.device('cpu'))
+    trained_model_dict = torch.load(model_path, map_location=torch.device('cuda:0' if torch.cuda.is_available() else "cpu"))
+    model.load_state_dict(trained_model_dict)#['state_dict'])
+
+    # model.load_state_dict(torch.load(model_path))
+    model = model.to(device)
+    # print("MODEL",model)
+
+    model.eval()
+    d = first(test_loader)
+    images = d["image"].to(device)
+    d['pred'] = sliding_window_inference(inputs=images, roi_size=(96,96,64),sw_batch_size=1, predictor = model)
+    d['pred'] = [test_posttransforms(i) for i in decollate_batch(d)] 
+        
+    # model.cpu()
+
+    add_contours_exist(preddir = dir_prediction_nii, refCT = refCT)
+    # Conversion nii to DICOM
+    convert_nii_to_dicom(dicomctdir = dir_ct_dicom, predictedNiiFile = predictedNiiFile, predictedDicomFile = predictedDicomFile, predicted_structures=['BODY'], rtstruct_colors=[[255,0,0]], refCT = refCT)
+
+    print("Conversion nii to DICOM done")
+
+    # Transfer predicted DICOM to Orthanc
+    uploadDicomToOrthanc(predictedDicomFile)
+
+    print("Upload predicted result to Orthanc done")
+    
+    print("Body Segmentation prediction done")
+
+'''
+Prediction parameters provided by the server. Select the parameters to be used for prediction:
+    [1] tempPath: The path where the predict.py is stored,
+    [2] patientname: python version,
+    [3] ctSeriesInstanceUID: Series instance UID for data set with modality = CT. To predict 'MR' modality data, retrieve the CT UID by the code (see Precision Code)
+    [4] rtStructSeriesInstanceUID: Series instance UID for modality = RTSTURCT
+    [5] regSeriesInstanceUID: Series instance UID for modality = REG,
+    [6] runInterpreter: The python version for the python environment
+    [7] oarList: only for dose predciton. For contour predicion oarList = []
+    [8] tvList:  only for dose prediction. For contour prediction tvList = []
+''' 
+
+if __name__ == '__main__':
+    predict(tempPath=sys.argv[1], patient_id=sys.argv[2], ctSeriesInstanceUID=sys.argv[3], runInterpreter=sys.argv[6])
+
+

preprocessing.py

@@ -0,0 +1,309 @@
+from monai.transforms import MapTransform, Transform
+import numpy as np 
+from monai.config import KeysCollection
+from typing import Dict, Hashable, Mapping, Optional, Type, Union, Sequence
+import sys
+from pathlib import Path
+from monai.config import DtypeLike, KeysCollection
+from monai.data.image_reader import ImageReader
+from monai.transforms.transform import MapTransform
+from monai.utils import ensure_tuple, ensure_tuple_rep
+from monai.utils.enums import PostFix
+from monai.data.meta_tensor import MetaTensor
+from monai.transforms.utility.array import EnsureChannelFirst
+from monai.utils import ImageMetaKey as Key
+from monai.utils import ensure_tuple, ensure_tuple_rep, convert_to_dst_type
+from monai.data import NibabelReader
+from monai.config import DtypeLike, KeysCollection, PathLike, NdarrayOrTensor
+
+DEFAULT_POST_FIX = PostFix.meta()
+
+class LoadImaged(MapTransform):
+    """
+    Dictionary-based wrapper of :py:class:`monai.transforms.LoadImage`,
+    It can load both image data and metadata. When loading a list of files in one key,
+    the arrays will be stacked and a new dimension will be added as the first dimension
+    In this case, the metadata of the first image will be used to represent the stacked result.
+    The affine transform of all the stacked images should be same.
+    The output metadata field will be created as ``meta_keys`` or ``key_{meta_key_postfix}``.
+
+    If reader is not specified, this class automatically chooses readers
+    based on the supported suffixes and in the following order:
+
+        - User-specified reader at runtime when calling this loader.
+        - User-specified reader in the constructor of `LoadImage`.
+        - Readers from the last to the first in the registered list.
+        - Current default readers: (nii, nii.gz -> NibabelReader), (png, jpg, bmp -> PILReader),
+          (npz, npy -> NumpyReader), (dcm, DICOM series and others -> ITKReader).
+
+    Please note that for png, jpg, bmp, and other 2D formats, readers often swap axis 0 and 1 after
+    loading the array because the `HW` definition for non-medical specific file formats is different
+    from other common medical packages.
+
+    Note:
+
+        - If `reader` is specified, the loader will attempt to use the specified readers and the default supported
+          readers. This might introduce overheads when handling the exceptions of trying the incompatible loaders.
+          In this case, it is therefore recommended setting the most appropriate reader as
+          the last item of the `reader` parameter.
+
+    See also:
+
+        - tutorial: https://github.com/Project-MONAI/tutorials/blob/master/modules/load_medical_images.ipynb
+
+    """
+
+    def __init__(
+        self,
+        keys: KeysCollection,
+        reader: Optional[Union[ImageReader, str]] = None,
+        patientname: str='',
+        dtype: DtypeLike = np.float32,
+        meta_keys: Optional[KeysCollection] = None,
+        meta_key_postfix: str = DEFAULT_POST_FIX,
+        overwriting: bool = False,
+        image_only: bool = False,
+        ensure_channel_first: bool = False,
+        simple_keys: bool = False,
+        prune_meta_pattern: Optional[str] = None,
+        prune_meta_sep: str = ".",
+        allow_missing_keys: bool = False,
+        *args,
+        **kwargs,
+    ) -> None:
+        """
+        Args:
+            keys: keys of the corresponding items to be transformed.
+                See also: :py:class:`monai.transforms.compose.MapTransform`
+            reader: reader to load image file and metadata
+                - if `reader` is None, a default set of `SUPPORTED_READERS` will be used.
+                - if `reader` is a string, it's treated as a class name or dotted path
+                (such as ``"monai.data.ITKReader"``), the supported built-in reader classes are
+                ``"ITKReader"``, ``"NibabelReader"``, ``"NumpyReader"``.
+                a reader instance will be constructed with the `*args` and `**kwargs` parameters.
+                - if `reader` is a reader class/instance, it will be registered to this loader accordingly.
+            patientname: the patient name.
+            dtype: if not None, convert the loaded image data to this data type.
+            meta_keys: explicitly indicate the key to store the corresponding metadata dictionary.
+                the metadata is a dictionary object which contains: filename, original_shape, etc.
+                it can be a sequence of string, map to the `keys`.
+                if None, will try to construct meta_keys by `key_{meta_key_postfix}`.
+            meta_key_postfix: if meta_keys is None, use `key_{postfix}` to store the metadata of the nifti image,
+                default is `meta_dict`. The metadata is a dictionary object.
+                For example, load nifti file for `image`, store the metadata into `image_meta_dict`.
+            overwriting: whether allow overwriting existing metadata of same key.
+                default is False, which will raise exception if encountering existing key.
+            image_only: if True return dictionary containing just only the image volumes, otherwise return
+                dictionary containing image data array and header dict per input key.
+            ensure_channel_first: if `True` and loaded both image array and metadata, automatically convert
+                the image array shape to `channel first`. default to `False`.
+            simple_keys: whether to remove redundant metadata keys, default to False for backward compatibility.
+            prune_meta_pattern: combined with `prune_meta_sep`, a regular expression used to match and prune keys
+                in the metadata (nested dictionary), default to None, no key deletion.
+            prune_meta_sep: combined with `prune_meta_pattern`, used to match and prune keys
+                in the metadata (nested dictionary). default is ".", see also :py:class:`monai.transforms.DeleteItemsd`.
+                e.g. ``prune_meta_pattern=".*_code$", prune_meta_sep=" "`` removes meta keys that ends with ``"_code"``.
+            allow_missing_keys: don't raise exception if key is missing.
+            args: additional parameters for reader if providing a reader name.
+            kwargs: additional parameters for reader if providing a reader name.
+        """
+        super().__init__(keys, allow_missing_keys)
+                
+        self._loader = LoadImage(
+            reader,
+            patientname,
+            image_only,
+            dtype,
+            ensure_channel_first,
+            simple_keys,
+            prune_meta_pattern,
+            prune_meta_sep,
+            *args,
+            **kwargs,
+        )
+                
+        if not isinstance(meta_key_postfix, str):
+            raise TypeError(f"meta_key_postfix must be a str but is {type(meta_key_postfix).__name__}.")
+        self.meta_keys = ensure_tuple_rep(None, len(self.keys)) if meta_keys is None else ensure_tuple(meta_keys)
+        if len(self.keys) != len(self.meta_keys):
+            raise ValueError("meta_keys should have the same length as keys.")
+        self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys))
+        self.overwriting = overwriting
+        
+        # Check patient name
+        if (len(patientname)==0):
+            raise ValueError("Patient name should not be empty.")
+
+    def register(self, reader: ImageReader):
+        self._loader.register(reader)
+
+
+    def __call__(self, data, reader: Optional[ImageReader] = None):
+        """
+        Raises:
+            KeyError: When not ``self.overwriting`` and key already exists in ``data``.
+
+        """
+        d = dict(data)
+        for key, meta_key, meta_key_postfix in self.key_iterator(d, self.meta_keys, self.meta_key_postfix):
+            data = self._loader(d[key], reader)
+            if self._loader.image_only:
+                d[key] = data
+            else:
+                if not isinstance(data, (tuple, list)):
+                    raise ValueError("loader must return a tuple or list (because image_only=False was used).")
+                d[key] = data[0]
+                if not isinstance(data[1], dict):
+                    raise ValueError("metadata must be a dict.")
+                meta_key = meta_key or f"{key}_{meta_key_postfix}"
+                if meta_key in d and not self.overwriting:
+                    raise KeyError(f"Metadata with key {meta_key} already exists and overwriting=False.")
+                d[meta_key] = data[1]
+                
+        return d
+
+def switch_endianness(data, new="<"):
+    """
+    Convert the input `data` endianness to `new`.
+
+    Args:
+        data: input to be converted.
+        new: the target endianness, currently support "<" or ">".
+    """
+    if isinstance(data, np.ndarray):
+        # default to system endian
+        sys_native = "<" if (sys.byteorder == "little") else ">"
+        current_ = sys_native if data.dtype.byteorder not in ("<", ">") else data.dtype.byteorder
+        if new not in ("<", ">"):
+            raise NotImplementedError(f"Not implemented option new={new}.")
+        if current_ != new:
+            data = data.byteswap().newbyteorder(new)
+    elif isinstance(data, tuple):
+        data = tuple(switch_endianness(x, new) for x in data)
+    elif isinstance(data, list):
+        data = [switch_endianness(x, new) for x in data]
+    elif isinstance(data, dict):
+        data = {k: switch_endianness(v, new) for k, v in data.items()}
+    elif not isinstance(data, (bool, str, float, int, type(None))):
+        raise RuntimeError(f"Unknown type: {type(data).__name__}")
+    return data
+
+class LoadImage(Transform):
+    """
+    Load image file or files from provided path based on reader.
+    If reader is not specified, this class automatically chooses readers
+    based on the supported suffixes and in the following order:
+
+        - User-specified reader at runtime when calling this loader.
+        - User-specified reader in the constructor of `LoadImage`.
+        - Readers from the last to the first in the registered list.
+        - Current default readers: (nii, nii.gz -> NibabelReader), (png, jpg, bmp -> PILReader),
+          (npz, npy -> NumpyReader), (nrrd -> NrrdReader), (DICOM file -> ITKReader).
+
+    Please note that for png, jpg, bmp, and other 2D formats, readers often swap axis 0 and 1 after
+    loading the array because the `HW` definition for non-medical specific file formats is different
+    from other common medical packages.
+
+    See also:
+
+        - tutorial: https://github.com/Project-MONAI/tutorials/blob/master/modules/load_medical_images.ipynb
+
+    """
+
+    def __init__(
+        self,
+        reader="NibabelReader",
+        patientname:str="",
+        image_only: bool = False,
+        dtype: DtypeLike = np.float32,
+        ensure_channel_first: bool = False,
+        simple_keys: bool = False,
+        prune_meta_pattern: Optional[str] = None,
+        prune_meta_sep: str = ".",
+        *args,
+        **kwargs,
+    ) -> None:
+        """
+        Args:
+            reader: reader to load image file and metadata
+                - if `reader` is None, a default set of `SUPPORTED_READERS` will be used.
+                - if `reader` is a string, it's treated as a class name or dotted path
+                (such as ``"monai.data.ITKReader"``), the supported built-in reader classes are
+                ``"ITKReader"``, ``"NibabelReader"``, ``"NumpyReader"``, ``"PydicomReader"``.
+                a reader instance will be constructed with the `*args` and `**kwargs` parameters.
+                - if `reader` is a reader class/instance, it will be registered to this loader accordingly.
+            image_only: if True return only the image MetaTensor, otherwise return image and header dict.
+            dtype: if not None convert the loaded image to this data type.
+            ensure_channel_first: if `True` and loaded both image array and metadata, automatically convert
+                the image array shape to `channel first`. default to `False`.
+            simple_keys: whether to remove redundant metadata keys, default to False for backward compatibility.
+            prune_meta_pattern: combined with `prune_meta_sep`, a regular expression used to match and prune keys
+                in the metadata (nested dictionary), default to None, no key deletion.
+            prune_meta_sep: combined with `prune_meta_pattern`, used to match and prune keys
+                in the metadata (nested dictionary). default is ".", see also :py:class:`monai.transforms.DeleteItemsd`.
+                e.g. ``prune_meta_pattern=".*_code$", prune_meta_sep=" "`` removes meta keys that ends with ``"_code"``.
+            args: additional parameters for reader if providing a reader name.
+            kwargs: additional parameters for reader if providing a reader name.
+
+        Note:
+
+            - The transform returns a MetaTensor, unless `set_track_meta(False)` has been used, in which case, a
+              `torch.Tensor` will be returned.
+            - If `reader` is specified, the loader will attempt to use the specified readers and the default supported
+              readers. This might introduce overheads when handling the exceptions of trying the incompatible loaders.
+              In this case, it is therefore recommended setting the most appropriate reader as
+              the last item of the `reader` parameter.
+
+        """
+
+        self.auto_select = reader is None
+        self.image_only = image_only
+        self.dtype = dtype
+        self.ensure_channel_first = ensure_channel_first
+        self.simple_keys = simple_keys
+        self.pattern = prune_meta_pattern
+        self.sep = prune_meta_sep
+        self.patientname = patientname
+        return
+    
+    def __call__(self, filename: Union[Sequence[PathLike], PathLike], reader: Optional[ImageReader] = NibabelReader):
+        """
+        Load image file and metadata from the given filename(s).
+        If `reader` is not specified, this class automatically chooses readers based on the
+        reversed order of registered readers `self.readers`.
+
+        Args:
+            filename: path file or file-like object or a list of files.
+                will save the filename to meta_data with key `filename_or_obj`.
+                if provided a list of files, use the filename of first file to save,
+                and will stack them together as multi-channels data.
+                if provided directory path instead of file path, will treat it as
+                DICOM images series and read.
+            reader: runtime reader to load image file and metadata.
+
+        """  
+        filename = tuple(f"{Path(s).expanduser()}" for s in ensure_tuple(filename))  # allow Path objects
+        img, err = None, []
+        # if reader is not None:
+        reader=NibabelReader()
+        img = reader.read(filename)  # runtime specified reader
+        header = img.header
+        img_array = img.get_fdata()
+        img_array: NdarrayOrTensor
+        img_array, meta_data = reader.get_data(img)
+        img_array = convert_to_dst_type(img_array, dst=img_array, dtype=self.dtype)[0]
+        if not isinstance(meta_data, dict):
+            raise ValueError("`meta_data` must be a dict.")
+        # make sure all elements in metadata are little endian
+        meta_data = switch_endianness(meta_data, "<")        
+        # meta_data["patient_name"]=filename[0].split('/')[-3]
+        meta_data["patient_name"]=self.patientname
+        meta_data[Key.FILENAME_OR_OBJ] = f"{ensure_tuple(filename)[0]}"  # Path obj should be strings for data loader        
+        img = MetaTensor.ensure_torch_and_prune_meta(
+            img_array, meta_data, self.simple_keys, pattern=self.pattern, sep=self.sep
+        )
+        if self.ensure_channel_first:
+            img = EnsureChannelFirst()(img)
+        if self.image_only:
+            return img
+        return img, img.meta, header if isinstance(img, MetaTensor) else meta_data

requirements.txt

@@ -0,0 +1 @@
+monai==1.3.0