Upload Process library

libraries/Process/CTimage.py

@@ -0,0 +1,125 @@
+import pydicom
+import numpy as np
+import scipy
+
+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
+
+    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.SOPClassUID = dcm.SOPClassUID
+    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
+    
+    
+   
+
+    

libraries/Process/MRimage.py

@@ -0,0 +1,120 @@
+import pydicom
+import numpy as np
+import scipy
+
+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 resample_MR(self, newvoxelsize):
+    mr = self.Image
+    # Rescaling to the newvoxelsize if given in parameter
+
+    source_shape = self.GridSize
+    voxelsize = self.PixelSpacing
+    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")
+          mr = scipy.ndimage.gaussian_filter(mr, 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 mr
+      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.PixelSpacing = newvoxelsize
+      
+    self.GridSize = list(mr.shape) 
+    self.NumVoxels = self.GridSize[0] * self.GridSize[1] * self.GridSize[2]
+    self.Image = mr
+    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_MR(self):
+    
+    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) + ")")    
+
+    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(mr.shape)
+    self.NumVoxels = self.GridSize[0] * self.GridSize[1] * self.GridSize[2]
+    self.Image = mr
+    self.SeriesDescription = dcm.SeriesDescription
+    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
+    
+   
+  
+    

libraries/Process/PatientData.py

@@ -0,0 +1,307 @@
+import os
+import pydicom
+
+from libraries.Process.CTimage import *
+from libraries.Process.MRimage import *
+from libraries.Process.RTdose import *
+from libraries.Process.RTstruct import *
+from libraries.Process.RTplan import *
+
+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)
+        
+        # Dicom MR
+        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)
+
+        # Dicom dose
+        elif dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.481.2":
+          dose_id = next((x for x, val in enumerate(self.list[patient_id].RTdoses) if val.SOPInstanceUID == dcm.SOPInstanceUID), -1)
+          if dose_id == -1:
+            dose = RTdose()
+            dose.SOPInstanceUID = dcm.SOPInstanceUID
+            dose.SeriesInstanceUID = dcm.SeriesInstanceUID
+            dose.PatientInfo = self.list[patient_id].PatientInfo
+            dose.StudyInfo = StudyInfo()
+            dose.StudyInfo.StudyInstanceUID = dcm.StudyInstanceUID
+            dose.StudyInfo.StudyID = dcm.StudyID
+            dose.StudyInfo.StudyDate = dcm.StudyDate
+            dose.StudyInfo.StudyTime = dcm.StudyTime
+            if dcm.DoseSummationType == "BEAM":
+              dose.beam_number = str(dcm.ReferencedRTPlanSequence[0].ReferencedFractionGroupSequence[0].ReferencedBeamSequence[0].ReferencedBeamNumber)
+            elif dcm.DoseSummationType == "PRIOR_TARGET":
+              dose.beam_number = "PRIOR_TARGET"
+            elif "PRIOR_TARGET_OAR" in dcm.DoseSummationType :
+              dose.beam_number = "PRIOR_TARGET_OAR"
+            else:
+              dose.beam_number = "PLAN"
+            if(hasattr(dcm, 'SeriesDescription') and dcm.SeriesDescription != ""): dose.ImgName = dcm.SeriesDescription
+            else: dose.ImgName = dcm.SeriesInstanceUID
+            dose.DcmFile = file_path
+            self.list[patient_id].RTdoses.append(dose)
+
+        # Dicom struct
+        elif dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.481.3":
+          #struct_id = next((x for x, val in enumerate(self.list[patient_id].RTstructs_CT) if val.SeriesInstanceUID == dcm.SeriesInstanceUID), -1)
+          #if struct_id == -1:
+          struct = RTstruct()
+          struct.SeriesInstanceUID = dcm.SeriesInstanceUID
+          struct.PatientInfo = self.list[patient_id].PatientInfo
+          struct.StudyInfo = StudyInfo()
+          struct.StudyInfo.StudyInstanceUID = dcm.StudyInstanceUID
+          struct.StudyInfo.StudyID = dcm.StudyID
+          struct.StudyInfo.StudyDate = dcm.StudyDate
+          struct.StudyInfo.StudyTime = dcm.StudyTime
+          struct.DcmFile = file_path
+          
+          # Avoid ContourSequence of the first contour is not present! 
+          stop = 0
+          for s in range(len(dcm.ROIContourSequence)):
+              if hasattr(dcm.ROIContourSequence[s], 'ContourSequence') and stop == 0:
+                  stop = 1
+                  if dcm.ROIContourSequence[s].ContourSequence[0].ContourImageSequence[0].ReferencedSOPClassUID=="1.2.840.10008.5.1.4.1.1.2":
+                    self.list[patient_id].RTstructs_CT.append(struct)
+                  elif dcm.ROIContourSequence[s].ContourSequence[0].ContourImageSequence[0].ReferencedSOPClassUID=="1.2.840.10008.5.1.4.1.1.4":
+                    self.list[patient_id].RTstructs_MR.append(struct)
+              else:
+                  continue
+
+
+        # Dicom plans
+        elif dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.481.5" or dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.481.8":
+          plan_id = next((x for x, val in enumerate(self.list[patient_id].RTplans) if val.SeriesInstanceUID == dcm.SeriesInstanceUID), -1)
+          if plan_id == -1:
+            plan = RTplan()
+            plan.SeriesInstanceUID = dcm.SeriesInstanceUID
+            plan.PatientInfo = self.list[patient_id].PatientInfo
+            plan.StudyInfo = StudyInfo()
+            plan.StudyInfo.StudyInstanceUID = dcm.StudyInstanceUID
+            plan.StudyInfo.StudyID = dcm.StudyID
+            plan.StudyInfo.StudyDate = dcm.StudyDate
+            plan.StudyInfo.StudyTime = dcm.StudyTime
+            if(hasattr(dcm, 'SeriesDescription') and dcm.SeriesDescription != ""): plan.PlanName = dcm.SeriesDescription
+            else: plan.PlanName = dcm.SeriesInstanceUID
+            plan.DcmFile = file_path
+            self.list[patient_id].RTplans.append(plan)
+        
+        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 = []
+    self.RTdoses = []
+    self.RTplans = []
+    self.RTstructs_CT = []
+    self.RTstructs_MR = []
+    
+  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 + "   ")
+    print("")
+
+    for mr in self.MRimages:
+      print("")
+      mr.print_MR_info(prefix + "   ")
+
+    print("")
+    for dose in self.RTdoses:
+      print("")
+      dose.print_dose_info(prefix + "   ")
+
+    print("")
+    for struct in self.RTstructs_CT:
+      print("")
+      struct.print_struct_info(prefix + "   ")
+    
+    print("")
+    for struct in self.RTstructs_MR:
+      print("")
+      struct.print_struct_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()
+    # import MR images
+    for i,mr in enumerate(self.MRimages):
+      if(mr.isLoaded == 1): continue
+      mr.import_Dicom_MR()
+    # import RTstructs linked to CT
+    for i, struct in enumerate(self.RTstructs_CT):
+      struct.import_Dicom_struct(self.CTimages[i]) # to be improved: user select CT image
+    # import RTstructs linked to MR
+    for i, struct in enumerate(self.RTstructs_MR):
+      struct.import_Dicom_struct(self.MRimages[i]) # to be improved: user select CT image
+    # import RTPlan
+    for i,plan in enumerate(self.RTplans):
+      if(plan.isLoaded == 1): continue
+      plan.import_Dicom_plan() 
+    #RESAMPLE ONLY IF NEWVOXELSIZE IS NOT NONE
+    if newvoxelsize is not None:
+        # Resample CT images
+        for i,ct in enumerate(self.CTimages):
+          ct.resample_CT(newvoxelsize)
+        # Resample MR images
+        for i,mr in enumerate(self.MRimages):
+          mr.resample_MR(newvoxelsize)
+        # Resample RTstructs linked to CT images
+        for i, struct in enumerate(self.RTstructs_CT):
+          struct.resample_struct(newvoxelsize) # to be improved: user select CT image
+    # import dose distributions
+    for i, dose in enumerate(self.RTdoses):
+      if(dose.isLoaded == 1): continue
+      dose.import_Dicom_dose(self.CTimages[0]) # to be improved: user select CT image
+    
+
+
+
+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 = ''

libraries/Process/RTdose.py

@@ -0,0 +1,259 @@
+import pydicom
+import datetime
+import numpy as np
+import scipy
+import nibabel as nib
+
+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 RTdose:
+
+  def __init__(self):
+    self.SeriesInstanceUID = ""
+    self.SOPInstanceUID = ""
+    self.PatientInfo = PatientInfo()
+    self.StudyInfo = StudyInfo()
+    self.CT_SeriesInstanceUID = ""
+    self.Plan_SOPInstanceUID = ""
+    self.FrameOfReferenceUID = ""
+    self.ImgName = ""
+    self.beam_number = "" # Beam number (str) or PLAN if sum of all
+    self.DcmFile = ""
+    self.isLoaded = 0
+    
+  def print_dose_info(self, prefix=""):
+    print(prefix + "Dose: " + self.SOPInstanceUID)
+    print(prefix + "   " + self.DcmFile)
+    
+    
+    
+  def import_Dicom_dose(self, CT):
+    if(self.isLoaded == 1):
+      print("Warning: Dose image " + self.SOPInstanceUID + " is already loaded")
+      return
+      
+    dcm = pydicom.dcmread(self.DcmFile)
+    
+    self.CT_SeriesInstanceUID = CT.SeriesInstanceUID
+    # self.Plan_SOPInstanceUID = dcm.ReferencedRTPlanSequence[0].ReferencedSOPInstanceUID
+    
+    
+    if(dcm.BitsStored == 16 and dcm.PixelRepresentation == 0):
+      dt = np.dtype('uint16')
+    elif(dcm.BitsStored == 16 and dcm.PixelRepresentation == 1):
+      dt = np.dtype('int16')
+    elif(dcm.BitsStored == 32 and dcm.PixelRepresentation == 0):
+      dt = np.dtype('uint32')
+    elif(dcm.BitsStored == 32 and dcm.PixelRepresentation == 1):
+      dt = np.dtype('int32')
+    else:
+      print("Error: Unknown data type for " + self.DcmFile)
+      return
+      
+    if(dcm.HighBit == dcm.BitsStored-1):
+      dt = dt.newbyteorder('L')
+    else:
+      dt = dt.newbyteorder('B')
+      
+    dose_image = np.frombuffer(dcm.PixelData, dtype=dt) 
+    dose_image = dose_image.reshape((dcm.Columns, dcm.Rows, dcm.NumberOfFrames), order='F').transpose(1,0,2)
+    dose_image = dose_image * dcm.DoseGridScaling
+    
+    self.Image = dose_image
+    self.FrameOfReferenceUID = dcm.FrameOfReferenceUID
+    self.ImagePositionPatient = dcm.ImagePositionPatient
+    if dcm.SliceThickness is not None:
+        self.PixelSpacing = [dcm.PixelSpacing[0], dcm.PixelSpacing[1], dcm.SliceThickness]
+    else:
+        self.PixelSpacing = [dcm.PixelSpacing[0], dcm.PixelSpacing[1], dcm.GridFrameOffsetVector[1]-dcm.GridFrameOffsetVector[0]]
+    self.GridSize = [dcm.Columns, dcm.Rows, dcm.NumberOfFrames]
+    self.NumVoxels = self.GridSize[0] * self.GridSize[1] * self.GridSize[2]
+    
+    if hasattr(dcm, 'GridFrameOffsetVector'):
+      if(dcm.GridFrameOffsetVector[1] - dcm.GridFrameOffsetVector[0] < 0):
+        self.Image = np.flip(self.Image, 2)
+        self.ImagePositionPatient[2] = self.ImagePositionPatient[2] - self.GridSize[2]*self.PixelSpacing[2]
+    
+    self.resample_to_CT_grid(CT)
+    self.isLoaded = 1
+        
+    
+    
+  def euclidean_dist(self, v1, v2):
+    return sum((p-q)**2 for p, q in zip(v1, v2)) ** .5
+    
+    
+      
+  def resample_to_CT_grid(self, CT):
+    if(self.GridSize == CT.GridSize and self.euclidean_dist(self.ImagePositionPatient, CT.ImagePositionPatient) < 0.001 and self.euclidean_dist(self.PixelSpacing, CT.PixelSpacing) < 0.001):
+      return
+    else:
+      # anti-aliasing filter
+      sigma = [0, 0, 0]
+      if(CT.PixelSpacing[0] > self.PixelSpacing[0]): sigma[0] = 0.4 * (CT.PixelSpacing[0]/self.PixelSpacing[0])
+      if(CT.PixelSpacing[1] > self.PixelSpacing[1]): sigma[1] = 0.4 * (CT.PixelSpacing[1]/self.PixelSpacing[1])
+      if(CT.PixelSpacing[2] > self.PixelSpacing[2]): sigma[2] = 0.4 * (CT.PixelSpacing[2]/self.PixelSpacing[2])
+      if(sigma != [0, 0, 0]):
+        print("Image is filtered before downsampling")
+        self.Image = scipy.ndimage.gaussian_filter(self.Image, sigma)
+
+      
+      print('Resample dose image to CT grid.')
+    
+      x = self.ImagePositionPatient[1] + np.arange(self.GridSize[1]) * self.PixelSpacing[1]
+      y = self.ImagePositionPatient[0] + np.arange(self.GridSize[0]) * self.PixelSpacing[0]
+      z = self.ImagePositionPatient[2] + np.arange(self.GridSize[2]) * self.PixelSpacing[2]
+  
+      xi = np.array(np.meshgrid(CT.VoxelY, CT.VoxelX, CT.VoxelZ))
+      xi = np.rollaxis(xi, 0, 4)
+      xi = xi.reshape((xi.size // 3, 3))
+  
+      self.Image = scipy.interpolate.interpn((x,y,z), self.Image, xi, method='linear', fill_value=0, bounds_error=False)
+      self.Image = self.Image.reshape((CT.GridSize[0], CT.GridSize[1], CT.GridSize[2])).transpose(1,0,2)
+  
+      self.ImagePositionPatient = CT.ImagePositionPatient
+      self.PixelSpacing = CT.PixelSpacing
+      self.GridSize = CT.GridSize
+      self.NumVoxels = CT.NumVoxels
+
+ 
+  def load_from_nii(self, dose_nii):   
+      
+    # load the nii image
+    img = nib.load(dose_nii)
+    
+    self.Image = img.get_fdata() ### SHOULD I TRANSPOSE?
+    self.GridSize = self.Image.shape
+    self.PixelSpacing = [img.header['pixdim'][1], img.header['pixdim'][2], img.header['pixdim'][3]]
+    self.ImagePositionPatient = [ img.affine[0][3], img.affine[1][3], img.affine[2][3]]
+    
+  def export_Dicom(self, refCT, OutputFile):
+
+    # meta data
+    SOPInstanceUID = pydicom.uid.generate_uid() 
+    meta = pydicom.dataset.FileMetaDataset()
+    meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.481.2' # UID class for RTDOSE
+    meta.MediaStorageSOPInstanceUID = SOPInstanceUID
+    #meta.ImplementationClassUID = '1.2.826.0.1.3680043.1.2.100.5.7.0.47' # from RayStation
+    #meta.ImplementationClassUID = '1.2.826.0.1.3680043.5.5.100.5.7.0.03' # modified OpenTPS
+    meta.ImplementationClassUID = '1.2.826.0.1.3680043.1.2.100.6.40.0.76'# from Halcyon? st. luc breast patients
+    #meta.TransferSyntaxUID = '1.2.840.10008.1.2'
+
+    meta.FileMetaInformationGroupLength = 200
+    #meta.FileMetaInformationVersion = 
+    #meta.ImplementationVersionName = 'DicomObjects.NET'
+    # dcm_file.ImplementationVersionName =
+    # dcm_file.SoftwareVersion = 
+
+    # dicom dataset
+    dcm_file = pydicom.dataset.FileDataset(OutputFile, {}, file_meta=meta, preamble=b"\0" * 128) # CONFIRM WHAT IS OUTPUTFILE AND WHAT THIS LINE IS DOING
+
+    # transfer syntax  
+    dcm_file.file_meta.TransferSyntaxUID = pydicom.uid.ExplicitVRLittleEndian
+    print(dcm_file.file_meta.TransferSyntaxUID)
+    dcm_file.is_little_endian = True
+    dcm_file.is_implicit_VR = False
+
+    # Patient
+    dcm_file.PatientName = refCT.PatientInfo.PatientName #self.PatientInfo.PatientName
+    dcm_file.PatientID = refCT.PatientInfo.PatientID #self.PatientInfo.PatientID
+    dcm_file.PatientBirthDate = refCT.PatientInfo.PatientBirthDate #self.PatientInfo.PatientBirthDate
+    dcm_file.PatientSex = refCT.PatientInfo.PatientSex #self.PatientInfo.PatientSex
+    
+    # General Study
+    dt = datetime.datetime.now()
+    dcm_file.StudyDate = dt.strftime('%Y%m%d')
+    dcm_file.StudyTime = dt.strftime('%H%M%S.%f')
+    dcm_file.AccessionNumber = '1' # A RIS/PACS (Radiology Information System/picture archiving and communication system) generated number that identifies the order for the Study.
+    dcm_file.ReferringPhysicianName = 'NA'
+    dcm_file.StudyInstanceUID = refCT.StudyInfo.StudyInstanceUID # get from reference CT to indicate that they belong to the same study#self.StudyInfo.StudyInstanceUID
+    dcm_file.StudyID = refCT.StudyInfo.StudyID # get from reference CT to indicate that they belong to the same study
+
+    # RT Series
+    dcm_file.Modality = 'RTDOSE'
+    dcm_file.SeriesDescription = 'AI-predicted' + dt.strftime('%Y%m%d') + dt.strftime('%H%M%S.%f')#self.ImgName
+    dcm_file.OperatorsName = 'MIRO'
+    dcm_file.SeriesInstanceUID = pydicom.uid.generate_uid() # if we have a uid_base --> pydicom.uid.generate_uid(uid_base)
+    dcm_file.SeriesNumber = 1
+
+    # Frame of Reference
+    dcm_file.FrameOfReferenceUID = refCT.FrameOfReferenceUID # pydicom.uid.generate_uid()
+    dcm_file.PositionReferenceIndicator = '' #empty if unknown https://dicom.innolitics.com/ciods/rt-dose/frame-of-reference/00201040
+
+    # General Equipment
+    dcm_file.Manufacturer = 'echarp'
+    #dcm_file.ManufacturerModelName = 'echarp'
+    #dcm_file.PixelPaddingValue = # conditionally required! https://dicom.innolitics.com/ciods/rt-dose/general-equipment/00280120
+    
+    # General Image
+    dcm_file.ContentDate = dt.strftime('%Y%m%d')
+    dcm_file.ContentTime = dt.strftime('%H%M%S.%f')
+    dcm_file.InstanceNumber = 1
+    dcm_file.PatientOrientation = ''
+    
+    # Image Plane
+    dcm_file.SliceThickness = self.PixelSpacing[2]
+    dcm_file.ImagePositionPatient = self.ImagePositionPatient
+    dcm_file.ImageOrientationPatient = [1, 0, 0, 0, 1, 0] # HeadFirstSupine=1,0,0,0,1,0  FeetFirstSupine=-1,0,0,0,1,0  HeadFirstProne=-1,0,0,0,-1,0  FeetFirstProne=1,0,0,0,-1,0
+    dcm_file.PixelSpacing = self.PixelSpacing[0:2]
+    
+    # Image pixel
+    dcm_file.SamplesPerPixel = 1
+    dcm_file.PhotometricInterpretation = 'MONOCHROME2'
+    dcm_file.Rows = self.GridSize[1]
+    dcm_file.Columns = self.GridSize[0]
+    dcm_file.BitsAllocated = 16
+    dcm_file.BitsStored = 16
+    dcm_file.HighBit = 15
+    dcm_file.BitDepth = 16
+    dcm_file.PixelRepresentation = 0 # 0=unsigned, 1=signed
+    #dcm_file.ColorType = 'grayscale'
+    
+    # multi-frame
+    dcm_file.NumberOfFrames = self.GridSize[2]
+    dcm_file.FrameIncrementPointer = pydicom.tag.Tag((0x3004, 0x000c))
+    
+    # RT Dose
+    dcm_file.DoseUnits = 'GY'
+    dcm_file.DoseType = 'PHYSICAL' # or 'EFFECTIVE' for RBE dose (but RayStation exports physical dose even if 1.1 factor is already taken into account)
+    dcm_file.DoseSummationType = 'PLAN'
+    dcm_file.GridFrameOffsetVector = list(np.arange(0, self.GridSize[2]*self.PixelSpacing[2], self.PixelSpacing[2]))
+    dcm_file.DoseGridScaling = self.Image.max()/(2**dcm_file.BitDepth - 1)
+    # pixel data
+    dcm_file.PixelData = (self.Image/dcm_file.DoseGridScaling).astype(np.uint16).transpose(2,0,1).tostring() # ALTERNATIVE: self.Image.tobytes()
+
+    #dcm_file.TissueHeterogeneityCorrection = 'IMAGE,ROI_OVERRIDE'
+    # ReferencedPlan = pydicom.dataset.Dataset()
+    # ReferencedPlan.ReferencedSOPClassUID = "1.2.840.10008.5.1.4.1.1.481.8" # ion plan
+    # if(plan_uid == []): ReferencedPlan.ReferencedSOPInstanceUID = self.Plan_SOPInstanceUID
+    # else: ReferencedPlan.ReferencedSOPInstanceUID = plan_uid
+    # dcm_file.ReferencedRTPlanSequence = pydicom.sequence.Sequence([ReferencedPlan])
+    
+    # SOP common
+    dcm_file.SpecificCharacterSet = 'ISO_IR 100'
+    dcm_file.InstanceCreationDate = dt.strftime('%Y%m%d')
+    dcm_file.InstanceCreationTime = dt.strftime('%H%M%S.%f')
+    dcm_file.SOPClassUID = meta.MediaStorageSOPClassUID
+    dcm_file.SOPInstanceUID = SOPInstanceUID
+
+    # save dicom file
+    print("Export dicom RTDOSE: " + OutputFile)
+    dcm_file.save_as(OutputFile)
+    
+
+
+

libraries/Process/RTplan.py

@@ -0,0 +1,449 @@
+import pydicom
+import numpy as np
+import math
+import time
+import pickle, scipy
+
+
+
+class RTplan:
+
+  def __init__(self):
+    self.SeriesInstanceUID = ""
+    self.SOPInstanceUID = ""
+    self.PatientInfo = {}
+    self.StudyInfo = {}
+    self.DcmFile = ""
+    self.Modality = ""
+    self.RadiationType = ""
+    self.ScanMode = ""
+    self.TreatmentMachineName = ""
+    self.NumberOfFractionsPlanned = 1
+    self.NumberOfSpots = 0
+    self.Beams = []
+    self.TotalMeterset = 0.0
+    self.PlanName = ""
+    self.isLoaded = 0
+    self.beamlets = []
+    self.OriginalDicomDataset = []
+    
+    
+    
+  def print_plan_info(self, prefix=""):
+    print(prefix + "Plan: " + self.SeriesInstanceUID)
+    print(prefix + "   " + self.DcmFile)
+    
+    
+  
+  def import_Dicom_plan(self):
+    if(self.isLoaded == 1):
+      print("Warning: RTplan " + self.SeriesInstanceUID + " is already loaded")
+      return
+      
+    dcm = pydicom.dcmread(self.DcmFile)
+    
+    self.OriginalDicomDataset = dcm
+    
+    # Photon plan
+    if dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.481.5": 
+      print("ERROR: Conventional radiotherapy (photon) plans are not supported")
+      self.Modality = "Radiotherapy"
+      return
+  
+    # Ion plan  
+    elif dcm.SOPClassUID == "1.2.840.10008.5.1.4.1.1.481.8":
+      self.Modality = "Ion therapy"
+    
+      if dcm.IonBeamSequence[0].RadiationType == "PROTON":
+        self.RadiationType = "Proton"
+      else:
+        print("ERROR: Radiation type " + dcm.IonBeamSequence[0].RadiationType + " not supported")
+        self.RadiationType = dcm.IonBeamSequence[0].RadiationType
+        return
+       
+      if dcm.IonBeamSequence[0].ScanMode == "MODULATED":
+        self.ScanMode = "MODULATED" # PBS
+      else:
+        print("ERROR: Scan mode " + dcm.IonBeamSequence[0].ScanMode + " not supported")
+        self.ScanMode = dcm.IonBeamSequence[0].ScanMode
+        return 
+    
+    # Other  
+    else:
+      print("ERROR: Unknown SOPClassUID " + dcm.SOPClassUID + " for file " + self.DcmFile)
+      self.Modality = "Unknown"
+      return
+      
+    # Start parsing PBS plan
+    self.SOPInstanceUID = dcm.SOPInstanceUID
+    self.NumberOfFractionsPlanned = int(dcm.FractionGroupSequence[0].NumberOfFractionsPlanned)
+    self.NumberOfSpots = 0
+    self.TotalMeterset = 0  
+    
+    if(hasattr(dcm.IonBeamSequence[0], 'TreatmentMachineName')):
+      self.TreatmentMachineName = dcm.IonBeamSequence[0].TreatmentMachineName
+    else:
+      self.TreatmentMachineName = ""
+  
+    for dcm_beam in dcm.IonBeamSequence:
+      if dcm_beam.TreatmentDeliveryType != "TREATMENT":
+        continue
+      
+      first_layer = dcm_beam.IonControlPointSequence[0]
+      
+      beam = Plan_IonBeam()
+      beam.SeriesInstanceUID = self.SeriesInstanceUID
+      beam.BeamName = dcm_beam.BeamName
+      beam.IsocenterPosition = [float(first_layer.IsocenterPosition[0]), float(first_layer.IsocenterPosition[1]), float(first_layer.IsocenterPosition[2])]
+      beam.GantryAngle = float(first_layer.GantryAngle)
+      beam.PatientSupportAngle = float(first_layer.PatientSupportAngle)
+      beam.FinalCumulativeMetersetWeight = float(dcm_beam.FinalCumulativeMetersetWeight)
+    
+      # find corresponding beam in FractionGroupSequence (beam order may be different from IonBeamSequence)
+      ReferencedBeam_id = next((x for x, val in enumerate(dcm.FractionGroupSequence[0].ReferencedBeamSequence) if val.ReferencedBeamNumber == dcm_beam.BeamNumber), -1)
+      if ReferencedBeam_id == -1:
+        print("ERROR: Beam number " + dcm_beam.BeamNumber + " not found in FractionGroupSequence.")
+        print("This beam is therefore discarded.")
+        continue
+      else: beam.BeamMeterset = float(dcm.FractionGroupSequence[0].ReferencedBeamSequence[ReferencedBeam_id].BeamMeterset)
+    
+      self.TotalMeterset += beam.BeamMeterset
+    
+      if dcm_beam.NumberOfRangeShifters == 0:
+        beam.RangeShifterID = ""
+        beam.RangeShifterType = "none"
+      elif dcm_beam.NumberOfRangeShifters == 1:
+        beam.RangeShifterID = dcm_beam.RangeShifterSequence[0].RangeShifterID
+        if dcm_beam.RangeShifterSequence[0].RangeShifterType == "BINARY":
+          beam.RangeShifterType = "binary"
+        elif dcm_beam.RangeShifterSequence[0].RangeShifterType == "ANALOG":
+          beam.RangeShifterType = "analog"
+        else:
+          print("ERROR: Unknown range shifter type for beam " + dcm_beam.BeamName)
+          beam.RangeShifterType = "none"
+      else: 
+        print("ERROR: More than one range shifter defined for beam " + dcm_beam.BeamName)
+        beam.RangeShifterID = ""
+        beam.RangeShifterType = "none"
+      
+      
+      SnoutPosition = 0
+      if hasattr(first_layer, 'SnoutPosition'):
+        SnoutPosition = float(first_layer.SnoutPosition)
+    
+      IsocenterToRangeShifterDistance = SnoutPosition
+      RangeShifterWaterEquivalentThickness = ""
+      RangeShifterSetting = "OUT"
+      ReferencedRangeShifterNumber = 0
+    
+      if hasattr(first_layer, 'RangeShifterSettingsSequence'):
+        if hasattr(first_layer.RangeShifterSettingsSequence[0], 'IsocenterToRangeShifterDistance'):
+          IsocenterToRangeShifterDistance = float(first_layer.RangeShifterSettingsSequence[0].IsocenterToRangeShifterDistance)
+        if hasattr(first_layer.RangeShifterSettingsSequence[0], 'RangeShifterWaterEquivalentThickness'):
+          RangeShifterWaterEquivalentThickness = float(first_layer.RangeShifterSettingsSequence[0].RangeShifterWaterEquivalentThickness)
+        if hasattr(first_layer.RangeShifterSettingsSequence[0], 'RangeShifterSetting'):
+          RangeShifterSetting = first_layer.RangeShifterSettingsSequence[0].RangeShifterSetting
+        if hasattr(first_layer.RangeShifterSettingsSequence[0], 'ReferencedRangeShifterNumber'):
+          ReferencedRangeShifterNumber = int(first_layer.RangeShifterSettingsSequence[0].ReferencedRangeShifterNumber)
+       
+      CumulativeMeterset = 0
+    
+      for dcm_layer in dcm_beam.IonControlPointSequence:
+        if dcm_layer.NumberOfScanSpotPositions == 1: sum_weights = dcm_layer.ScanSpotMetersetWeights
+        else: sum_weights = sum(dcm_layer.ScanSpotMetersetWeights)
+      
+        if sum_weights == 0.0:
+          continue
+        
+        layer = Plan_IonLayer()
+        layer.SeriesInstanceUID = self.SeriesInstanceUID
+            
+        if hasattr(dcm_layer, 'SnoutPosition'):
+          SnoutPosition = float(dcm_layer.SnoutPosition)
+        
+        if hasattr(dcm_layer, 'NumberOfPaintings'): layer.NumberOfPaintings = int(dcm_layer.NumberOfPaintings)
+        else: layer.NumberOfPaintings = 1
+       
+        layer.NominalBeamEnergy = float(dcm_layer.NominalBeamEnergy)
+        layer.ScanSpotPositionMap_x = dcm_layer.ScanSpotPositionMap[0::2]
+        layer.ScanSpotPositionMap_y = dcm_layer.ScanSpotPositionMap[1::2]
+        layer.ScanSpotMetersetWeights = dcm_layer.ScanSpotMetersetWeights
+        layer.SpotMU = np.array(dcm_layer.ScanSpotMetersetWeights) * beam.BeamMeterset / beam.FinalCumulativeMetersetWeight # spot weights are converted to MU
+        if layer.SpotMU.size == 1: layer.SpotMU = [layer.SpotMU]
+        else: layer.SpotMU = layer.SpotMU.tolist()
+      
+        self.NumberOfSpots += len(layer.SpotMU)
+        CumulativeMeterset += sum(layer.SpotMU)
+        layer.CumulativeMeterset = CumulativeMeterset
+            
+        if beam.RangeShifterType != "none":        
+          if hasattr(dcm_layer, 'RangeShifterSettingsSequence'):
+            RangeShifterSetting = dcm_layer.RangeShifterSettingsSequence[0].RangeShifterSetting
+            ReferencedRangeShifterNumber = dcm_layer.RangeShifterSettingsSequence[0].ReferencedRangeShifterNumber
+            if hasattr(dcm_layer.RangeShifterSettingsSequence[0], 'IsocenterToRangeShifterDistance'):
+              IsocenterToRangeShifterDistance = dcm_layer.RangeShifterSettingsSequence[0].IsocenterToRangeShifterDistance
+            if hasattr(dcm_layer.RangeShifterSettingsSequence[0], 'RangeShifterWaterEquivalentThickness'):
+              RangeShifterWaterEquivalentThickness = dcm_layer.RangeShifterSettingsSequence[0].RangeShifterWaterEquivalentThickness
+        
+          layer.RangeShifterSetting = RangeShifterSetting
+          layer.IsocenterToRangeShifterDistance = IsocenterToRangeShifterDistance
+          layer.RangeShifterWaterEquivalentThickness = RangeShifterWaterEquivalentThickness
+          layer.ReferencedRangeShifterNumber = ReferencedRangeShifterNumber
+        
+        
+        beam.Layers.append(layer)
+      
+      self.Beams.append(beam)
+      
+    self.isLoaded = 1
+
+  def export_Dicom_with_new_UID(self, OutputFile):
+    # generate new uid
+    initial_uid = self.OriginalDicomDataset.SOPInstanceUID
+    new_uid = pydicom.uid.generate_uid()
+    self.OriginalDicomDataset.SOPInstanceUID = new_uid
+
+    # save dicom file
+    print("Export dicom RTPLAN: " + OutputFile)
+    self.OriginalDicomDataset.save_as(OutputFile)
+
+    # restore initial uid
+    self.OriginalDicomDataset.SOPInstanceUID = initial_uid
+
+    return new_uid
+
+
+
+  def save(self, file_path):
+    beamlets = self.beamlets
+    self.beamlets = []
+
+    with open(file_path, 'wb') as fid:
+      pickle.dump(self.__dict__, fid)
+
+    self.beamlets = beamlets
+
+
+
+  def load(self, file_path):
+    with open(file_path, 'rb') as fid:
+      tmp = pickle.load(fid)
+
+    self.__dict__.update(tmp)
+
+  def compute_cartesian_coordinates(self, CT, Scanner, beams, RangeShifters=[]):
+    time_start = time.time()
+    
+    SPR = SPRimage()
+    SPR.convert_CT_to_SPR(CT, Scanner)
+    
+    CTborders_x = [SPR.ImagePositionPatient[0], SPR.ImagePositionPatient[0] + SPR.GridSize[0] * SPR.PixelSpacing[0]]
+    CTborders_y = [SPR.ImagePositionPatient[1], SPR.ImagePositionPatient[1] + SPR.GridSize[1] * SPR.PixelSpacing[1]]
+    CTborders_z = [SPR.ImagePositionPatient[2], SPR.ImagePositionPatient[2] + SPR.GridSize[2] * SPR.PixelSpacing[2]]
+    
+    spot_positions = []
+    spot_directions = []
+    spot_ranges = []
+
+    # initialize spot info for raytracing
+    for beam in self.Beams:
+      #beam = self.Beams[b]
+
+      RangeShifter = -1
+      if beam.RangeShifterType == "binary":
+        RangeShifter = next((RS for RS in RangeShifters if RS.ID == beam.RangeShifterID), -1)
+
+      for layer in beam.Layers:
+
+        range_in_water = SPR.energyToRange(layer.NominalBeamEnergy)*10
+        if(layer.RangeShifterSetting == 'IN'):
+          if(layer.RangeShifterWaterEquivalentThickness != ""): RangeShifter_WET = layer.RangeShifterWaterEquivalentThickness
+          elif(RangeShifter != -1): RangeShifter_WET = RangeShifter.WET
+          else: RangeShifter_WET = 0.0
+
+          if(RangeShifter_WET > 0.0): range_in_water -= RangeShifter_WET
+
+        for s in range(len(layer.ScanSpotPositionMap_x)):
+          
+          # BEV coordinates to 3D coordinates: position (x,y,z) and direction (u,v,w)
+          x,y,z = layer.ScanSpotPositionMap_x[s], 0, layer.ScanSpotPositionMap_y[s]
+          u,v,w = 1e-10, 1.0, 1e-10
+          
+          # rotation for gantry angle (around Z axis)
+          angle = math.radians(beam.GantryAngle)
+          [x,y,z] = self.Rotate_vector([x,y,z], angle, 'z')
+          [u,v,w] = self.Rotate_vector([u,v,w], angle, 'z')
+          
+          # rotation for couch angle (around Y axis)
+          angle = math.radians(beam.PatientSupportAngle)
+          [x,y,z] = self.Rotate_vector([x,y,z], angle, 'y')
+          [u,v,w] = self.Rotate_vector([u,v,w], angle, 'y')
+          
+          # Dicom CT coordinates
+          x = x + beam.IsocenterPosition[0]
+          y = y + beam.IsocenterPosition[1]
+          z = z + beam.IsocenterPosition[2]
+          
+          # translate initial position at the CT image border
+          Translation = np.array([1.0, 1.0, 1.0])
+          Translation[0] = (x - CTborders_x[int(u<0)]) / u
+          Translation[1] = (y - CTborders_y[int(v<0)]) / v
+          Translation[2] = (z - CTborders_z[int(w<0)]) / w
+          Translation = Translation[np.argmin(np.absolute(Translation))]
+          x = x - Translation * u
+          y = y - Translation * v
+          z = z - Translation * w
+
+          # append data to the list of spots to process
+          spot_positions.append([x,y,z])
+          spot_directions.append([u,v,w])
+          spot_ranges.append(range_in_water)
+
+
+    CartesianSpotPositions = compute_position_from_range(SPR, spot_positions, spot_directions, spot_ranges)
+          
+    print("Spot RayTracing: " + str(time.time()-time_start) + " sec")
+    return CartesianSpotPositions 
+
+  #TO ADAPT
+  def compute_spot_maps(self, CT, plan, Struct, RangeShifters):
+    
+    # Find BODY
+    for ROI in Struct.Contours:
+        if ROI.ROIName == 'BODY':
+            BODY = ROI 
+            break
+
+    # Initialize Spot Maps
+    SpotMapBinary = np.full((CT.GridSize[0], CT.GridSize[1], CT.GridSize[2], len(plan.Beams)), False)
+    SpotMapWeights = np.zeros((CT.GridSize[0], CT.GridSize[1], CT.GridSize[2], len(plan.Beams)))
+
+    
+    #Compute cartesian coordinates
+    CartesianCoordinates = plan.compute_cartesian_coordinates(CT, 'UCL_Toshiba', plan.Beams, RangeShifters)
+
+    # Initialize SpotID
+    SpotsID = np.zeros((plan.NumberOfSpots, 4),dtype=int)
+    SpotNumber = 0
+    SpotsOutsideBody = 0
+    # Repeat = [] 
+    # SpotsID_repeat = [] 
+
+    print('ImagePositionPatient',CT.ImagePositionPatient)
+    # Compute SpotsID
+    print('\n')
+    counter = 0
+    for beamNumber, beam in enumerate(plan.Beams):
+        print('nb of layers',len(beam.Layers))
+        for layer in beam.Layers: 
+            for weight in layer.SpotMU:
+                #print('SpotNumber',SpotNumber)
+                #print('CartesianCoordinates',CartesianCoordinates[SpotNumber])
+                #print('ImagePositionPatient',CT.ImagePositionPatient)
+                #print('PixelSpacing',CT.PixelSpacing)
+                # x = int((CartesianCoordinates[SpotNumber][0] - CT.ImagePositionPatient[0])/CT.PixelSpacing[0])-1
+                # y = int((CartesianCoordinates[SpotNumber][1] - CT.ImagePositionPatient[1])/CT.PixelSpacing[1])-1
+                # z = int((CartesianCoordinates[SpotNumber][2] - CT.ImagePositionPatient[2])/CT.PixelSpacing[2])-1
+
+                x = int(CartesianCoordinates[SpotNumber][0]/CT.PixelSpacing[0])
+                y = int(CartesianCoordinates[SpotNumber][1]/CT.PixelSpacing[1])
+                z = int(CartesianCoordinates[SpotNumber][2]/CT.PixelSpacing[2])
+                
+                SpotsID[SpotNumber,:] = [x,y,z,beamNumber]
+                #print('coordinates',[x,y,z,beamNumber])
+                #print('Spots ID',SpotsID[SpotNumber,:])
+                
+                SpotNumber += 1
+
+                if BODY.Mask[x,y,z]==False:  # avoid spots outside BODY 
+                    SpotsOutsideBody += 1
+                    print('This spot is outside the body',[x,y,z])
+                    continue
+                
+                # if (x,y,z,beamNumber) in SpotsID_repeat:
+                #     Repeat.append((x,y,z,beamNumber))     
+                
+                # SpotsID_repeat.append((x,y,z,beamNumber))
+                SpotMapBinary[x,y,z,beamNumber] = True
+                SpotMapWeights[x,y,z,beamNumber] = weight 
+                counter+=1
+    # We can get SpotMapBinary as boolean SpotMapWeights 
+    # plan.SpotMapBinary = SpotMapBinary
+    plan.SpotMapWeights = SpotMapWeights     
+    
+    #     print('SpotsID beam_' + str(beamNumber) + ' computed...')    
+    # print('nb of iteration',counter)
+    # save_file_binary = os.path.join(dst_dir, 'SpotMapBinary_beams.npz') 
+    # np.savez_compressed(save_file_binary,SpotMapBinary)   
+    # print('\nSpot Map Binary saved = ' + save_file_binary)
+    
+    # save_file_weights = os.path.join(dst_dir, 'SpotMapWeights_beams.npz')
+    # np.savez_compressed(save_file_weights, SpotMapWeights.astype(np.float16))
+    # print('Spot Map Weights saved = ' + save_file_weights)
+    
+    # save_file_ID = os.path.join(dst_dir, 'spotsID.npz')    
+    # np.savez_compressed(save_file_ID, SpotsID)
+    # print('SpotsID saved = ' + save_file_ID)
+    
+    # print('\nNumber of Spots in plan = ' + str(plan.NumberOfSpots))
+    # print('Number of Spots in binary mask = ' + str(np.ndarray.flatten(SpotMapBinary).tolist().count(True)))
+    # print('Spots placed outside the body = ' + (str(SpotsOutsideBody)))  
+    
+    # if len(Repeat)!=0:  
+    #     spots_repeated_by_patient.append(['Patient_' + str(PatientNumber) + ' (' + Patient.PatientInfo.PatientName + ')', len(Repeat)])
+        
+    # print('\nAt this point, there are ' + str(len(spots_repeated_by_patient)) + ' patients with spots repeated')
+    # for repeat in spots_repeated_by_patient:
+    #     print(repeat[0] + ' has ' + str(repeat[1]) + ' spots repeated')
+    # print('\n')
+
+  def Rotate_vector(self, vec, angle, axis):
+      if axis == 'x':
+        x = vec[0]
+        y = vec[1] * math.cos(angle) - vec[2] * math.sin(angle)
+        z = vec[1] * math.sin(angle) + vec[2] * math.cos(angle)
+      elif axis ==  'y':
+        x = vec[0] * math.cos(angle) + vec[2] * math.sin(angle)
+        y = vec[1]
+        z = -vec[0] * math.sin(angle) + vec[2] * math.cos(angle)
+      elif axis == 'z':
+        x = vec[0] * math.cos(angle) - vec[1] * math.sin(angle)
+        y = vec[0] * math.sin(angle) + vec[1] * math.cos(angle)
+        z = vec[2]
+        
+      return [x,y,z]
+  
+      
+class Plan_IonBeam:
+
+  def __init__(self):
+    self.SeriesInstanceUID = ""
+    self.BeamName = ""
+    self.IsocenterPosition = [0,0,0]
+    self.GantryAngle = 0.0
+    self.PatientSupportAngle = 0.0
+    self.FinalCumulativeMetersetWeight = 0.0
+    self.BeamMeterset = 0.0
+    self.RangeShifter = "none"
+    self.Layers = []
+  
+  
+  
+class Plan_IonLayer:
+
+  def __init__(self):
+    self.SeriesInstanceUID = ""
+    self.NumberOfPaintings = 1
+    self.NominalBeamEnergy = 0.0
+    self.ScanSpotPositionMap_x = []
+    self.ScanSpotPositionMap_y = []
+    self.ScanSpotMetersetWeights = []
+    self.SpotMU = []
+    self.CumulativeMeterset = 0.0
+    self.RangeShifterSetting = 'OUT'
+    self.IsocenterToRangeShifterDistance = 0.0
+    self.RangeShifterWaterEquivalentThickness = 0.0
+    self.ReferencedRangeShifterNumber = 0
+    
+    
+    

libraries/Process/RTstruct.py

@@ -0,0 +1,542 @@
+import pydicom
+import numpy as np
+import nibabel as nib
+#from matplotlib.path import Path
+from PIL import Image, ImageDraw
+import scipy
+import datetime
+import SimpleITK as sitk
+
+
+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
+
+    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("The structure [ ", dcm_struct.ROIName ," ] 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_xor(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, data_format, flip):
+      
+    # data_format can be either "integers" or "one-hot" (i.e. 2**i)
+          
+    #flip if needed
+    if flip == True:
+        #struct_nib = nib.orientations.flip_axis(struct_nib, axis=0)
+        img = sitk.ReadImage(struct_nii_path)
+        img2 = sitk.PermuteAxes(img, [1,0,2])
+        sitk.WriteImage(img2, struct_nii_path)
+        
+    # load the nii image 
+    struct_nib = nib.load(struct_nii_path)
+    struct_data = struct_nib.get_fdata()
+        
+    # load the file according to data_format
+    if data_format == 'integers':
+        roinumbers = np.unique(struct_data)
+        roinumbers = roinumbers[roinumbers > 0] # assumes we have a background = 0
+        print(roinumbers)
+    elif data_format == 'one-hot':
+        roinumbers = list(np.arange(np.floor(np.log2(np.max(struct_data))).astype(int)+1)) # CAREFUL WITH THIS LINE, MIGHT NOT WORK IF WE HAVE OVERLAP OF STRUCTURES
+    
+    # get contourexists from header or compute it from labels and data values
+    if hasattr(struct_nib.header, 'extensions') and len(struct_nib.header.extensions) != 0: 
+        contoursexist = list(struct_nib.header.extensions[0].get_content())
+    else:
+        if data_format == 'integers':
+            contoursexist = []
+            for i in range(len(rtstruct_labels)):
+                if i+1 in roinumbers:
+                    contoursexist.append(1)
+                else:
+                    contoursexist.append(0)
+        elif data_format == 'one-hot': # AGAIN, THIS ONLY WORKS IF WE DONT HAVE OVERLAP
+            contoursexist = []
+            for i in range(len(rtstruct_labels)):
+                if 2**i in roinumbers:
+                    contoursexist.append(1)
+                else:
+                    contoursexist.append(0)
+    
+    # get number of rois in struct_data    
+    nb_rois_in_struct = len(roinumbers)
+    self.NumContours = len(rtstruct_labels)
+    # check that they match
+    if 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(rtstruct_labels) as number of rois")
+
+    # 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 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:
+            if data_format == 'integers':
+                Contour.Mask = (struct_data == c+1).astype(bool)
+            elif data_format == 'one-hot':
+                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 ECHARP 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
+    
+
+    

libraries/utils_nii_dicom.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Sep  5 20:34:46 2020
+
+@author: ana
+"""
+
+
+# import general libraries
+import os
+import numpy as np
+import pandas as pd
+import scipy
+import nibabel as nib
+import pydicom
+import glob
+import warnings
+from copy import deepcopy
+from scipy.ndimage import find_objects
+from scipy.ndimage.morphology import binary_fill_holes
+from skimage import measure
+from matplotlib.patches import Polygon
+
+
+###############################################################################
+###################################   FUNCTIONS   #############################
+###############################################################################
+
+def get_dict(dict_path):
+    """
+    get dictionary in NAS/public_info
+    :param : dict_path(string) location of the dictionary
+    :return: dictionary in pandas format
+    """
+    if dict_path == 'default':
+        dictionary = pd.read_excel(r'/home/ana/NAS_database/public_info/RT_dictionary.xlsx',  engine='openpyxl')
+    else:
+        dictionary = pd.read_excel(dict_path, engine='openpyxl')
+    
+    return dictionary
+
+      
+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 is not None:
+        nii_file.header.extensions.append(nib.nifti1.Nifti1Extension(0, bytearray(contours_exist)))
+    return nii_file
+
+
+def get_struct_and_contoursexist(roi,arrayshape):
+    struct = np.zeros((arrayshape[0],arrayshape[1],arrayshape[2]))
+    roi_names = list(roi.keys())   
+    contoursexist = []
+    
+    for i in range(len(roi_names)):
+        if(not(roi[roi_names[i]] is None)):
+            contoursexist.append(1)
+            struct += (2**i)*roi[roi_names[i]]
+        else:
+            contoursexist.append(0)
+    return struct, contoursexist
+
+
+def save_images(dst_dir, voxelsize, image_position_patient, image, image_type, roi=None, dose=None, bdoses=None, prior_knowledge = None, spotmap = None):
+    
+    # encode in nii  and save at dst_dir
+    # IMPORTANT WE 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
+    image_nii = nib.Nifti1Image(image, affine=np.eye(4)) # for Nifti1 header, change for a Nifti2 type of header
+    # 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,image_type.lower()+'.nii.gz'))
+    
+    # DOSE
+    if dose is not None:
+        dose_nii = nib.Nifti1Image(dose, affine=np.eye(4)) # for Nifti1 header, change for a Nifti2 type of header
+        # Update header fields
+        dose_nii = set_header_info(dose_nii, voxelsize, image_position_patient)
+        # Save nii 
+        nib.save(dose_nii, os.path.join(dst_dir,'dose.nii.gz'))
+
+    # BDOSES
+    if bdoses is not None:
+        for b in range(len(bdoses)):
+            bdose_nii = nib.Nifti1Image(bdoses[b].Image, affine=np.eye(4)) # for Nifti1 header, change for a Nifti2 type of header
+            # Update header fields
+            bdose_nii = set_header_info(bdose_nii, voxelsize, image_position_patient)
+            # Save nii
+            nib.save(bdose_nii, os.path.join(dst_dir,'dose_b{}.nii.gz'.format(b+1)))
+
+    # PRIOR KNOWLEDGE 
+    if prior_knowledge is not None:
+        for charact, pk in prior_knowledge.items():
+            prior_knowledge_nii = nib.Nifti1Image(pk, affine=np.eye(4)) # for Nifti1 header, change for a Nifti2 type of header
+            # Update header fields
+            prior_knowledge_nii = set_header_info(prior_knowledge_nii, voxelsize, image_position_patient)
+            # Save nii 
+            nib.save(prior_knowledge_nii, os.path.join(dst_dir,'prior_knowledge_{}.nii.gz'.format(charact.lower())))
+
+    # RTSTRUCT
+    if roi is not None:
+        struct_compressed, contours_exist = get_struct_and_contoursexist(roi, image_shape)
+
+        struct_nii_compressed = nib.Nifti1Image(struct_compressed, affine=np.eye(4)) # for Nifti1 header, change for a Nifti2 type of header
+        # struct_nii_compressed.set_data_dtype('smallest')
+        # Update header fields
+        struct_nii_compressed = set_header_info(struct_nii_compressed, voxelsize, image_position_patient, contours_exist=contours_exist)
+        # Save nii 
+        nib.save(struct_nii_compressed, os.path.join(dst_dir,'struct.nii.gz'))  
+
+
+

libraries/utils_preprocess.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Sep  5 20:34:46 2020
+
+@author: ana
+"""
+
+
+# import general libraries
+import os
+import numpy as np
+import pandas as pd
+import scipy
+import nibabel as nib
+import pydicom
+import glob
+import warnings
+from copy import deepcopy
+from scipy.ndimage import find_objects
+from scipy.ndimage.morphology import binary_fill_holes
+from skimage import measure
+from matplotlib.patches import Polygon
+from libraries.utils_nii_dicom import set_header_info
+
+
+###############################################################################
+###################################   FUNCTIONS   #############################
+###############################################################################
+
+def delete_all(obj):
+    for i in vars(obj):
+        del obj.i
+
+def overwrite_ct_threshold(ct_image, body = None, artefact = None, contrast = None):
+    # Change the HU out of the body to air: -1000    
+    if body is not None:
+        # Change the HU outside the body to -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 remove_dose_outside_mask(dose, mask = None):
+    # Put dose = 0 outside the mask (typically the body)   
+    if mask is not None:
+        dose[mask==0]=0
+    return dose
+
+def get_and_save_tv(roi, nib_header, tv_names, dst_dir):
+    tv = np.zeros(nib_header['dim'][1:4])
+    roi_names = list(roi.keys())
+    if tv_names is not None:
+        for c in tv_names:
+            if c in roi_names:
+                tv[roi[c]>0]=int(c.split('_')[1])/100
+                
+    # create nii, update header and save
+    save_nii_image(tv, nib_header,dst_dir, 'struct_tv')
+
+    return tv
+
+def get_and_save_oars(roi, nib_header, oar_names, dst_dir):
+    oars = np.zeros(nib_header['dim'][1:4])
+    
+    roi_names = list(roi.keys())
+    contoursexist = []
+    
+    if oar_names is not None:
+        for i in range(len(oar_names)):
+            if oar_names[i] in roi_names:
+                if roi[oar_names[i]] is not None:
+                    contoursexist.append(1)
+                    oars += (2**i)*roi[oar_names[i]]
+                else:
+                    contoursexist.append(0)        
+                    
+    # create nii, update header and save 
+    save_nii_image(oars, nib_header,dst_dir, 'struct_oar', contours_exist = contoursexist)
+
+        
+def get_and_save_sample_probability(tv,dst_dir):
+    # get sample probability for patch-based training
+    bufftv=np.zeros_like(tv)
+    bufftv[tv!=0]=1
+    m=bufftv.sum(axis=0).sum(axis=0).sum()/1000
+    sample_probability_slc=(bufftv.sum(axis=0).sum(axis=0)+m)/(bufftv.sum(axis=0).sum(axis=0)+m).sum()
+    sample_probability_row=(bufftv.sum(axis=1).sum(axis=1)+m)/(bufftv.sum(axis=1).sum(axis=1)+m).sum()
+    sample_probability_col=(bufftv.sum(axis=0).sum(axis=-1)+m)/(bufftv.sum(axis=0).sum(axis=-1)+m).sum()
+    
+    np.savez_compressed(os.path.join(dst_dir,'sample_probability_row.npz'),sample_probability_row)
+    np.savez_compressed(os.path.join(dst_dir,'sample_probability_col.npz'),sample_probability_col)
+    np.savez_compressed(os.path.join(dst_dir,'sample_probability_slc.npz'),sample_probability_slc)
+    
+
+def decompress_struct(struct_nib,struct_list):
+    
+    struct_data = struct_nib.get_fdata()
+    roi = dict.fromkeys(struct_list, None) 
+    # get contourexists from header
+    contoursexist = list(struct_nib.header.extensions[0].get_content())
+    for i in range(len(contoursexist)):
+        if contoursexist[i] == 1:
+            roi[struct_list[i]] = np.bitwise_and(struct_data.astype(int), 2 ** i).astype(bool)
+
+    return roi
+
+def binary_to_integers(struct,select_list):
+        
+    roi_names = list(struct.keys())
+    # get shape
+    for k in roi_names:
+        if struct[k] is not None:
+            struct_shape = struct[k].shape
+    # initialize roi
+    roi = np.zeros(struct_shape)     
+    
+    # initialize label
+    label = 0
+    for i in range(len(select_list)):
+        label = label + 1
+        if select_list[i] in roi_names:
+            if struct[select_list[i]] is not None:
+                # populate roi matrix with selected rois in select_list
+                roi[struct[select_list[i]]] = label
+        
+    return roi
+
+def save_nii_image(nib_img, nib_header,dst_dir, image_name, 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,image_name +'.nii.gz'))
+
+
+
+