First upload

dicom_to_nii.py

@@ -0,0 +1,533 @@
+import pydicom
+import sys
+import os
+import numpy as np
+import nibabel as nib
+import scipy
+
+
+def convert_transform_mr_to_nii(dir_mr_dicom, tranform_mr, dir_nii, outputname, CT):
+    Patients = PatientList()
+    Patients.list_dicom_files(dir_mr_dicom, 1)
+    patient = Patients.list[0]
+    patient_name = patient.PatientInfo.PatientName
+    patient.import_patient_data(CT.PixelSpacing)
+    MR = patient.MRimages[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=tranform_mr.imageArray, outputname=outputname)
+    return MR
+
+def convert_mr_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)
+    MR = patient.MRimages[0]
+    image_position_patient = MR.ImagePositionPatient
+    voxelsize = np.array(MR.PixelSpacing)
+    save_images(dst_dir=os.path.join(dir_nii), voxelsize=voxelsize,
+                image_position_patient=image_position_patient, image=MR.Image, outputname=outputname)
+    return MR
+
+    
+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)
+                elif dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.4":
+                        mr_id = next((x for x, val in enumerate(self.list[patient_id].MRimages) if val.SeriesInstanceUID == dcm.SeriesInstanceUID), -1)
+                        if mr_id == -1:
+                            MR = MRimage()
+                            MR.SeriesInstanceUID = dcm.SeriesInstanceUID
+                            MR.SOPClassUID == "1.2.840.10008.5.1.4.1.1.4"
+                            MR.PatientInfo = self.list[patient_id].PatientInfo
+                            MR.StudyInfo = StudyInfo()
+                            MR.StudyInfo.StudyInstanceUID = dcm.StudyInstanceUID
+                            MR.StudyInfo.StudyID = dcm.StudyID
+                            MR.StudyInfo.StudyDate = dcm.StudyDate
+                            MR.StudyInfo.StudyTime = dcm.StudyTime
+                            if(hasattr(dcm, 'SeriesDescription') and dcm.SeriesDescription != ""): MR.ImgName = dcm.SeriesDescription
+                            else: MR.ImgName = dcm.SeriesInstanceUID
+                            self.list[patient_id].MRimages.append(MR)
+                            mr_id = len(self.list[patient_id].MRimages) - 1
+
+                        self.list[patient_id].MRimages[mr_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 = []
+        self.MRimages = []
+
+    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 + "   ")
+            
+        for mr in self.MRimages:
+            print("")
+            mr.print_MR_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)
+            
+        # import MR images
+        for i, mr in enumerate(self.MRimages):
+            if (mr.isLoaded == 1):
+                continue
+            mr.import_Dicom_MR(newvoxelsize)
+        # Resample MR images
+        # for i,mr in enumerate(self.MRimages):
+        #     mr.resample_MR(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
+
+class MRimage:
+    
+  def __init__(self):
+    self.SeriesInstanceUID = ""
+    self.PatientInfo = {}
+    self.StudyInfo = {}
+    self.FrameOfReferenceUID = ""
+    self.ImgName = ""
+    self.SOPClassUID = ""
+            
+    self.DcmFiles = []
+    self.isLoaded = 0
+    
+    
+    
+  def print_MR_info(self, prefix=""):
+    print(prefix + "MR series: " + self.SeriesInstanceUID)
+    for mr_slice in self.DcmFiles:
+      print(prefix + "   " + mr_slice)
+      
+  def import_Dicom_MR(self, newvoxelsize):
+    
+    if(self.isLoaded == 1):
+      print("Warning: CT series " + 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]
+    mr = np.dstack(images).astype("float32")
+
+    if mr.shape[0:2] != (dcm.Rows, dcm.Columns):
+      print("WARNING: GridSize " + str(mr.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) + ")")
+    
+    # Rescaling to the newvoxelsize if given in parameter
+    if newvoxelsize is not None:
+      source_shape = list(mr.shape)
+      
+      voxelsize = [float(dcm.PixelSpacing[0]), float(dcm.PixelSpacing[1]), MeanSliceDistance]
+      VoxelX_source = dcm.ImagePositionPatient[0] + np.arange(source_shape[0])*voxelsize[0]
+      VoxelY_source = dcm.ImagePositionPatient[1] + np.arange(source_shape[1])*voxelsize[1]
+      VoxelZ_source = dcm.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 = dcm.ImagePositionPatient[0] + np.arange(target_shape[0])*newvoxelsize[0]
+      VoxelY_target = dcm.ImagePositionPatient[1] + np.arange(target_shape[1])*newvoxelsize[1]
+      VoxelZ_target = dcm.ImagePositionPatient[2] + np.arange(target_shape[2])*newvoxelsize[2]
+      
+      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")
+            mr = scipy.ndimage.gaussian_filter(mr, sigma)
+        else:
+            print("Image does not need filtering")
+                
+            
+        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
+        mr = scipy.interpolate.interpn((VoxelX_source,VoxelY_source,VoxelZ_source), mr, xi, method='linear', fill_value=0, bounds_error=False).reshape(target_shape).transpose(1,0,2)
+        
+
+    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] if newvoxelsize is None else newvoxelsize
+    self.GridSize = list(mr.shape)
+    self.NumVoxels = self.GridSize[0] * self.GridSize[1] * self.GridSize[2]
+    self.Image = mr
+    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

nii_to_dicom.py

@@ -0,0 +1,570 @@
+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
+from dicom_to_nii import set_header_info
+
+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)
+
+def integer_to_onehot(niiFile):
+    
+    # get contours in nnunet format
+    nnunet_integer_nib = nib.load(niiFile)
+    nnunet_integer_data = nnunet_integer_nib.get_fdata()
+   
+    # convert to onehot encoding (2**i)
+    onehot_data = np.zeros(nnunet_integer_data.shape)
+    for i in np.unique(nnunet_integer_data):
+        onehot_data[nnunet_integer_data == i] = 2**i
+        
+    # get contours_exist
+    contours_exist = np.ones(len(np.unique(onehot_data))).astype(bool).tolist()
+    #contours_exist = np.ones(len(np.unique(onehot_data))-1).astype(bool) # -1 to remove the background which we don't want
+    # save it back to nii format (will overwrite the predicted file - integer format - with this one - onehot format -)
+    image_nii = nib.Nifti1Image(onehot_data, affine=np.eye(4)) # for Nifti1 header, change for a Nifti2 type of header
+    # Update header fields
+    image_nii = set_header_info(image_nii, nnunet_integer_nib.header['pixdim'][1:4], [nnunet_integer_nib.header['qoffset_x'],nnunet_integer_nib.header['qoffset_y'],nnunet_integer_nib.header['qoffset_z']], contours_exist = contours_exist)
+    # Save  nii 
+    nib.save(image_nii,niiFile) #overwrites old file     
+
+    return
+
+def save_nii_image(nib_img, nib_header,dst_dir, dst_filename, contours_exist = None):
+    
+    image_nii = nib.Nifti1Image(nib_img, affine=np.eye(4)) # for Nifti1 header, change for a Nifti2 type of header
+    # Update header fields
+    if contours_exist is not None:
+        image_nii = set_header_info(image_nii, nib_header['pixdim'][1:4], [nib_header['qoffset_x'],nib_header['qoffset_y'],nib_header['qoffset_z']], contours_exist = contours_exist)
+    else:
+        image_nii = set_header_info(image_nii, nib_header['pixdim'][1:4], [nib_header['qoffset_x'],nib_header['qoffset_y'],nib_header['qoffset_z']])
+    # Save  nii 
+    nib.save(image_nii, os.path.join(dst_dir,dst_filename))
+
+def Taubin_smoothing(contour):
+    """ Here, we do smoothing in 2D contours!
+        Parameters:
+            a Nx2 numpy array containing the contour to smooth
+        Returns:
+            a Nx2 numpy array containing the smoothed contour """
+    smoothingloops = 5
+    smoothed = [np.empty_like(contour) for i in range(smoothingloops+1)]
+    smoothed[0] = contour
+    for i in range(smoothingloops):
+        # loop over all elements in the contour
+        for vertex_i in range(smoothed[0].shape[0]):
+            if vertex_i == 0:
+                vertex_prev = smoothed[i].shape[0]-1
+                vertex_next = vertex_i+1
+            elif vertex_i == smoothed[i].shape[0]-1:
+                vertex_prev = vertex_i-1
+                vertex_next = 0
+            else:
+                vertex_prev = vertex_i -1
+                vertex_next = vertex_i +1
+            neighbours_x = np.array([smoothed[i][vertex_prev,0], smoothed[i][vertex_next,0]])
+            neighbours_y = np.array([smoothed[i][vertex_prev,1], smoothed[i][vertex_next,1]])
+            smoothed[i+1][vertex_i,0] = smoothed[i][vertex_i,0] - 0.3*(smoothed[i][vertex_i,0] - np.mean(neighbours_x))
+            smoothed[i+1][vertex_i,1] = smoothed[i][vertex_i,1] - 0.3*(smoothed[i][vertex_i,1] - np.mean(neighbours_y))
+
+    return np.round(smoothed[smoothingloops],3)
+
+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:
+        # TODO ENABLE IN CASE WE DONT HAVE contoursexist TAKE JUST THE LENGTH OF LABELS
+        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 not len(rtstruct_labels) == len(contoursexist) :
+        #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 and contoursexist in struct.nii.gz is not the same. Taking len(contoursexist) as number of rois")
+        self.NumContours = len(rtstruct_labels)#len(contoursexist)
+    else:
+        self.NumContours = len(rtstruct_labels)#len(contoursexist)
+    print("num contours", self.NumContours, len(rtstruct_labels) , len(contoursexist))    
+    # 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):   
+    print("EXPORT DICOM")             
+    # 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
+            # Smooth contour
+            smoothed_array_2D = Taubin_smoothing(np.transpose(np.array([polygon[0::3],polygon[1::3]])))
+            # fill in smoothed contour
+            polygon[0::3] = smoothed_array_2D[:,0]
+            polygon[1::3] = smoothed_array_2D[:,1]
+            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

predict_new.py

@@ -0,0 +1,209 @@
+import os
+import os.path
+from os import environ
+import sys
+import json
+import subprocess
+import time
+import nibabel as nib
+
+# +++++++++++++ Conversion imports +++++++++++++++++++++++++
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(os.path.abspath(".."))
+# +++++++++++++ Conversion imports +++++++++++++++++++++++++
+
+from utils import *
+from dicom_to_nii import convert_ct_dicom_to_nii, convert_transform_mr_to_nii, PatientList, save_images
+from nii_to_dicom import convert_nii_to_dicom, integer_to_onehot
+from predict_nnunet import predictNNUNet
+
+def predict(tempPath, patient_id, regSeriesInstanceUID, 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 regSeriesInstanceUID or regSeriesInstanceUID == "":
+        sys.exit("No series instance UID for Modality 'REG' file. Check for REG file in your study")
+        
+    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_mr_dicom = os.path.join(dir_base, 'mr_dicom')
+    createdir(dir_mr_dicom)
+    
+    dir_reg_dicom = os.path.join(dir_base, 'reg_dicom')
+    createdir(dir_reg_dicom)
+        
+    nnUNet_raw = os.path.join(os.getcwd(), 'nnUNet_raw')    
+    nnUNet_preprocessed = os.path.join(os.getcwd(), 'nnUNet_preprocessed')
+    RESULTS_FOLDER = os.path.join(os.getcwd(), 'nnUNet_trained_models')
+    dataset = "Dataset103_EPTN_T1_CT_all_structures" 
+    # IMPORTANT: data set modality: MR or CT ######################
+    predictType='MR' 
+
+    # IMPORTANT DOT Remove ########################################
+    os.environ['nnUNet_raw'] = nnUNet_raw
+    os.environ['nnUNet_preprocessed'] = nnUNet_preprocessed
+    os.environ['nnUNet_results'] = RESULTS_FOLDER
+    
+    # Important ++++++++++++++++++++++++++++++++++++++++++++++++
+    # Import the lib after setting environ parameters
+    # import nnunet.inference.predict_simple as nnunetpredict
+    
+    print('** The python enviornment path: ', os.environ["PATH"])
+    
+    # For nnunet version 2
+    import nnunetv2.inference.predict_from_raw_data as nnunetpredict
+    # ###########################################################
+
+    # predicted files
+    predictedNiiFile = os.path.join(tempPath, patient_id, 'predict_nii')
+    createdir(predictedNiiFile)
+    
+    predictedDicom = os.path.join(tempPath, patient_id, 'predicted_dicom')
+    createdir(predictedDicom)
+    
+    predictedDicomFile = os.path.join(predictedDicom, 'predicted_rtstruct.dcm')
+        
+    print('** Use python interpreter: ', runInterpreter)
+    print('** Patient name: ', patient_id)
+    print('** REG series instance UID: ', regSeriesInstanceUID)
+    
+    # Convert CT image to NII #############
+    startTime = time.time()
+    
+    if predictType == 'CT':
+        
+        dir_dicom_to_nii = os.path.join(nnUNet_raw, 'nnUNet_raw_data', 'Dataset098_HAN_nodes')
+        createdir(dir_dicom_to_nii)
+    
+        downloadSeriesInstanceByModality(instanceID, dir_ct_dicom, "CT")
+        print("Loading CT from Orthanc done: ", time.time()-startTime)
+        
+        # Convert CT image to NII #############
+        refCT= convert_ct_dicom_to_nii(dir_dicom=dir_ct_dicom, dir_nii=dir_dicom_to_nii, outputname='1a_001_0000.nii.gz', newvoxelsize = None)
+        print("Convert CT image to NII Done: ",  time.time()-startTime)
+        
+        # new version 2:  
+        cmd = [modelPath, '-i', dir_dicom_to_nii, '-o', predictedNiiFile, '-d', dataset, '-tr', 'nnUNetTrainer_650epochs', '-c', '3d_fullres', '-f', '0']
+        
+        out = subprocess.check_output(cmd)
+        # Important ########################
+        sys.argv = cmd
+        
+        # #### nnunet version 2 #############
+        nnunetpredict.predict_entry_point() 
+        print("Prediction CT done",  time.time()-startTime)
+        
+        niiFile = os.path.join(predictedNiiFile, '1a_001.nii.gz')
+        
+        # POSTPROCESSING TO CONVERT FROM INTEGERS TO 2**i, ADD CONTOURS EXISTS, AND SMOOTH        
+        integer_to_onehot(niiFile)
+        print("POST processing convert from integers done: ", time.time()-startTime)
+        
+        startTime = time.time()
+        convert_nii_to_dicom(dicomctdir=dir_ct_dicom, predictedNiiFile=niiFile, predictedDicomFile=predictedDicomFile,
+                             predicted_structures=predicted_structures, rtstruct_colors=rtstruct_colors, refCT=refCT)
+        
+        print("Convert CT predicted NII to DICOM done: ", time.time()-startTime)
+                
+    elif predictType == 'MR':
+        
+        dir_dicom_to_nii = os.path.join(nnUNet_raw, 'nnUNet_raw_data',dataset)
+        createdir(dir_dicom_to_nii)
+        
+        # Download the REG dicom ##############
+        downloadSeriesInstanceByModality(regSeriesInstanceUID, dir_reg_dicom, "REG")
+        print("Loading REG from Orthanc done: ", time.time()-startTime)
+        
+        # Download the MR dicom ###############
+        # Read the mr study instance UID from the download REG dicom   
+        mrSeriesInstanceUID = getSeriesInstanceUIDFromRegDicom(dir_reg_dicom, regSeriesInstanceUID)
+        
+        downloadSeriesInstanceByModality(mrSeriesInstanceUID, dir_mr_dicom, "MR")
+        print("Loading MR from Orthanc done: ", time.time()-startTime)
+        
+        # Execute REG tranformation ###########
+        ctSeriesInstanceUIDFromRegDicom = getCTSeriesInstanceUIDFromRegDicom(dir_reg_dicom, regSeriesInstanceUID)
+        print("CT Series Instance UID referenced by Reg dicom: ", ctSeriesInstanceUIDFromRegDicom)
+        
+        downloadSeriesInstanceByModality(ctSeriesInstanceUIDFromRegDicom, dir_ct_dicom, "CT")
+        
+        Patients = PatientList() 
+        Patients.list_dicom_files(dir_ct_dicom, 1)
+        patient = Patients.list[0]
+        patient_name = patient.PatientInfo.PatientName
+        patient.import_patient_data(newvoxelsize=None)
+        CT = patient.CTimages[0]
+
+        startTime = time.time()
+        mr_reg = regMatrixTransformation(dir_mr_dicom, reg_file_path=dir_reg_dicom, regSeriesInstanceUID=regSeriesInstanceUID, CT=CT)
+        print("Transforming MR data done (OpenTPS.Core)")
+        
+        # Convert transform MR image to NII ##################
+        refMR = convert_transform_mr_to_nii(dir_mr_dicom=dir_mr_dicom, tranform_mr = mr_reg, dir_nii=dir_dicom_to_nii, outputname='1a_001_0000.nii.gz', CT=CT)
+        refCT= convert_ct_dicom_to_nii(dir_dicom=dir_ct_dicom, dir_nii=dir_dicom_to_nii, outputname='1a_001_0001.nii.gz', newvoxelsize = None)
+        print("Convert CT image to NII Done: ",  time.time()-startTime)
+        print("Convert transform MR image to NII Done: ",  time.time()-startTime)
+        
+        
+        print("## start MR running prediction ###############")
+        startTime = time.time()
+        # modelPath = '..\\..\\python_environments\\prediction-3.10.9\\Scripts\\nnUNetv2_predict.exe' 
+        # cmd = [modelPath, '-i', dir_dicom_to_nii, '-o', predictedNiiFile, '-d', '99', '-c', '3d_fullres' , '--disable_tta', '-tr', 'nnUNetTrainer_650epochs', '-f', '1, 4']
+        
+        predictNNUNet(os.path.join(RESULTS_FOLDER,dataset, 'nnUNetTrainer_650epochs__nnUNetPlans__3d_fullres'),
+                      dir_dicom_to_nii,
+                      predictedNiiFile,
+                      [1]) 
+        
+        print("Prediction MR done",  time.time()-startTime)
+        
+        startTime = time.time()
+
+        predicted_structures = ["background", "BRAIN", "AMYGDALAE", "BRAINSTEM", "CAUDATENUCLEI", "CEREBELLUM", "CHIASM", "COCHLEAS", "CORNEAS", "CORPUSCALLOSUM", "FORNICES", "GLANDPINEAL", "HIPPOCAMPI", "HYPOTHALAMI", "LACRIMALGLANDS", "LENSES", "OPTICNERVES", "ORBITOFRONTALS", "PITUITARY", "RETINAS", "THALAMI", "VSCCs"]
+        rtstruct_colors = [[255,0,0]]*len(predicted_structures)
+        
+        niiFile = os.path.join(predictedNiiFile, '1a_001.nii.gz')
+        
+        # POSTPROCESSING TO CONVERT FROM INTEGERS TO 2**i, ADD CONTOURS EXISTS, AND SMOOTH        
+        integer_to_onehot(niiFile)
+        print("POST processing convert from integers done: ", time.time()-startTime)
+        
+        # Convert CT image to NII #############
+        
+        
+        
+        convert_nii_to_dicom(dicomctdir=dir_ct_dicom, predictedNiiFile=niiFile, predictedDicomFile=predictedDicomFile, 
+                            predicted_structures=predicted_structures, rtstruct_colors=rtstruct_colors, refCT=refCT)
+    else:
+        print("Not supported yet")
+        
+    
+    startTime = time.time()
+    uploadDicomToOrthanc(predictedDicomFile)
+    print("Upload predicted result to Orthanc done: ",  time.time()-startTime)
+
+# tempPath = 'C:\Temp\parrot_prediction'
+# regSeriesInstanceUID = '1.2.246.352.205.5029381855449574337.1508502639685232062'
+# runInterpreter = 'py3109'
+# patientName = 'P0461C0006I7638639'
+
+'''
+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], regSeriesInstanceUID=sys.argv[5], runInterpreter=sys.argv[6])
+    # predict(tempPath=tempPath, patient_id=patientName, regSeriesInstanceUID=regSeriesInstanceUID, runInterpreter=runInterpreter)

predict_nnunet.py

@@ -0,0 +1,32 @@
+import torch
+from nnunetv2.inference.predict_from_raw_data import nnUNetPredictor
+
+def predictNNUNet(model_dir, input_dir, output_dir, folds):
+    
+    predictor = nnUNetPredictor(
+        tile_step_size=0.9, #0.5,
+        use_gaussian=True,
+        use_mirroring=False,  # --disable_tta
+        # perform_everything_on_device=True,
+        device=torch.device('cpu', 0),
+        verbose=True,
+        verbose_preprocessing=False,
+        allow_tqdm=True,
+    )
+
+    predictor.initialize_from_trained_model_folder(
+        model_dir,
+        use_folds=folds, # None if autodetect folds
+        checkpoint_name='checkpoint_final.pth',
+    )
+    print("input_dir",input_dir)
+    predictor.predict_from_files(input_dir,
+                                 output_dir,
+                                 save_probabilities=False,
+                                 overwrite=True,
+                                 num_processes_preprocessing=2,
+                                 num_processes_segmentation_export=2,
+                                 folder_with_segs_from_prev_stage=None,
+                                 num_parts=1,
+                                 part_id=0
+                                 )