pydicomrt 0.4.0__py3-none-any.whl

pydicomrt/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from pydicomrt!")

pydicomrt/ct/ct_ds_iod.py

@@ -0,0 +1,40 @@
+from pydicom.uid import UID
+
+
+CT_IMAGE_IOD = {
+    "PatientID": {},
+    "PatientName": {},
+    "PatientBirthDate": {},
+    "PatientSex": {},
+    "StudyInstanceUID": {},
+    "StudyID": {},
+    "StudyDate": {},
+    "StudyTime": {},
+    "AccessionNumber": {},
+    "SeriesInstanceUID": {"type": UID},
+    "SeriesNumber": {},
+    "Modality": {"value": "CT"},
+    "Manufacturer": {},
+    "FrameOfReferenceUID": {"type": UID},
+    "SOPClassUID": {"type": UID},
+    "SOPInstanceUID": {"type": UID},
+    "InstanceNumber": {},
+
+    "SliceThickness": {},
+    "ImagePositionPatient": {},
+    "ImageOrientationPatient": {},
+    "PixelSpacing": {},
+
+    "Rows": {},
+    "Columns": {},
+
+    "ImageType": {},
+    "BitsAllocated": {},
+    "BitsStored": {},
+    "HighBit": {},
+    "RescaleIntercept": {},
+    "RescaleSlope": {},
+
+    "PixelData": {},
+
+}

pydicomrt/dose/builder.py

@@ -0,0 +1,156 @@
+import os
+import numpy as np
+import SimpleITK as sitk
+
+from datetime import datetime
+from pydicom.tag import Tag
+from pydicom.dataset import Dataset, FileDataset, FileMetaDataset
+from pydicom.sequence import Sequence
+from pydicom.uid import generate_uid
+from pydicom.uid import ImplicitVRLittleEndian
+
+
+DICOM_UID_PREFIX = os.getenv('DICOM_UID_PREFIX', "1.2.826.0.1.3680043.8.498.")  # PYDICOM_ROOT_UID
+
+def generate_base_dataset() -> FileDataset:
+    file_name = "bear_dose"
+    file_meta = get_file_meta()
+    ds = FileDataset(file_name, {}, file_meta=file_meta, preamble=b"\0" * 128)
+    add_required_elements_to_ds(ds)
+    add_sequence_lists_to_ds(ds)
+    return ds
+
+def get_file_meta() -> FileMetaDataset:
+    file_meta = FileMetaDataset()
+    file_meta.FileMetaInformationGroupLength = 190
+    file_meta.FileMetaInformationVersion = b"\x00\x01"
+    file_meta.TransferSyntaxUID = ImplicitVRLittleEndian
+    file_meta.MediaStorageSOPClassUID = "1.2.840.10008.5.1.4.1.1.481.2"
+    file_meta.MediaStorageSOPInstanceUID = (
+        generate_uid(prefix=DICOM_UID_PREFIX)
+    )
+    file_meta.ImplementationClassUID = DICOM_UID_PREFIX + "1"
+    # TODO file_meta.ImplementationVersionName = ""
+    return file_meta
+
+def add_required_elements_to_ds(ds: FileDataset):
+    dt = datetime.now()
+    # Append data elements required by the DICOM standarad
+    ds.SpecificCharacterSet = "ISO_IR 192"
+    ds.InstanceCreationDate = dt.strftime("%Y%m%d")
+    ds.InstanceCreationTime = dt.strftime("%H%M%S")
+    ds.Modality = "RTDOSE"
+    ds.Manufacturer = "higumalu"
+    ds.ManufacturerModelName = "modelv1"
+    ds.InstitutionName = "higumalu"
+    # Set the transfer syntax
+    ds.is_little_endian = True
+    ds.is_implicit_VR = True
+    # Set values already defined in the file meta
+    ds.SOPClassUID = ds.file_meta.MediaStorageSOPClassUID
+    ds.SOPInstanceUID = ds.file_meta.MediaStorageSOPInstanceUID
+
+    ds.ApprovalStatus = "UNAPPROVED"
+
+def add_sequence_lists_to_ds(ds: FileDataset):
+    ds.ReferencedRTPlanSequence = Sequence()
+
+# ---------------------------------------------------------------------------------------- #
+
+def add_patient_information(ds: FileDataset, reference_ds: Dataset):
+    ds.PatientName = getattr(reference_ds, "PatientName", "Unknown")
+    ds.PatientID = getattr(reference_ds, "PatientID", "Unknown")
+    ds.PatientBirthDate = getattr(reference_ds, "PatientBirthDate", "")
+    ds.PatientSex = getattr(reference_ds, "PatientSex", "")
+    ds.PatientAge = getattr(reference_ds, "PatientAge", "")
+    ds.PatientSize = getattr(reference_ds, "PatientSize", "")
+    ds.PatientWeight = getattr(reference_ds, "PatientWeight", "")
+    return ds
+
+def add_study_information(ds: FileDataset, reference_ds: Dataset):
+    dt = datetime.now()
+    ds.StudyInstanceUID = getattr(reference_ds, "StudyInstanceUID", generate_uid(prefix=DICOM_UID_PREFIX))
+    ds.StudyDate = getattr(reference_ds, "StudyDate", dt.strftime("%Y%m%d"))
+    ds.StudyTime = getattr(reference_ds, "StudyTime", dt.strftime("%H%M%S"))
+    ds.StudyID = getattr(reference_ds, "StudyID", "")
+    ds.AccessionNumber = getattr(reference_ds, "AccessionNumber", "")
+    ds.ReferringPhysicianName = getattr(reference_ds, "ReferringPhysicianName", "")
+    return ds
+
+def add_series_information(ds: FileDataset, reference_ds: Dataset, series_number: int = 1):
+    dt = datetime.now()
+    ds.Modality = "RTDOSE"
+    ds.SeriesInstanceUID = generate_uid(prefix=DICOM_UID_PREFIX)
+    ds.SeriesDate = dt.strftime("%Y%m%d")
+    ds.SeriesTime = dt.strftime("%H%M%S")
+    ds.SeriesDescription = getattr(reference_ds, "SeriesDescription", "") + "_dose" + dt.strftime("%Y%m%d%H%M%S")
+    ds.SeriesNumber = getattr(reference_ds, "SeriesNumber", series_number)
+    ds.OperatorsName = getattr(reference_ds, "OperatorsName", "")
+    return ds
+
+def add_frame_of_reference_information(ds: FileDataset, reference_ds: Dataset):
+    ds.FrameOfReferenceUID = getattr(reference_ds, "FrameOfReferenceUID", generate_uid(prefix=DICOM_UID_PREFIX))
+    ds.PositionReferenceIndicator = getattr(reference_ds, "PositionReferenceIndicator", "")
+    return ds
+
+# ---------------------------------------------------------------------------------------- #
+
+def cp_information_from_ds(
+    ds: FileDataset,
+    reference_ds: Dataset,
+    ):
+    ds = add_patient_information(ds, reference_ds)
+    ds = add_study_information(ds, reference_ds)
+    ds = add_series_information(ds, reference_ds)
+    ds = add_frame_of_reference_information(ds, reference_ds)
+    return ds
+
+# ---------------------------------------------------------------------------------------- #
+
+def add_dose_grid_to_ds(
+    ds: FileDataset,
+    dose_sitk_image: sitk.Image,
+    ):
+    scaling = 1e-7
+    array = sitk.GetArrayFromImage(dose_sitk_image)
+    size = list(dose_sitk_image.GetSize())
+    spacing = list(dose_sitk_image.GetSpacing())
+    direction = list(dose_sitk_image.GetDirection())
+    origin = list(dose_sitk_image.GetOrigin())
+
+    ds.SamplesPerPixel = 1
+    ds.PhotometricInterpretation = "MONOCHROME2"
+    ds.BitsAllocated = 32
+    ds.BitsStored = 32
+    ds.HighBit = 31
+    ds.PixelRepresentation = True
+    ds.DoseUnits = "GY"
+    ds.DoseType = "EFFECTIVE"
+    ds.DoseSummationType = "PLAN"
+    ds.NumberOfFrames = size[2]
+    ds.FrameIncrementPointer = Tag(0x3004, 0x000C)
+
+    ds.ImagePositionPatient = origin
+    ds.ImageOrientationPatient = direction
+    ds.PixelSpacing = spacing[0:2]
+    ds.SliceThickness = spacing[2]
+    ds.Columns = size[0]
+    ds.Rows = size[1]
+    ds.GridFrameOffsetVector = [ov * spacing[2] for ov in range(size[2])]
+    ds.DoseGridScaling = scaling
+    ds.PixelData = (array // scaling).astype(np.uint32).tobytes()
+    return ds
+
+
+# -------------------------------- example --------------------------------------------------- #
+
+if __name__ == "__main__":
+    import pydicom
+    import SimpleITK as sitk
+    dose_sitk_image = sitk.ReadImage("example/data/DF_001/RD_003/CT_001_dose.dcm")
+    ds = pydicom.dcmread("example/data/DF_001/RD_003/CT_001.dcm")
+
+    dose_ds = generate_base_dataset()
+    dose_ds = cp_information_from_ds(dose_ds, ds)
+    dose_ds = add_dose_grid_to_ds(dose_ds, dose_sitk_image)
+    dose_ds.save_as("example/data/DF_001/RD_003/dose.dcm")

pydicomrt/dose/dose_ds_iod.py

@@ -0,0 +1,42 @@
+from pydicom.uid import UID
+
+# RT Dose CIOD
+RT_DOSE_IOD = {
+    "PatientID": {},
+    "PatientName": {},
+    "PatientBirthDate": {},
+    "PatientSex": {},
+    "StudyInstanceUID": {},
+    "StudyID": {},
+    "StudyDate": {},
+    "StudyTime": {},
+    "AccessionNumber": {},
+    "SeriesInstanceUID": {"type": UID},
+    "SeriesNumber": {},
+    "Modality": {"value": "RTDOSE"},
+    "Manufacturer": {},
+    "FrameOfReferenceUID": {"type": UID},
+    "SOPClassUID": {"type": UID},
+    "SOPInstanceUID": {"type": UID},
+    "InstanceNumber": {},
+
+    "NumberOfFrames": {},
+    "Rows": {},
+    "Columns": {},
+    "PixelSpacing": {},
+    "ImageOrientationPatient": {},
+    "ImagePositionPatient": {},     # if value == (3004,000C) GridFrameOffsetVector is required
+    "SliceThickness": {"optional": True},
+
+    "BitsAllocated": {},
+    "BitsStored": {},
+    "HighBit": {},
+    "PixelRepresentation": {},
+
+    "DoseUnits": {"value": "GY"},
+    "DoseType": {},
+    "DoseSummationType": {"value": "PLAN"},
+    "GridFrameOffsetVector": {},
+
+    "PixelData": {},
+}

pydicomrt/reg/builder.py

@@ -0,0 +1,21 @@
+
+
+class SpatialRegistrationBuilder:
+    def __init__(self, fixed_ds_list, moving_ds_list, transform_matrix):
+        self.fixed_ds_list = fixed_ds_list
+        self.moving_ds_list = moving_ds_list
+        self.transform_matrix = transform_matrix
+
+
+class DeformableSpatialRegistrationBuilder:
+    def __init__(
+        self, fixed_ds_list, moving_ds_list,
+        pre_transform,
+        vectorial_field,
+        post_transform
+        ):
+        self.fixed_ds_list = fixed_ds_list
+        self.moving_ds_list = moving_ds_list
+        self.pre_transform = pre_transform
+        self.vectorial_field = vectorial_field
+        self.post_transform = post_transform

pydicomrt/reg/check.py

@@ -0,0 +1,30 @@
+from pydicom.dataset import Dataset
+from .ds_reg_ds_iod import DEFORMABLE_SPATIAL_REGSITRATION_IOD
+from .s_reg_ds_iod import SPATIAL_REGSITRATION_IOD
+from pydicomrt.utils.validate_dcm_info import check_iod
+
+
+def check_ds_reg_iod(rs_ds: Dataset) -> dict:
+    result_dict = {
+        "result": True,
+        "content": []
+    }
+    failed_item_list = []
+    failed_item_list = check_iod(ds=rs_ds, config_map=DEFORMABLE_SPATIAL_REGSITRATION_IOD)
+    if len(failed_item_list) > 0:
+        result_dict["result"] = False
+        result_dict["content"] = failed_item_list
+    return result_dict
+
+
+def check_s_reg_iod(rs_ds: Dataset) -> dict:
+    result_dict = {
+        "result": True,
+        "content": []
+    }
+    failed_item_list = []
+    failed_item_list = check_iod(ds=rs_ds, config_map=SPATIAL_REGSITRATION_IOD)
+    if len(failed_item_list) > 0:
+        result_dict["result"] = False
+        result_dict["content"] = failed_item_list
+    return result_dict

pydicomrt/reg/ds_reg_ds_iod.py

@@ -0,0 +1,40 @@
+from pydicom.uid import UID
+
+# Deformable Spatial Registration CIOD
+DEFORMABLE_SPATIAL_REGSITRATION_IOD = {
+    "PatientID": {},
+    "PatientName": {},
+    "PatientBirthDate": {},
+    "PatientSex": {},
+    "StudyInstanceUID": {},
+    "StudyID": {},
+    "StudyDate": {},
+    "StudyTime": {},
+    "AccessionNumber": {},
+    "SeriesInstanceUID": {"type": UID},
+    "SeriesNumber": {},
+    "Modality": {"value": "REG"},
+    "Manufacturer": {},
+    "FrameOfReferenceUID": {"type": UID},
+    "SOPClassUID": {"type": UID},
+    "SOPInstanceUID": {"type": UID},
+    "InstanceNumber": {},
+    "ContentLabel": {},
+    "ContentDescription": {},
+    "DeformableRegistrationSequence": {
+        "SourceFrameOfReferenceUID": {"type": UID},
+        "submap": {
+            "DeformableRegistrationGridSequence": {
+                "ImagePositionPatient": {},
+                "ImageOrientationPatient": {},
+                "GridDimensions": {},
+                "GridResolution": {},
+                "VectorGridData": {}
+            },
+            "PreDeformationMatrixRegistrationSequence": {},
+            "PostDeformationMatrixRegistrationSequence": {},
+            "RegistrationTypeCodeSequence": {},
+        }
+    },
+
+}

pydicomrt/reg/parser.py

@@ -0,0 +1,29 @@
+
+import numpy as np
+from struct import unpack
+
+from pydicom.dataset import Dataset
+
+def get_deformable_reg_list(reg_ds: Dataset) -> list:
+    reg_dict_list = []
+    for reg in reg_ds.DeformableRegistrationSequence:
+        reg_dict = {}
+        reg_dict['SourceFrameOfReferenceUID'] = reg.SourceFrameOfReferenceUID
+        reg_dict['PreDeformationMatrixRegistration'] = reg.PreDeformationMatrixRegistrationSequence[-1].FrameOfReferenceTransformationMatrix
+        reg_dict['PostDeformationMatrixRegistration'] = reg.PostDeformationMatrixRegistrationSequence[-1].FrameOfReferenceTransformationMatrix
+        reg_dict['DeformableRegistrationGrid'] = {}
+        deformed_grid_data = reg.DeformableRegistrationGridSequence[-1]
+
+        reg_dict['DeformableRegistrationGrid']['GridDimensions'] = deformed_grid_data.GridDimensions
+        reg_dict['DeformableRegistrationGrid']['GridResolution'] = deformed_grid_data.GridResolution
+        reg_dict['DeformableRegistrationGrid']['ImagePositionPatient'] = deformed_grid_data.ImagePositionPatient
+
+        grid_dim = deformed_grid_data.GridDimensions
+        vector_grid_data = deformed_grid_data.VectorGridData
+        vector_grid_data = unpack(f"<{len(vector_grid_data) // 4}f", vector_grid_data)
+        deformed_array = np.reshape(vector_grid_data, grid_dim[::-1] + [3,])
+
+        reg_dict['DeformableRegistrationGrid']['VectorGridData'] = deformed_array
+        reg_dict_list.append(reg_dict)
+
+    return reg_dict_list

pydicomrt/reg/s_reg_ds_iod.py

@@ -0,0 +1,38 @@
+from pydicom.uid import UID
+
+# Spatial Registration CIOD
+SPATIAL_REGSITRATION_IOD = {
+    "PatientID": {},
+    "PatientName": {},
+    "PatientBirthDate": {},
+    "PatientSex": {},
+    "StudyInstanceUID": {},
+    "StudyID": {},
+    "StudyDate": {},
+    "StudyTime": {},
+    "AccessionNumber": {},
+    "SeriesInstanceUID": {"type": UID},
+    "SeriesNumber": {},
+    "Modality": {"value": "REG"},
+    "Manufacturer": {},
+    "FrameOfReferenceUID": {"type": UID},
+    "SOPClassUID": {"type": UID},
+    "SOPInstanceUID": {"type": UID},
+    "InstanceNumber": {},
+    "ContentLabel": {},
+    "ContentDescription": {},
+    "RegistrationSequence": {
+        "FrameOfReferenceUID": {"type": UID},
+        "submap": {
+            "MatrixRegistrationSequence": {
+                "submap": {
+                    "MatrixSequence": {
+                        "FrameOfReferenceTransformationMatrixType": {},
+                        "FrameOfReferenceTransformationMatrix": {},
+                    }
+                }
+            },
+        }
+    },
+
+}

pydicomrt/reg/sitk_reg_method.py

@@ -0,0 +1,141 @@
+import numpy as np
+import SimpleITK as sitk
+
+
+def rigid_registration(
+    fixed_image: sitk.Image,
+    moving_image: sitk.Image,
+    histogram_bins: int = 50,
+    learning_rate: float = 1.0,
+    iterations: int = 100,
+    convergence_minimum_value: float = 1e-6,
+    convergence_window_size: int = 10,
+    ) -> sitk.Transform:
+    """
+    Perform rigid registration (translation and rotation only) between two 3D SimpleITK images and return an affine transform.
+    Args:
+        fixed_image (sitk.Image)
+        moving_image (sitk.Image)
+        histogram_bins (int)
+        learning_rate (float)
+        iterations (int)
+        convergence_minimum_value (float)
+        convergence_window_size (int)
+    Returns:
+        sitk.Transform: The resulting affine transform (containing only rotation + translation)
+    """
+    fixed_image = sitk.Cast(fixed_image, sitk.sitkFloat32)
+    moving_image = sitk.Cast(moving_image, sitk.sitkFloat32)
+
+    registration_method = sitk.ImageRegistrationMethod()
+    registration_method.SetMetricAsMattesMutualInformation(numberOfHistogramBins=histogram_bins)
+    registration_method.SetInterpolator(sitk.sitkLinear)
+    registration_method.SetOptimizerAsGradientDescent(
+        learningRate=learning_rate,
+        numberOfIterations=iterations,
+        convergenceMinimumValue=convergence_minimum_value,
+        convergenceWindowSize=convergence_window_size,
+    )
+    registration_method.SetOptimizerScalesFromPhysicalShift()
+    initial_transform = sitk.CenteredTransformInitializer(
+        fixed_image,
+        moving_image,
+        sitk.VersorRigid3DTransform(),
+        sitk.CenteredTransformInitializerFilter.GEOMETRY
+    )
+    initial_transform.SetCenter((0.0, 0.0, 0.0))
+    registration_method.SetInitialTransform(initial_transform, inPlace=False)
+    final_transform = registration_method.Execute(fixed_image, moving_image)
+    if isinstance(final_transform, sitk.CompositeTransform):
+        transform = final_transform.GetNthTransform(0)
+    else:
+        transform = final_transform
+    affine_transform = sitk.AffineTransform(3)
+    affine_transform.SetMatrix(transform.GetMatrix())
+    affine_transform.SetTranslation(transform.GetTranslation())
+    return affine_transform
+
+
+def deformable_registration(fixed_image, moving_image, mesh_size=8):
+    """
+    Perform deformable registration and output displacement field (numpy array with spatial information) and SimpleITK transform object.
+
+    Args:
+        fixed_image (sitk.Image): Fixed image (reference)
+        moving_image (sitk.Image): Moving image (to be registered)
+        mesh_size (int or list): B-spline mesh size (default 8, can be adjusted based on image size)
+
+    Returns:
+        dfield_transform (sitk.DisplacementFieldTransform): SimpleITK displacement transform
+    """
+    if isinstance(mesh_size, int):
+        mesh_size = [mesh_size] * fixed_image.GetDimension()
+    tx = sitk.BSplineTransformInitializer(fixed_image, mesh_size)
+
+    registration_method = sitk.ImageRegistrationMethod()
+    registration_method.SetMetricAsMattesMutualInformation(numberOfHistogramBins=100)
+    registration_method.SetOptimizerAsGradientDescent(
+        learningRate=1.0,
+        numberOfIterations=50,
+        convergenceMinimumValue=1e-6,
+        convergenceWindowSize=10
+    )
+    registration_method.SetInterpolator(sitk.sitkLinear)
+    registration_method.SetInitialTransform(tx, inPlace=False)
+    # registration_method.SetShrinkFactorsPerLevel(shrinkFactors=[4, 2, 1])       # 4 2 1
+    # registration_method.SetSmoothingSigmasPerLevel(smoothingSigmas=[2, 1, 0])   # 2 1 0
+    # registration_method.SmoothingSigmasAreSpecifiedInPhysicalUnitsOn()
+
+    outTx = registration_method.Execute(fixed_image, moving_image)
+
+    displacement_field = sitk.TransformToDisplacementField(
+        outTx,
+        sitk.sitkVectorFloat64,
+        fixed_image.GetSize(),
+        fixed_image.GetOrigin(),
+        fixed_image.GetSpacing(),
+        fixed_image.GetDirection()
+    )
+
+    dfield_transform = sitk.DisplacementFieldTransform(displacement_field)
+    return dfield_transform
+
+
+def affine_to_homogeneous_matrix(transform: sitk.AffineTransform) -> np.ndarray:
+    """
+    Convert a SimpleITK AffineTransform to a 4x4 homogeneous transformation matrix.
+
+    Args:
+        transform (sitk.AffineTransform): The affine transform to convert.
+
+    Returns:
+        np.ndarray: 4x4 homogeneous matrix (dtype float64).
+    """
+    matrix3x3 = np.array(transform.GetMatrix()).reshape((3, 3))
+    translation = np.array(transform.GetTranslation())
+    hom_mat = np.eye(4)
+    hom_mat[:3, :3] = matrix3x3
+    hom_mat[:3, 3] = translation
+    return hom_mat
+
+
+def displacement_field_to_dict(transform: sitk.DisplacementFieldTransform) -> dict:
+    """
+    Convert a SimpleITK DisplacementFieldTransform to a dictionary.
+    Args:
+        transform (sitk.DisplacementFieldTransform): The displacement field transform to convert.
+    Returns:
+        dict: Dictionary containing displacement field information.
+    """
+    displacement_field = sitk.GetArrayFromImage(transform.GetDisplacementField())
+    origin = transform.GetOrigin()
+    spacing = transform.GetSpacing()
+    direction = transform.GetDirection()
+    size = transform.GetSize()
+    return {
+        "vector_grid": displacement_field,
+        "origin": origin,
+        "spacing": spacing,
+        "direction": direction,
+        "size": size,
+    }

pydicomrt/rs/__init__.py

@@ -0,0 +1,46 @@
+"""Radiation Therapy Structure Set module"""
+
+from .builder import create_rtstruct_dataset
+
+from .add_new_roi import create_roi_into_rs_ds
+
+from .make_contour_sequence import (
+    add_contour_sequence_from_mask3d,
+    add_contour_sequence_from_dcm_ctr_dict
+)
+
+from .parser import (
+    get_contour_dict,
+    get_roi_number_to_name
+)
+
+from .checker import (
+    is_rtstruct_matching_series,
+    check_rs_iod
+)
+
+from .rs_to_volume import (
+    rtstruct_to_mask_dict,
+    calc_image_series_affine_mapping,
+    calc_rs_affine_mapping
+)
+
+
+__all__ = [
+    'create_rtstruct_dataset',
+    'create_roi_into_rs_ds',
+
+    'add_contour_sequence_from_mask3d',
+    'add_contour_sequence_from_dcm_ctr_dict',
+
+    'get_contour_dict',
+    'get_roi_number_to_name',
+
+    'is_rtstruct_matching_series',
+    'check_rs_iod',
+
+    'rtstruct_to_mask_dict',
+    'calc_image_series_affine_mapping',
+    'calc_rs_affine_mapping',
+
+]

pydicomrt/rs/add_new_roi.py

@@ -0,0 +1,50 @@
+from pydicom.dataset import Dataset
+from pydicom.sequence import Sequence
+
+
+def create_roi_into_rs_ds(
+    rs_ds: Dataset,
+    roi_color: list,
+    roi_number: int,
+    roi_name: str,
+    roi_description: str,
+    roi_interpreted_type: str = "ORGAN",
+    ) -> Dataset:
+    frame_of_ref_uid = rs_ds.FrameOfReferenceUID
+    rs_ds.StructureSetROISequence.append(create_empty_structure_set_roi(roi_number, roi_name, roi_description, frame_of_ref_uid))
+    rs_ds.ROIContourSequence.append(create_empty_roi_contour_sequence(roi_number, roi_color))
+    rs_ds.RTROIObservationsSequence.append(create_empty_rtroi_observation(roi_number, roi_interpreted_type))
+    return rs_ds
+
+def create_empty_structure_set_roi(roi_number,
+                                   roi_name,
+                                   roi_description,
+                                   frame_of_ref_uid,
+                                   roi_generation_algorithm="AUTOMATIC",
+                                   roi_generation_description="KumaGenerated",
+                                   ) -> Dataset:
+    structure_set_roi = Dataset()
+    structure_set_roi.ROINumber = roi_number
+    structure_set_roi.ROIName = roi_name
+    structure_set_roi.ROIDescription = roi_description
+    structure_set_roi.ROIGenerationAlgorithm = roi_generation_algorithm
+    structure_set_roi.ROIGenerationDescription = roi_generation_description
+    structure_set_roi.ReferencedFrameOfReferenceUID = frame_of_ref_uid
+    return structure_set_roi
+
+def create_empty_roi_contour_sequence(roi_number, roi_color) -> Dataset:
+    roi_contour_sequence = Dataset()
+    roi_contour_sequence.ReferencedROINumber = roi_number    # also in create_structure_set_roi
+    roi_contour_sequence.ROIDisplayColor = roi_color
+    roi_contour_sequence.ContourSequence = Sequence()
+    return roi_contour_sequence
+
+def create_empty_rtroi_observation(roi_number, roi_interpreted_type='ORGAN') -> Dataset:
+    rtroi_observation = Dataset()
+    rtroi_observation.ObservationNumber = roi_number
+    rtroi_observation.ReferencedROINumber = roi_number
+    rtroi_observation.ROIObservationDescription = "Type:Soft,Range:*/*,Fill:0,Opacity:0.0,Thickness:1,LineThickness:2,read-only:false"
+    rtroi_observation.private_creators = "higumalu"
+    rtroi_observation.RTROIInterpretedType = roi_interpreted_type
+    rtroi_observation.ROIInterpreter = ""
+    return rtroi_observation