dbdicom 0.3.1__tar.gz → 0.3.3__tar.gz

{dbdicom-0.3.1/src/dbdicom.egg-info → dbdicom-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbdicom
-Version: 0.3.1
+Version: 0.3.3
 Summary: A pythonic interface for reading and writing DICOM databases
 Author-email: Steven Sourbron <s.sourbron@sheffield.ac.uk>, Ebony Gunwhy <e.gunwhy@sheffield.ac.uk>
 Project-URL: Homepage, https://openmiblab.github.io/dbdicom/
@@ -22,7 +22,5 @@ Requires-Dist: importlib-resources
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: vreg
-Requires-Dist: pydicom
-Requires-Dist: python-gdcm
-Requires-Dist: pylibjpeg-libjpeg
+Requires-Dist: pydicom[basic,pixeldata]
 Dynamic: license-file

{dbdicom-0.3.1 → dbdicom-0.3.3}/pyproject.toml

@@ -7,16 +7,16 @@ requires = ['setuptools>=61.2']
 
 [project]
 name = "dbdicom"
-version = "0.3.1"
+version = "0.3.3"
 dependencies = [ 
     "tqdm",
     "importlib-resources",
     "numpy",
     "pandas", # make obsolete
     'vreg', 
-    "pydicom", 
-    "python-gdcm",
-    "pylibjpeg-libjpeg",
+    "pydicom[basic,pixeldata]", 
+    #"python-gdcm",
+    #"pylibjpeg-libjpeg",
 ]
 
 # optional information

{dbdicom-0.3.1 → dbdicom-0.3.3}/src/dbdicom/api.py

@@ -1,5 +1,5 @@
+from typing import Union
 
-import numpy as np
 import vreg
 
 from dbdicom.dbd import DataBaseDicom
@@ -16,6 +16,15 @@ def open(path:str) -> DataBaseDicom:
     """
     return DataBaseDicom(path)
 
+def to_json(path):
+    """Summarise the contents of the DICOM folder in a json file
+
+    Args:
+        path (str): path to the DICOM folder
+    """
+    dbd = open(path)
+    dbd.close()   
+
 def print(path):
     """Print the contents of the DICOM folder
 
@@ -42,6 +51,21 @@ def summary(path) -> dict:
     return s
 
 
+def tree(path) -> dict:
+    """Return the structure of the database as a dictionary tree.
+
+    Args:
+        path (str): path to the DICOM folder
+
+    Returns:
+        dict: Nested dictionary with summary information on the database.
+    """
+    dbd = open(path)
+    s = dbd.register
+    dbd.close()
+    return s
+
+
 def patients(path, name:str=None, contains:str=None, isin:list=None)->list:
     """Return a list of patients in the DICOM folder.
 
@@ -167,41 +191,36 @@ def move(from_entity:list, to_entity:list):
     dbd.close()
 
 
-def volume(series:list, dims:list=None, multislice=False) -> vreg.Volume3D:
+def volume(series:list, dims:list=None) -> vreg.Volume3D:
     """Read a vreg.Volume3D from a DICOM series
 
     Args:
         series (list): DICOM series to read
         dims (list, optional): Non-spatial dimensions of the volume. Defaults to None.
-        multislice (bool, optional): Whether the data are to be read 
-            as multislice or not. In multislice data the voxel size 
-            is taken from the slice gap rather thsan the slice thickness. Defaults to False.
 
     Returns:
         vreg.Volume3D: vole read from the series.
     """
+    if isinstance(series, str):
+        series = [series]
     dbd = open(series[0])
-    vol = dbd.volume(series, dims, multislice)
+    vol = dbd.volume(series, dims)
     dbd.close()
     return vol
 
-def write_volume(vol:vreg.Volume3D, series:list, ref:list=None, 
-                 multislice=False):
+def write_volume(vol:Union[vreg.Volume3D, tuple], series:list, ref:list=None):
     """Write a vreg.Volume3D to a DICOM series
 
     Args:
-        vol (vreg.Volume3D): Volume to write to the series.
+        vol (vreg.Volume3D or tuple): Volume to write to the series.
         series (list): DICOM series to read
         dims (list, optional): Non-spatial dimensions of the volume. Defaults to None.
-        multislice (bool, optional): Whether the data are to be read 
-            as multislice or not. In multislice data the voxel size 
-            is taken from the slice gap rather thsan the slice thickness. Defaults to False.
     """
     dbd = open(series[0])
-    dbd.write_volume(vol, series, ref, multislice)
+    dbd.write_volume(vol, series, ref)
     dbd.close()
 
-def to_nifti(series:list, file:str, dims:list=None, multislice=False):
+def to_nifti(series:list, file:str, dims:list=None):
     """Save a DICOM series in nifti format.
 
     Args:
@@ -209,27 +228,21 @@ def to_nifti(series:list, file:str, dims:list=None, multislice=False):
         file (str): file path of the nifti file.
         dims (list, optional): Non-spatial dimensions of the volume. 
             Defaults to None.
-        multislice (bool, optional): Whether the data are to be read 
-            as multislice or not. In multislice data the voxel size 
-            is taken from the slice gap rather thaan the slice thickness. Defaults to False.
     """
     dbd = open(series[0])
-    dbd.to_nifti(series, file, dims, multislice)
+    dbd.to_nifti(series, file, dims)
     dbd.close()
 
-def from_nifti(file:str, series:list, ref:list=None, multislice=False):
+def from_nifti(file:str, series:list, ref:list=None):
     """Create a DICOM series from a nifti file.
 
     Args:
         file (str): file path of the nifti file.
         series (list): DICOM series to create
         ref (list): DICOM series to use as template.
-        multislice (bool, optional): Whether the data are to be written
-            as multislice or not. In multislice data the voxel size 
-            is written in the slice gap rather thaan the slice thickness. Defaults to False.
     """
     dbd = open(series[0])
-    dbd.from_nifti(file, series, ref, multislice)
+    dbd.from_nifti(file, series, ref)
     dbd.close()
 
 def pixel_data(series:list, dims:list=None, include:list=None) -> tuple:
@@ -247,6 +260,8 @@ def pixel_data(series:list, dims:list=None, include:list=None) -> tuple:
             is provide these are returned as a dictionary in a third 
             return value.
     """
+    if isinstance(series, str):
+        series = [series]
     dbd = open(series[0])
     array = dbd.pixel_data(series, dims, include)
     dbd.close()

dbdicom-0.3.3/src/dbdicom/database.py

@@ -0,0 +1,126 @@
+import os
+from tqdm import tqdm
+
+import numpy as np
+import pandas as pd
+import pydicom
+
+import dbdicom.utils.dcm4che as dcm4che
+import dbdicom.utils.files as filetools
+import dbdicom.dataset as dbdataset
+
+
+COLUMNS = [   
+    # Identifiers (unique)
+    'PatientID', 
+    'StudyInstanceUID', 
+    'SeriesInstanceUID', 
+    'SOPInstanceUID', 
+    # Human-readable identifiers (not unique)
+    'PatientName', 
+    'StudyDescription', 
+    'StudyDate', 
+    'StudyID',
+    'SeriesDescription', 
+    'SeriesNumber', 
+    'InstanceNumber', 
+]
+
+def read(path):
+    files = filetools.all_files(path)
+    tags = COLUMNS + ['NumberOfFrames'] # + ['SOPClassUID']
+    array = []
+    dicom_files = []
+    for i, file in tqdm(enumerate(files), total=len(files), desc='Reading DICOM folder'):
+        try:
+            ds = pydicom.dcmread(file, force=True, specific_tags=tags+['Rows'])
+        except:
+            pass
+        else:
+            if isinstance(ds, pydicom.dataset.FileDataset):
+                if 'TransferSyntaxUID' in ds.file_meta:
+                    if not 'Rows' in ds: # Image only
+                        continue
+                    row = dbdataset.get_values(ds, tags)
+                    array.append(row)
+                    index = os.path.relpath(file, path)
+                    dicom_files.append(index) 
+    df = pd.DataFrame(array, index = dicom_files, columns = tags)
+    df = _multiframe_to_singleframe(path, df)
+    dbtree = _tree(df)
+    return dbtree
+
+
+def _multiframe_to_singleframe(path, df):
+    """Converts all multiframe files in the folder into single-frame files.
+    
+    Reads all the multi-frame files in the folder,
+    converts them to singleframe files, and delete the original multiframe file.
+    """
+    singleframe = df.NumberOfFrames.isnull() 
+    multiframe = singleframe == False
+    nr_multiframe = multiframe.sum()
+    if nr_multiframe != 0: 
+        for relpath in tqdm(df[multiframe].index.values, desc="Converting multiframe file " + relpath):
+            filepath = os.path.join(path, relpath)
+            singleframe_files = dcm4che.split_multiframe(filepath) 
+            if singleframe_files != []:            
+                # add the single frame files to the dataframe
+                dfnew = read(singleframe_files, df.columns, path)
+                df = pd.concat([df, dfnew])
+                # delete the original multiframe 
+                os.remove(filepath)
+            # drop the file also if the conversion has failed
+            df.drop(index=relpath, inplace=True)
+    df.drop('NumberOfFrames', axis=1, inplace=True)
+    return df
+
+
+def _tree(df):
+    # A human-readable summary tree
+    # TODO: Add version number
+
+    df.sort_values(['PatientID','StudyInstanceUID','SeriesNumber'], inplace=True)
+    df = df.fillna('None')
+    summary = []
+
+    for uid_patient in df.PatientID.unique():
+        df_patient = df[df.PatientID == uid_patient]
+        patient_name = df_patient.PatientName.values[0]
+        patient = {
+            'PatientName': patient_name,
+            'PatientID': uid_patient,
+            'studies': [],
+        }
+        summary.append(patient)
+        for uid_study in df_patient.StudyInstanceUID.unique():
+            df_study = df_patient[df_patient.StudyInstanceUID == uid_study]
+            study_desc = df_study.StudyDescription.values[0]
+            study_id = df_study.StudyID.values[0]
+            study_date = df_study.StudyDate.values[0]
+            study = {
+                'StudyDescription': study_desc,
+                'StudyDate': study_date,
+                'StudyID': study_id,
+                'StudyInstanceUID': uid_study,
+                'series': [],
+            }
+            patient['studies'].append(study)
+            for uid_sery in df_study.SeriesInstanceUID.unique():
+                df_series = df_study[df_study.SeriesInstanceUID == uid_sery]
+                series_desc = df_series.SeriesDescription.values[0]
+                series_nr = int(df_series.SeriesNumber.values[0])
+                series = {
+                    'SeriesNumber': series_nr,
+                    'SeriesDescription': series_desc,
+                    'SeriesInstanceUID': uid_sery,
+                    'instances': {},
+                }
+                study['series'].append(series)
+                for uid_instance in df_series.SOPInstanceUID.unique():
+                    df_instance = df_series[df_series.SOPInstanceUID == uid_instance]
+                    instance_nr = int(df_instance.InstanceNumber.values[0])
+                    relpath = df_instance.index[0]
+                    series['instances'][instance_nr]=relpath
+
+    return summary

{dbdicom-0.3.1 → dbdicom-0.3.3}/src/dbdicom/dataset.py

@@ -7,13 +7,12 @@ import struct
 from tqdm import tqdm
 
 import numpy as np
-import pandas as pd
 import pydicom
 from pydicom.util.codify import code_file
 import pydicom.config
-from pydicom.dataset import Dataset
 import vreg
 
+
 import dbdicom.utils.image as image
 import dbdicom.utils.variables as variables
 from dbdicom.sop_classes import (
@@ -74,6 +73,8 @@ def new_dataset(sop_class):
         return xray_angiographic_image.default()
     if sop_class == 'UltrasoundMultiFrameImage':
         return ultrasound_multiframe_image.default()
+    if sop_class == 'ParametricMap':
+        return parametric_map.default()
     else:
         raise ValueError(
             f"DICOM class {sop_class} is not currently supported"
@@ -228,7 +229,8 @@ def write(ds, file, status=None):
     dir = os.path.dirname(file)
     if not os.path.exists(dir):
         os.makedirs(dir)
-    ds.save_as(file, write_like_original=False)
+    #ds.save_as(file, write_like_original=False) # deprecated
+    ds.save_as(file, enforce_file_format=True)
 
 
 def codify(source_file, save_file, **kwargs):
@@ -238,7 +240,7 @@ def codify(source_file, save_file, **kwargs):
     file.close()
 
 
-def read_data(files, tags, path=None, images_only=False):
+def read_data(files, tags, path=None, images_only=False): # obsolete??
 
     if np.isscalar(files):
         files = [files]
@@ -266,34 +268,6 @@ def read_data(files, tags, path=None, images_only=False):
 
 
 
-def read_dataframe(files, tags, path=None, images_only=False):
-    if np.isscalar(files):
-        files = [files]
-    if np.isscalar(tags):
-        tags = [tags]
-    array = []
-    dicom_files = []
-    for i, file in tqdm(enumerate(files), desc='Reading DICOM folder'):
-        try:
-            ds = pydicom.dcmread(file, force=True, specific_tags=tags+['Rows'])
-        except:
-            pass
-        else:
-            if isinstance(ds, pydicom.dataset.FileDataset):
-                if 'TransferSyntaxUID' in ds.file_meta:
-                    if images_only:
-                        if not 'Rows' in ds:
-                            continue
-                    row = get_values(ds, tags)
-                    array.append(row)
-                    if path is None:
-                        index = file
-                    else:
-                        index = os.path.relpath(file, path)
-                    dicom_files.append(index) 
-    df = pd.DataFrame(array, index = dicom_files, columns = tags)
-    return df
-
 
 def _add_new(ds, tag, value, VR='OW'):
     if not isinstance(tag, pydicom.tag.BaseTag):
@@ -540,32 +514,24 @@ def set_lut(ds, RGB):
 
 
 
-def affine(ds, multislice=False):
-    if multislice:
-        return image.affine_matrix(
-            get_values(ds, 'ImageOrientationPatient'), 
-            get_values(ds, 'ImagePositionPatient'), 
-            get_values(ds, 'PixelSpacing'), 
-            get_values(ds, 'SpacingBetweenSlices'),
-        )
-    else:
-        return image.affine_matrix(
-            get_values(ds, 'ImageOrientationPatient'), 
-            get_values(ds, 'ImagePositionPatient'), 
-            get_values(ds, 'PixelSpacing'), 
-            get_values(ds, 'SliceThickness'),
-        )
+def affine(ds):
+    # Spacing Between Slices is not required so can be absent
+    slice_spacing = ds.get("SpacingBetweenSlices")
+    if slice_spacing is None:
+        slice_spacing = ds.get("SliceThickness")
+    return image.affine_matrix(
+        get_values(ds, 'ImageOrientationPatient'), 
+        get_values(ds, 'ImagePositionPatient'), 
+        get_values(ds, 'PixelSpacing'), 
+        slice_spacing, 
+    )
 
-
-def set_affine(ds, affine, multislice=False):
+def set_affine(ds, affine):
     if affine is None:
         raise ValueError('The affine cannot be set to an empty value')
     v = image.dismantle_affine_matrix(affine)
     set_values(ds, 'PixelSpacing', v['PixelSpacing'])
-    if multislice:
-        set_values(ds, 'SpacingBetweenSlices', v['SliceThickness'])
-    else:
-        set_values(ds, 'SliceThickness', v['SliceThickness'])
+    set_values(ds, 'SpacingBetweenSlices', v['SpacingBetweenSlices'])
     set_values(ds, 'ImageOrientationPatient', v['ImageOrientationPatient'])
     set_values(ds, 'ImagePositionPatient', v['ImagePositionPatient'])
     set_values(ds, 'SliceLocation', np.dot(v['ImagePositionPatient'], v['slice_cosine']))
@@ -586,7 +552,7 @@ def pixel_data(ds):
     try:
         array = ds.pixel_array
     except:
-        return None
+        raise ValueError("Dataset has no pixel data.")
     array = array.astype(np.float32)
     slope = float(getattr(ds, 'RescaleSlope', 1)) 
     intercept = float(getattr(ds, 'RescaleIntercept', 0)) 
@@ -595,7 +561,7 @@ def pixel_data(ds):
     return np.transpose(array)
 
 
-def set_pixel_data(ds, array, value_range=None):
+def set_pixel_data(ds, array):
     if array is None:
         raise ValueError('The pixel array cannot be set to an empty value.')
     
@@ -611,7 +577,7 @@ def set_pixel_data(ds, array, value_range=None):
     # if array.ndim >= 3: # remove spurious dimensions of 1
     #     array = np.squeeze(array) 
 
-    array = image.clip(array.astype(np.float32), value_range=value_range)
+    array = image.clip(array.astype(np.float32))
     array, slope, intercept = image.scale_to_range(array, ds.BitsAllocated)
     array = np.transpose(array)
 
@@ -629,17 +595,26 @@ def set_pixel_data(ds, array, value_range=None):
     ds.PixelData = array.tobytes()
 
 
-def volume(ds, multislice=False):
-    return vreg.volume(pixel_data(ds), affine(ds, multislice))
+def volume(ds):
+    return vreg.volume(pixel_data(ds), affine(ds))
 
-def set_volume(ds, volume:vreg.Volume3D, multislice=False):
+def set_volume(ds, volume:vreg.Volume3D):
     if volume is None:
         raise ValueError('The volume cannot be set to an empty value.')
+    try:
+        mod = SOPCLASSMODULE[ds.SOPClassUID]
+    except KeyError:
+        raise ValueError(
+            f"DICOM class {ds.SOPClassUID} is not currently supported."
+        )
+    if hasattr(mod, 'set_volume'):
+        return getattr(mod, 'set_volume')(ds, volume)
+    
     image = np.squeeze(volume.values)
     if image.ndim != 2:
         raise ValueError("Can only write 2D images to a dataset.")
     set_pixel_data(ds, image)
-    set_affine(ds, volume.affine, multislice)
+    set_affine(ds, volume.affine)
     if volume.coords is not None:
         # All other dimensions should have size 1
         coords = volume.coords.reshape((volume.coords.shape[0], -1))