def write_file_meta_info(fp, file_meta, enforce_standard=True): """Write the File Meta Information elements in `file_meta` to `fp`. If `enforce_standard` is ``True`` then the file-like `fp` should be positioned past the 128 byte preamble + 4 byte prefix (which should already have been written). **DICOM File Meta Information Group Elements** From the DICOM standard, Part 10, :dcm:`Section 7.1<part10/chapter_7.html#sect_7.1>`, any DICOM file shall contain a 128-byte preamble, a 4-byte DICOM prefix 'DICM' and (at a minimum) the following Type 1 DICOM Elements (from :dcm:`Table 7.1-1<part10/chapter_7.html#table_7.1-1>`): * (0002,0000) *File Meta Information Group Length*, UL, 4 * (0002,0001) *File Meta Information Version*, OB, 2 * (0002,0002) *Media Storage SOP Class UID*, UI, N * (0002,0003) *Media Storage SOP Instance UID*, UI, N * (0002,0010) *Transfer Syntax UID*, UI, N * (0002,0012) *Implementation Class UID*, UI, N If `enforce_standard` is ``True`` then (0002,0000) will be added/updated, (0002,0001) and (0002,0012) will be added if not already present and the other required elements will be checked to see if they exist. If `enforce_standard` is ``False`` then `file_meta` will be written as is after minimal validation checking. The following Type 3/1C Elements may also be present: * (0002,0013) *Implementation Version Name*, SH, N * (0002,0016) *Source Application Entity Title*, AE, N * (0002,0017) *Sending Application Entity Title*, AE, N * (0002,0018) *Receiving Application Entity Title*, AE, N * (0002,0102) *Private Information*, OB, N * (0002,0100) *Private Information Creator UID*, UI, N If `enforce_standard` is ``True`` then (0002,0013) will be added/updated. *Encoding* The encoding of the *File Meta Information* shall be *Explicit VR Little Endian*. Parameters ---------- fp : file-like The file-like to write the File Meta Information to. file_meta : pydicom.dataset.Dataset The File Meta Information elements. enforce_standard : bool If ``False``, then only the *File Meta Information* elements already in `file_meta` will be written to `fp`. If ``True`` (default) then a DICOM Standards conformant File Meta will be written to `fp`. Raises ------ ValueError If `enforce_standard` is ``True`` and any of the required *File Meta Information* elements are missing from `file_meta`, with the exception of (0002,0000), (0002,0001) and (0002,0012). ValueError If any non-Group 2 Elements are present in `file_meta`. """ validate_file_meta(file_meta, enforce_standard) if enforce_standard and 'FileMetaInformationGroupLength' not in file_meta: # Will be updated with the actual length later file_meta.FileMetaInformationGroupLength = 0 # Write the File Meta Information Group elements # first write into a buffer to avoid seeking back, that can be # expansive and is not allowed if writing into a zip file buffer = DicomBytesIO() buffer.is_little_endian = True buffer.is_implicit_VR = False write_dataset(buffer, file_meta) # If FileMetaInformationGroupLength is present it will be the first written # element and we must update its value to the correct length. if 'FileMetaInformationGroupLength' in file_meta: # Update the FileMetaInformationGroupLength value, which is the number # of bytes from the end of the FileMetaInformationGroupLength element # to the end of all the File Meta Information elements. # FileMetaInformationGroupLength has a VR of 'UL' and so has a value # that is 4 bytes fixed. The total length of when encoded as # Explicit VR must therefore be 12 bytes. file_meta.FileMetaInformationGroupLength = buffer.tell() - 12 buffer.seek(0) write_data_element(buffer, file_meta[0x00020000]) fp.write(buffer.getvalue())
def test_validate_and_correct_file_meta(self): file_meta = Dataset() validate_file_meta(file_meta, enforce_standard=False) with pytest.raises(ValueError): validate_file_meta(file_meta, enforce_standard=True) file_meta.PatientID = 'PatientID' for enforce_standard in (True, False): with pytest.raises(ValueError, match=r'Only File Meta Information Group ' r'\(0002,eeee\) elements must be present .*'): validate_file_meta(file_meta, enforce_standard=enforce_standard) file_meta = Dataset() file_meta.MediaStorageSOPClassUID = '1.2.3' file_meta.MediaStorageSOPInstanceUID = '1.2.4' # still missing TransferSyntaxUID with pytest.raises(ValueError): validate_file_meta(file_meta, enforce_standard=True) file_meta.TransferSyntaxUID = ImplicitVRLittleEndian validate_file_meta(file_meta, enforce_standard=True) # check the default created values assert file_meta.FileMetaInformationVersion == b'\x00\x01' assert file_meta.ImplementationClassUID == PYDICOM_IMPLEMENTATION_UID assert file_meta.ImplementationVersionName.startswith('PYDICOM ') file_meta.ImplementationClassUID = '1.2.3.4' file_meta.ImplementationVersionName = 'ACME LTD' validate_file_meta(file_meta, enforce_standard=True) # check that existing values are left alone assert file_meta.ImplementationClassUID == '1.2.3.4' assert file_meta.ImplementationVersionName == 'ACME LTD'
def write_file_meta_info(fp, file_meta, enforce_standard=True): """Write the File Meta Information elements in `file_meta` to `fp`. If `enforce_standard` is True then the file-like `fp` should be positioned past the 128 byte preamble + 4 byte prefix (which should already have been written). DICOM File Meta Information Group Elements ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ From the DICOM standard, Part 10 Section 7.1, any DICOM file shall contain a 128-byte preamble, a 4-byte DICOM prefix 'DICM' and (at a minimum) the following Type 1 DICOM Elements (from Table 7.1-1): * (0002,0000) FileMetaInformationGroupLength, UL, 4 * (0002,0001) FileMetaInformationVersion, OB, 2 * (0002,0002) MediaStorageSOPClassUID, UI, N * (0002,0003) MediaStorageSOPInstanceUID, UI, N * (0002,0010) TransferSyntaxUID, UI, N * (0002,0012) ImplementationClassUID, UI, N If `enforce_standard` is True then (0002,0000) will be added/updated, (0002,0001) and (0002,0012) will be added if not already present and the other required elements will be checked to see if they exist. If `enforce_standard` is False then `file_meta` will be written as is after minimal validation checking. The following Type 3/1C Elements may also be present: * (0002,0013) ImplementationVersionName, SH, N * (0002,0016) SourceApplicationEntityTitle, AE, N * (0002,0017) SendingApplicationEntityTitle, AE, N * (0002,0018) ReceivingApplicationEntityTitle, AE, N * (0002,0100) PrivateInformationCreatorUID, UI, N * (0002,0102) PrivateInformation, OB, N If `enforce_standard` is True then (0002,0013) will be added/updated. Encoding ~~~~~~~~ The encoding of the File Meta Information shall be Explicit VR Little Endian Parameters ---------- fp : file-like The file-like to write the File Meta Information to. file_meta : pydicom.dataset.Dataset The File Meta Information DataElements. enforce_standard : bool If False, then only the File Meta Information elements already in `file_meta` will be written to `fp`. If True (default) then a DICOM Standards conformant File Meta will be written to `fp`. Raises ------ ValueError If `enforce_standard` is True and any of the required File Meta Information elements are missing from `file_meta`, with the exception of (0002,0000), (0002,0001) and (0002,0012). ValueError If any non-Group 2 Elements are present in `file_meta`. """ validate_file_meta(file_meta, enforce_standard) if enforce_standard and 'FileMetaInformationGroupLength' not in file_meta: # Will be updated with the actual length later file_meta.FileMetaInformationGroupLength = 0 # Only used if FileMetaInformationGroupLength is present. # FileMetaInformationGroupLength has a VR of 'UL' and so has a value that # is 4 bytes fixed. The total length of when encoded as Explicit VR must # therefore be 12 bytes. end_group_length_elem = fp.tell() + 12 # The 'is_little_endian' and 'is_implicit_VR' attributes will need to be # set correctly after the File Meta Info has been written. fp.is_little_endian = True fp.is_implicit_VR = False # Write the File Meta Information Group elements to `fp` write_dataset(fp, file_meta) # If FileMetaInformationGroupLength is present it will be the first written # element and we must update its value to the correct length. if 'FileMetaInformationGroupLength' in file_meta: # Save end of file meta to go back to end_of_file_meta = fp.tell() # Update the FileMetaInformationGroupLength value, which is the number # of bytes from the end of the FileMetaInformationGroupLength element # to the end of all the File Meta Information elements group_length = int(end_of_file_meta - end_group_length_elem) file_meta.FileMetaInformationGroupLength = group_length fp.seek(end_group_length_elem - 12) write_data_element(fp, file_meta[0x00020000]) # Return to end of the file meta, ready to write remainder of the file fp.seek(end_of_file_meta)
def generate_dicom_sr(file_path, img_ds, data, series_description): """ Generates DICOM Structured Report files for the given file path. :param file_path: the file name and directory to save the DICOM SR file in. :param img_ds: A CT or MR image from the dataset used to pull general information for the DICOM SR. :param data: Text data to be written to the DICOM SR file. :param series_description: Description of text data written to SR. :return: dicom_sr, a dataset for the new DICOM SR file. """ if img_ds is None: raise ValueError("No CT data to initialize RT SS") # Create file meta file_meta = FileMetaDataset() file_meta.FileMetaInformationGroupLength = 238 file_meta.FileMetaInformationVersion = b'\x00\x01' file_meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.88.33' file_meta.MediaStorageSOPInstanceUID = pydicom.uid.generate_uid() file_meta.TransferSyntaxUID = ImplicitVRLittleEndian validate_file_meta(file_meta) # Create dataset dicom_sr = pydicom.dataset.FileDataset(file_path, {}, preamble=b"\0" * 128, file_meta=file_meta) dicom_sr.fix_meta_info() # Get current date and time now = datetime.datetime.now() dicom_date = now.strftime("%Y%m%d") dicom_time = now.strftime("%H%M") # List of tags to copy from CT/MR image top_level_tags_to_copy: list = [ Tag("PatientName"), Tag("PatientID"), Tag("PatientBirthDate"), Tag("PatientSex"), Tag("StudyDate"), Tag("StudyTime"), Tag("ReferringPhysicianName"), Tag("StudyDescription"), Tag("StudyInstanceUID"), Tag("StudyID"), Tag("RequestingService"), Tag("PatientAge"), Tag("PatientSize"), Tag("PatientWeight"), Tag("MedicalAlerts"), Tag("Allergies"), Tag("PregnancyStatus"), Tag("InstitutionName"), Tag("InstitutionAddress") ] # Copy tags from CT/MR image for tag in top_level_tags_to_copy: if tag in img_ds: dicom_sr[tag] = deepcopy(img_ds[tag]) dicom_sr.AccessionNumber = "" # == SR Document Series Module dicom_sr.SeriesDate = dicom_date dicom_sr.SeriesTime = dicom_time dicom_sr.Modality = "SR" dicom_sr.SeriesDescription = series_description # Can be empty referenced_performed_procedure_step_sequence = Sequence() dicom_sr.ReferencedPerformedProcedureStepSequence = \ referenced_performed_procedure_step_sequence dicom_sr.SeriesInstanceUID = pydicom.uid.generate_uid() dicom_sr.SeriesNumber = 1 # == General Equipment Module dicom_sr.Manufacturer = "OnkoDICOM" dicom_sr.ManufacturersModelName = "OnkoDICOM" # TODO: Pull this off build information in some way dicom_sr.SoftwareVersions = "2021" # == SR Document General Module dicom_sr.ContentDate = dicom_date dicom_sr.ContentTime = dicom_time dicom_sr.InstanceNumber = 1 # Empty if unknown performed_procedure_code_sequence = Sequence() dicom_sr.PerformedProcedureCodeSequence = performed_procedure_code_sequence # Do not want to mark as complete in case it isn't! dicom_sr.CompletionFlag = "PARTIAL" dicom_sr.VerificationFlag = "UNVERIFIED" # == SR Document Content Module referenced_sop_sequence = Sequence([Dataset()]) referenced_sop_sequence[0].ReferencedSOPClassUID = '' referenced_sop_sequence[0].ReferencedSOPInstanceUID = '' dicom_sr.ReferencedSOPSequence = referenced_sop_sequence dicom_sr.ValueType = "CONTAINER" dicom_sr.ContinuityOfContent = "CONTINUOUS" dicom_sr.TemporalRangeTime = "" dicom_sr.ReferencedTimeOffsets = "" dicom_sr.ReferencedDateTime = "" dicom_sr.MeasuredValueSequence = Sequence() og_frame_of_reference_UID = \ deepcopy(img_ds[Tag("FrameOfReferenceUID")].value) dicom_sr.ReferencedFrameOfReferenceUID = og_frame_of_reference_UID # == Content Sequence content_sequence = Sequence([Dataset()]) content_sequence[0].RelationshipType = 'CONTAINS' content_sequence[0].ValueType = 'TEXT' concept_name_code_sequence = Sequence([Dataset()]) concept_name_code_sequence[0].CodeValue = '' concept_name_code_sequence[0].CodingSchemeDesignator = '' concept_name_code_sequence[0].CodeMeaning = '' content_sequence[0].ConceptNameCodeSequence = concept_name_code_sequence content_sequence[0].TextValue = data dicom_sr.ContentSequence = content_sequence # == SOP Common Module dicom_sr.SOPClassUID = '1.2.840.10008.5.1.4.1.1.88.33' dicom_sr.SOPInstanceUID = file_meta.MediaStorageSOPInstanceUID dicom_sr.is_little_endian = True dicom_sr.is_implicit_VR = True return dicom_sr
def __init__(self, dataset, memmap_pixel_array=False): """Initialize DicomParser from a pydicom Dataset or DICOM file. Parameters ---------- dataset : pydicom Dataset or filename pydicom dataset object or DICOM file location memmap_pixel_array : bool, optional Enable pixel array access via memory mapping, by default False Raises ------ AttributeError Raised if SOPClassUID is not present in the pydicom Dataset AttributeError Raised if the DICOM file or pydicom Dataset cannot be read """ self.memmap_pixel_array = memmap_pixel_array if isinstance(dataset, Dataset): self.ds = dataset elif isinstance(dataset, (string_types, BytesIO)): try: with open(dataset, "rb") as fp: self.ds = read_file(fp, defer_size=100, force=True, stop_before_pixels=memmap_pixel_array) if memmap_pixel_array: self.offset = fp.tell() + 8 except Exception: # Raise the error for the calling method to handle raise else: # Sometimes DICOM files may not have headers, # but they should always have a SOPClassUID # to declare what type of file it is. # If the file doesn't have a SOPClassUID, # then it probably isn't DICOM. if "SOPClassUID" not in self.ds: raise AttributeError else: raise AttributeError # Fix dataset file_meta if incorrect try: validate_file_meta(self.ds.file_meta) except ValueError: logger.debug('Fixing invalid File Meta for ' + str(self.ds.SOPInstanceUID)) self.ds.fix_meta_info() # Remove the PixelData attribute if it is not set. # i.e. RTStruct does not contain PixelData and its presence can confuse # the parser if "PixelData" in self.ds and self.ds.PixelData is None: delattr(self.ds, 'PixelData') if memmap_pixel_array: self.filename = dataset self.pixel_array = self.get_pixel_array else: if "PixelData" in self.ds: self.pixel_array = self.ds.pixel_array
def test_valid_filemeta(new_rtstruct: RTStruct): try: validate_file_meta(new_rtstruct.ds.file_meta) except Exception: pytest.fail("Invalid file meta in RTStruct dataset")
def create_initial_rtss_from_ct(img_ds: pydicom.dataset.Dataset, filepath: Path, uid_list: list) -> pydicom.dataset.FileDataset: """ Pre-populate an RT Structure Set based on a single CT (or MR) and a list of image UIDs The caller should update the Structure Set Label, Name, and Description, which are set to "OnkoDICOM" plus the StudyID from the CT, and must add Structure Set ROI Sequence, ROI Contour Sequence, and RT ROI Observations Sequence Parameters ---------- img_ds : pydicom.dataset.Dataset A CT or MR image that the RT Structure Set will be "drawn" on uid_list : list list of UIDs (as strings) of the entire image volume that the RT SS references filepath: str A path where the RTStruct will be saved Returns ------- pydicom.dataset.FileDataset the half-baked RT SS, ready for Structure Set ROI Sequence, ROI Contour Sequence, and RT ROI Observations Sequence Raises ------ ValueError [description] """ if img_ds is None: raise ValueError("No CT data to initialize RT SS") now = datetime.datetime.now() dicom_date = now.strftime("%Y%m%d") dicom_time = now.strftime("%H%M") # File Meta module file_meta = FileMetaDataset() file_meta.FileMetaInformationGroupLength = 238 file_meta.FileMetaInformationVersion = b'\x00\x01' file_meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.481.3' file_meta.MediaStorageSOPInstanceUID = generate_uid() file_meta.TransferSyntaxUID = ImplicitVRLittleEndian validate_file_meta(file_meta) rt_ss = pydicom.dataset.FileDataset(filepath, {}, preamble=b"\0" * 128, file_meta=file_meta) rt_ss.fix_meta_info() top_level_tags_to_copy: list = [ Tag("PatientName"), Tag("PatientID"), Tag("PatientBirthDate"), Tag("PatientSex"), Tag("StudyDate"), Tag("StudyTime"), Tag("AccessionNumber"), Tag("ReferringPhysicianName"), Tag("StudyDescription"), Tag("StudyInstanceUID"), Tag("StudyID"), Tag("RequestingService"), Tag("PatientAge"), Tag("PatientSize"), Tag("PatientWeight"), Tag("MedicalAlerts"), Tag("Allergies"), Tag("PregnancyStatus"), Tag("FrameOfReferenceUID"), Tag("PositionReferenceIndicator"), Tag("InstitutionName"), Tag("InstitutionAddress"), Tag("OperatorsName") ] for tag in top_level_tags_to_copy: if tag in img_ds: rt_ss[tag] = deepcopy(img_ds[tag]) if rt_ss.StudyInstanceUID == "": raise ValueError( "The given dataset is missing a required tag 'StudyInstanceUID'") # RT Series Module rt_ss.SeriesDate = dicom_date rt_ss.SeriesTime = dicom_time rt_ss.Modality = "RTSTRUCT" rt_ss.OperatorsName = "" rt_ss.SeriesInstanceUID = pydicom.uid.generate_uid() rt_ss.SeriesNumber = "1" # General Equipment Module rt_ss.Manufacturer = "OnkoDICOM" rt_ss.ManufacturerModelName = "OnkoDICOM" # TODO: Pull this off build information in some way rt_ss.SoftwareVersions = "2021" # Frame of Reference module rt_ss.FrameOfReferenceUID = img_ds.FrameOfReferenceUID rt_ss.PositionReferenceIndicator = "" # Structure Set module # Best to modify the Structure Set Label with something more # interesting in the application. and populate the Name and # Description from the application also. rt_ss.StructureSetLabel = "OnkoDICOM rtss" rt_ss.StructureSetName = rt_ss.StructureSetLabel rt_ss.StructureSetDescription = "OnkoDICOM rtss of " + rt_ss.StudyID rt_ss.StructureSetDate = dicom_date rt_ss.StructureSetTime = dicom_time # Contour Image Sequence contour_image_sequence = [] for uid in uid_list: contour_image_sequence_item = pydicom.dataset.Dataset() contour_image_sequence_item.ReferencedSOPClassUID = img_ds.SOPClassUID contour_image_sequence_item.ReferencedSOPInstanceUID = uid contour_image_sequence.append(contour_image_sequence_item) # RT Referenced Series Sequence rt_referenced_series = pydicom.dataset.Dataset() rt_referenced_series.SeriesInstanceUID = img_ds.SeriesInstanceUID rt_referenced_series.ContourImageSequence = contour_image_sequence rt_referenced_series_sequence = [rt_referenced_series] # RT Referenced Study Sequence rt_referenced_study = pydicom.dataset.Dataset() rt_referenced_study.ReferencedSOPClassUID = "1.2.840.10008.3.1.2.3.1" rt_referenced_study.ReferencedSOPInstanceUID = img_ds.StudyInstanceUID rt_referenced_study.RTReferencedSeriesSequence = \ rt_referenced_series_sequence rt_referenced_study_sequence = [rt_referenced_study] # RT Referenced Frame Of Reference Sequence, Structure Set Module referenced_frame_of_reference = pydicom.dataset.Dataset() referenced_frame_of_reference.FrameOfReferenceUID = \ img_ds.FrameOfReferenceUID referenced_frame_of_reference.RTReferencedStudySequence = \ rt_referenced_study_sequence rt_ss.ReferencedFrameOfReferenceSequence = [referenced_frame_of_reference] # Sequence modules rt_ss.StructureSetROISequence = [] rt_ss.ROIContourSequence = [] rt_ss.RTROIObservationsSequence = [] # SOP Common module rt_ss.SOPClassUID = rt_ss.file_meta.MediaStorageSOPClassUID rt_ss.SOPInstanceUID = rt_ss.file_meta.MediaStorageSOPInstanceUID # Add required elements rt_ss.InstanceCreationDate = dicom_date rt_ss.InstanceCreationTime = dicom_time rt_ss.is_little_endian = True rt_ss.is_implicit_VR = True return rt_ss
def write_file_meta_info(fp, file_meta, enforce_standard=True): """Write the File Meta Information elements in `file_meta` to `fp`. If `enforce_standard` is True then the file-like `fp` should be positioned past the 128 byte preamble + 4 byte prefix (which should already have been written). DICOM File Meta Information Group Elements ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ From the DICOM standard, Part 10 Section 7.1, any DICOM file shall contain a 128-byte preamble, a 4-byte DICOM prefix 'DICM' and (at a minimum) the following Type 1 DICOM Elements (from Table 7.1-1): * (0002,0000) FileMetaInformationGroupLength, UL, 4 * (0002,0001) FileMetaInformationVersion, OB, 2 * (0002,0002) MediaStorageSOPClassUID, UI, N * (0002,0003) MediaStorageSOPInstanceUID, UI, N * (0002,0010) TransferSyntaxUID, UI, N * (0002,0012) ImplementationClassUID, UI, N If `enforce_standard` is True then (0002,0000) will be added/updated, (0002,0001) and (0002,0012) will be added if not already present and the other required elements will be checked to see if they exist. If `enforce_standard` is False then `file_meta` will be written as is after minimal validation checking. The following Type 3/1C Elements may also be present: * (0002,0013) ImplementationVersionName, SH, N * (0002,0016) SourceApplicationEntityTitle, AE, N * (0002,0017) SendingApplicationEntityTitle, AE, N * (0002,0018) ReceivingApplicationEntityTitle, AE, N * (0002,0100) PrivateInformationCreatorUID, UI, N * (0002,0102) PrivateInformation, OB, N If `enforce_standard` is True then (0002,0013) will be added/updated. Encoding ~~~~~~~~ The encoding of the File Meta Information shall be Explicit VR Little Endian Parameters ---------- fp : file-like The file-like to write the File Meta Information to. file_meta : pydicom.dataset.Dataset The File Meta Information DataElements. enforce_standard : bool If False, then only the File Meta Information elements already in `file_meta` will be written to `fp`. If True (default) then a DICOM Standards conformant File Meta will be written to `fp`. Raises ------ ValueError If `enforce_standard` is True and any of the required File Meta Information elements are missing from `file_meta`, with the exception of (0002,0000), (0002,0001) and (0002,0012). ValueError If any non-Group 2 Elements are present in `file_meta`. """ validate_file_meta(file_meta, enforce_standard) if enforce_standard and 'FileMetaInformationGroupLength' not in file_meta: # Will be updated with the actual length later file_meta.FileMetaInformationGroupLength = 0 # Write the File Meta Information Group elements # first write into a buffer to avoid seeking back, that can be # expansive and is not allowed if writing into a zip file buffer = DicomBytesIO() buffer.is_little_endian = True buffer.is_implicit_VR = False write_dataset(buffer, file_meta) # If FileMetaInformationGroupLength is present it will be the first written # element and we must update its value to the correct length. if 'FileMetaInformationGroupLength' in file_meta: # Update the FileMetaInformationGroupLength value, which is the number # of bytes from the end of the FileMetaInformationGroupLength element # to the end of all the File Meta Information elements. # FileMetaInformationGroupLength has a VR of 'UL' and so has a value # that is 4 bytes fixed. The total length of when encoded as # Explicit VR must therefore be 12 bytes. file_meta.FileMetaInformationGroupLength = buffer.tell() - 12 buffer.seek(0) write_data_element(buffer, file_meta[0x00020000]) fp.write(buffer.getvalue())