dbdicom 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

dbdicom/__init__.py

@@ -1,12 +1,13 @@
 
 from .create import (
     database,
-    database_hollywood,
     patient,
     study,
     series, 
     as_series,
     zeros,
+    ones,
+    empty_series,
 )
 from .record import (
     copy_to, 
@@ -22,5 +23,6 @@ from .types.database import Database
 from .types.patient import Patient
 from .types.study import Study
 from .types.series import Series
-
-from .utils import image
+from .utils import image
+from . import extensions
+from . import dro

dbdicom/create.py

@@ -6,7 +6,7 @@ from dbdicom.manager import Manager
 from dbdicom.types.database import Database
 from dbdicom.types.patient import Patient
 from dbdicom.types.study import Study
-from dbdicom.types.series import Series
+from dbdicom.types.series import Series, _coords_size, _grid_to_coords
 from dbdicom.types.instance import Instance
 
 
@@ -270,6 +270,7 @@ def series(dtype='mri', in_study:Study=None, in_database:Database=None, **kwargs
     else:
         if in_database is None:
             _database = database()
+            _database.mute()
         else:
             _database = in_database
         patient = _database.new_patient()
@@ -281,73 +282,14 @@ def series(dtype='mri', in_study:Study=None, in_database:Database=None, **kwargs
 
 
 
-def database_hollywood()->Database:
-    """Create an empty toy database for demonstration purposes.
 
-    Returns:
-        Database: Database with two patients, two studies per patient and two empty series per study.
-
-    See Also:
-        :func:`~database`
-
-    Example:
-        >>> database = db.database_hollywood()
-        >>> database.print()
-        ---------- DATABASE --------------
-        Location:  In memory
-            Patient James Bond
-                Study MRI [19821201]
-                    Series 001 [Localizer]
-                        Nr of instances: 0
-                    Series 002 [T2w]
-                        Nr of instances: 0
-                Study Xray [19821205]
-                    Series 001 [Chest]
-                        Nr of instances: 0
-                    Series 002 [Head]
-                        Nr of instances: 0
-            Patient Scarface
-                Study MRI [19850105]
-                    Series 001 [Localizer]
-                        Nr of instances: 0
-                    Series 002 [T2w]
-                        Nr of instances: 0
-                Study Xray [19850106]
-                    Series 001 [Chest]
-                        Nr of instances: 0
-                    Series 002 [Head]
-                        Nr of instances: 0
-        ---------------------------------
-    """
-    hollywood = database()
-
-    james_bond = hollywood.new_patient(PatientName='James Bond')
-    james_bond_mri = james_bond.new_study(StudyDescription='MRI', StudyDate='19821201')
-    james_bond_mri_localizer = james_bond_mri.new_series(SeriesDescription='Localizer')
-    james_bond_mri_T2w = james_bond_mri.new_series(SeriesDescription='T2w')
-    james_bond_xray = james_bond.new_study(StudyDescription='Xray', StudyDate='19821205')
-    james_bond_xray_chest = james_bond_xray.new_series(SeriesDescription='Chest')
-    james_bond_xray_head = james_bond_xray.new_series(SeriesDescription='Head')
-
-    scarface = hollywood.new_patient(PatientName='Scarface')
-    scarface_mri = scarface.new_study(StudyDescription='MRI', StudyDate='19850105')
-    scarface_mri_localizer = scarface_mri.new_series(SeriesDescription='Localizer')
-    scarface_mri_T2w = scarface_mri.new_series(SeriesDescription='T2w')
-    scarface_xray = scarface.new_study(StudyDescription='Xray', StudyDate='19850106')
-    scarface_xray_chest = scarface_xray.new_series(SeriesDescription='Chest')
-    scarface_xray_head = scarface_xray.new_series(SeriesDescription='Head')
-
-    return hollywood
-
-
-
-
-def as_series(array:np.ndarray, coords:dict=None, dtype='mri', in_study:Study=None, in_database:Database=None, **kwargs)->Series:
+def as_series(array:np.ndarray, coords:dict=None, gridcoords:dict=None, dtype='mri', in_study:Study=None, in_database:Database=None, **kwargs)->Series:
     """Create a DICOM series from a numpy array.
 
     Args:
         array (np.ndarray): numpy.ndarray with image data
-        coords (dict, optional): Dictionary with coordinate labels and values. For 3- or 4-dimensional arrays this is optional but for arrays with more than 4 dimensions this is required. The coordinate values can be one-dimensions for regularly gridded data, or n-dimensional for irregularly gridded data. 
+        coords (dict, optional): Dictionary with coordinate labels and values. For 3- or 4-dimensional arrays this is optional but for arrays with more than 4 dimensions either *coords* or *gridcoords* are required. 
+        gridcoords (dict, optional): regularly gridded coordinates can also be provided as a coordinate grid.
         dtype (str, optional): The type of the series to create. Defaults to 'mri'.
         in_study (Study, optional): If provided, the series is created in this study. Defaults to None.
         in_database (Database, optional): If provided, the series is created in this database. Defaults to None.
@@ -402,14 +344,39 @@ def as_series(array:np.ndarray, coords:dict=None, dtype='mri', in_study:Study=No
         >>> print(zeros.RepetitionTime)
         [2.5, 5.0]
     """
+    shape = array.shape
+    if coords is None:
+        if gridcoords is None:
+            if len(shape) > 4:
+                msg = 'With more than 4 dimensions, the coords argument is required.'
+                raise ValueError(msg)
+            gridcoords = {}
+            if len(shape) == 2:
+                gridcoords['InstanceNumber'] = np.array([1])
+            if len(shape) > 2:
+                gridcoords['SliceLocation'] = np.arange(shape[2])
+            if len(shape) > 3:
+                gridcoords['AcquisitionTime'] = np.arange(shape[3])
+    if gridcoords is not None:
+        coords = _grid_to_coords(gridcoords)
+    sery = series(dtype=dtype, in_study=in_study, in_database=in_database, **kwargs)
+    sery.expand(coords)
+    sery.set_pixel_values(array, dims=tuple(coords))
+    return sery
+
+
+def empty_series(coords:dict=None, gridcoords:dict=None,  dtype='mri', in_study:Study=None, in_database:Database=None, **kwargs)->Series:
+
+    if gridcoords is not None:
+        coords = _grid_to_coords(gridcoords)
     sery = series(dtype=dtype, in_study=in_study, in_database=in_database, **kwargs)
-    sery.mute()
-    sery.set_array(array, coords=coords, pixels_first=True)
-    sery.unmute()
+    if coords is None:
+        return sery
+    sery.expand(coords)
     return sery
 
 
-def zeros(shape:tuple, coords:dict=None, **kwargs) -> Series:
+def zeros(shape:tuple, coords:dict=None, gridcoords:dict=None, **kwargs) -> Series:
     """Create a DICOM series populated with zeros.
 
     This is a convenience wrapper providing a numpy-like interface for :func:`~as_series`.
@@ -422,8 +389,7 @@ def zeros(shape:tuple, coords:dict=None, **kwargs) -> Series:
         Series: DICOM series with zero values
 
     See Also:
-        :func:`~series`
-        :func:`~as_series`
+        :func:`~ones`
 
     Example:
         Create a series containing a 4-dimensional array of zeros:
@@ -446,5 +412,46 @@ def zeros(shape:tuple, coords:dict=None, **kwargs) -> Series:
         >>> array = np.zeros((128, 128, 2, 3))
         >>> zeros = db.as_series(array)
     """
+
     array = np.zeros(shape, dtype=np.float32)
-    return as_series(array, coords=coords, **kwargs)
+    return as_series(array, coords=coords, gridcoords=gridcoords, **kwargs)
+
+
+def ones(shape:tuple, coords:dict=None, gridcoords:dict=None, **kwargs) -> Series:
+    """Create a DICOM series populated with ones.
+
+    This is a convenience wrapper providing a numpy-like interface for :func:`~as_series`.
+
+    Args:
+        shape (tuple): shape of the array
+        kwargs: see :func:`~series`
+        
+    Returns:
+        Series: DICOM series with values of one.
+
+    See Also:
+        :func:`~zeros`
+
+    Example:
+        Create a series containing a 4-dimensional array of ones:
+
+        >>> zeros = db.ones((128, 128, 2, 3))
+        >>> zeros.print()
+        ---------- SERIES --------------
+        Series 001 [New Series]
+            Nr of instances: 6
+                MRImage 000001
+                MRImage 000002
+                MRImage 000003
+                MRImage 000004
+                MRImage 000005
+                MRImage 000006
+        --------------------------------
+
+        This is effectively shorthand for:
+        
+        >>> array = np.ones((128, 128, 2, 3))
+        >>> zeros = db.as_series(array)
+    """
+    array = np.ones(shape, dtype=np.float32)
+    return as_series(array, coords=coords, gridcoords=gridcoords, **kwargs)

dbdicom/dro.py

@@ -0,0 +1,174 @@
+# Importing annotations to handle or sign in import type hints
+from __future__ import annotations
+
+import numpy as np
+import dbdicom as db
+from dbdicom.types.database import Database
+from dbdicom.types.series import Series
+from dbdicom.utils import image
+
+
+def T1_mapping_vFATR(spacing = (15, 15, 20), fov = (300, 250, 120), T1min = 600, S0min = 100, vFA = [2.0, 20.0], vTR = [5.0,15.0])->Series:
+    """Synthetic T1-mapping data with variable TR and FA
+
+    Args:
+        spacing (tuple, optional): x, y, z pixel spacing in mm. Defaults to (1.5, 1.5, 2.0).
+        fov (tuple, optional): x, y, z field of view in mm. Defaults to (300, 250, 120).
+        T1min (int, optional): smallest T1 in msec. Defaults to 600.
+        S0min (int, optional): smallest S0 in a.u. Defaults to 100.
+        vFA (list, optional): variable flip angle values in degrees. Defaults to [2.0, 5.0, 10.0, 15.0, 20.0].
+        vTR (list, optional): variable repetition time values in msec. Defaults to [2.0, 3.0, 4.0, 5.0, 10.0, 15.0].
+
+    Returns:
+        dbdicom.Series: A series with appropriate array and header data.
+    """
+    ellipsoid = image.ellipsoid(fov[0]/2, fov[1]/2, fov[2]/2, spacing=spacing, levelset=True)
+    ellipsoid = 1 + ellipsoid - np.amin(ellipsoid)
+    T1 = T1min*ellipsoid
+    S0 = S0min*ellipsoid
+    array = np.empty((T1.shape[0], T1.shape[1], T1.shape[2], len(vFA), len(vTR)))
+    for j, TR in enumerate(vTR):
+        Ej = np.exp(-TR/T1)
+        for i, FA in enumerate(vFA):
+            ci = np.cos(FA*np.pi/180)
+            array[:,:,:,i,j] = S0 * (1-Ej) / (1-ci*Ej)
+    
+    coords = {
+        'SliceLocation': spacing[2]*np.arange(array.shape[2]),
+        'FlipAngle': np.array(vFA),
+        'RepetitionTime': np.array(vTR),
+    }
+    v0, v1 = np.amin(array), np.amax(array)
+    series = db.as_series(array, gridcoords=coords, PixelSpacing=[spacing[1],spacing[0]], WindowWidth=v1-v0, WindowCenter=(v0+v1)/2)
+    series.patient().PatientName = 'Ellipsoid'
+    series.study().StudyDescription = 'Synthetic'
+    series.SeriesDescription = 'T1 mapping variable TR and FA'
+
+    return series
+    
+
+def ellipsoid(a, b, c, spacing=(1., 1., 1.), levelset=False)->Series:
+    """
+    Generates ellipsoid with semimajor axes aligned with grid dimensions
+    on grid with specified `spacing`.
+
+    Args:
+        a (float): Length of semimajor axis aligned with x-axis.
+        b (float): Length of semimajor axis aligned with y-axis.
+        c (float): Length of semimajor axis aligned with z-axis.
+        spacing (tuple of floats, length 3): Spacing in (x, y, z) spatial dimensions. Defaults to (1,1,1)
+        levelset (bool): If True, returns the level set for this ellipsoid (signed level set about zero, with positive denoting interior) as np.float64. False returns a binarized version of said level set. Defaults to False.
+    
+    Returns:
+        dbdicom.Series: A series with appropriate array and header data.
+    
+    Note:
+        The interface and the array generation is taken directly from skimage but the core function is copied into dbdicom utilities to avoid bringing in skimage as an essential dependency.
+    """
+    arr = image.ellipsoid(a, b, c, spacing=spacing, levelset=levelset)
+    coords = {'SliceLocation': spacing[2]*np.arange(arr.shape[2])}
+    v0, v1 = np.amin(arr), np.amax(arr)
+    series = db.as_series(arr, gridcoords=coords, PixelSpacing=[spacing[1],spacing[0]], WindowWidth=v1-v0, WindowCenter=(v0+v1)/2)
+    affine = np.array(
+        [[spacing[1], 0., 0., 0.],
+         [0., spacing[0], 0., 0.],
+         [0., 0., spacing[2], 0.],
+         [0., 0., 0., 1.]]
+    )
+    series.set_affine(affine)
+    series.patient().PatientName = 'Ellipsoid'
+    series.study().StudyDescription = 'Synthetic'
+    series.SeriesDescription = 'Levelset ellipsoid'
+    return series
+
+
+def double_ellipsoid(a, b, c, spacing=(1., 1., 1.), levelset=False)->Series:
+    """
+    Generates a double ellipsoid with semimajor axes aligned with grid dimensions
+    on grid with specified `spacing`.
+
+    Args:
+        a (float): Length of semimajor axis aligned with x-axis.
+        b (float): Length of semimajor axis aligned with y-axis.
+        c (float): Length of semimajor axis aligned with z-axis.
+        spacing (tuple of floats, length 3): Spacing in (x, y, z) spatial dimensions. Defaults to (1,1,1)
+        levelset (bool): If True, returns the level set for this ellipsoid (signed level set about zero, with positive denoting interior) as np.float64. False returns a binarized version of said level set. Defaults to False.
+
+    Returns:
+        dbdicom.Series: A series with appropriate array and header data.
+    
+    Note:
+        The interface and the array generation is taken directly from skimage, but the core function is copied into dbdicom utilities to avoid bringing in skimage as an essential dependency.
+    """
+    arr = image.ellipsoid(a, b, c, spacing=spacing, levelset=levelset)
+    coords = {'SliceLocation': spacing[2]*np.arange(arr.shape[2])}
+    arr = np.concatenate((arr[:-1, ...], arr[2:, ...]), axis=0)
+    v0, v1 = np.amin(arr), np.amax(arr)
+    series = db.as_series(arr, gridcoords=coords, PixelSpacing=[spacing[1],spacing[0]], WindowWidth=v1-v0, WindowCenter=(v0+v1)/2)
+    series.patient().PatientName = 'Ellipsoid'
+    series.study().StudyDescription = 'Synthetic'
+    series.SeriesDescription = 'Levelset ellipsoid'
+    return series
+
+
+def database_hollywood()->Database:
+    """Create an empty toy database for demonstration purposes.
+
+    Returns:
+        Database: Database with two patients, two studies per patient and two empty series per study.
+
+    See Also:
+        :func:`~database`
+
+    Example:
+        >>> database = db.dro.database_hollywood()
+        >>> database.print()
+        ---------- DATABASE --------------
+        Location:  In memory
+            Patient James Bond
+                Study MRI [19821201]
+                    Series 001 [Localizer]
+                        Nr of instances: 0
+                    Series 002 [T2w]
+                        Nr of instances: 0
+                Study Xray [19821205]
+                    Series 001 [Chest]
+                        Nr of instances: 0
+                    Series 002 [Head]
+                        Nr of instances: 0
+            Patient Scarface
+                Study MRI [19850105]
+                    Series 001 [Localizer]
+                        Nr of instances: 0
+                    Series 002 [T2w]
+                        Nr of instances: 0
+                Study Xray [19850106]
+                    Series 001 [Chest]
+                        Nr of instances: 0
+                    Series 002 [Head]
+                        Nr of instances: 0
+        ---------------------------------
+    """
+    hollywood = db.database()
+    hollywood.mute()
+
+    james_bond = hollywood.new_patient(PatientName='James Bond')
+    james_bond_mri = james_bond.new_study(StudyDescription='MRI', StudyDate='19821201')
+    james_bond_mri_localizer = james_bond_mri.new_series(SeriesDescription='Localizer')
+    james_bond_mri_T2w = james_bond_mri.new_series(SeriesDescription='T2w')
+    james_bond_xray = james_bond.new_study(StudyDescription='Xray', StudyDate='19821205')
+    james_bond_xray_chest = james_bond_xray.new_series(SeriesDescription='Chest')
+    james_bond_xray_head = james_bond_xray.new_series(SeriesDescription='Head')
+
+    scarface = hollywood.new_patient(PatientName='Scarface')
+    scarface_mri = scarface.new_study(StudyDescription='MRI', StudyDate='19850105')
+    scarface_mri_localizer = scarface_mri.new_series(SeriesDescription='Localizer')
+    scarface_mri_T2w = scarface_mri.new_series(SeriesDescription='T2w')
+    scarface_xray = scarface.new_study(StudyDescription='Xray', StudyDate='19850106')
+    scarface_xray_chest = scarface_xray.new_series(SeriesDescription='Chest')
+    scarface_xray_head = scarface_xray.new_series(SeriesDescription='Head')
+
+    return hollywood
+
+if __name__ == '__main__':
+    T1_mapping_vFATR()

dbdicom/ds/dataset.py

@@ -306,9 +306,21 @@ def set_values(ds, tags, values, VR=None):
                     ds[tag].value = format_value(values[i], tag=tag)
                 else:
                     _add_new(ds, tag, values[i], VR=VR[i])
+
+        #_set_derived_data_element(ds, tag, values[i])
+                
     return ds
 
 
+# def _set_derived_data_element(ds, tag, value):
+#     """Set any tags that are need to change as well"""
+
+#     if tag == 'SliceLocation' or tag == (0x0020, 0x1041):
+#         if value is not None: 
+#             loc = ds['ImageOrientationPatient'].value
+#             ds['ImagePositionPatient'].value = image.image_position_from_slice_location(value, loc)
+
+
 def _add_new(ds, tag, value, VR='OW'):
     if not isinstance(tag, pydicom.tag.BaseTag):
         tag = pydicom.tag.Tag(tag)
@@ -324,10 +336,15 @@ def _add_new(ds, tag, value, VR='OW'):
         ds.add_new(tag, value_repr, format_value(value, value_repr))
     else:
         if (tag.group, 0x0010) not in ds:
-            ds.private_block(tag.group, 'Wezel ' + str(tag.group), create=True)
+            ds.private_block(tag.group, 'dbdicom ' + str(tag.group), create=True)
         ds.add_new(tag, VR, format_value(value, VR))
 
 
+
+
+
+
+
 def get_values(ds, tags):
     """Return a list of values for a dataset"""
 
@@ -347,12 +364,20 @@ def get_values(ds, tags):
                     value = getattr(ds, 'get_attribute_' + tag)()
             else:
                 pydcm_value = ds[tag].value
-                value = to_set_type(pydcm_value, pydicom.datadict.dictionary_VR(tag)) # ELIMINATE THIS STEP - return pydicom datatypes
+                try:
+                    VR = pydicom.datadict.dictionary_VR(tag)
+                except:
+                    VR = None
+                value = to_set_type(pydcm_value, VR) # ELIMINATE THIS STEP - return pydicom datatypes
 
         # If the tag is a tuple of hexadecimal values
         else: 
             if tag in ds:
-                value = to_set_type(ds[tag].value, pydicom.datadict.dictionary_VR(tag))
+                try:
+                    VR = pydicom.datadict.dictionary_VR(tag)
+                except:
+                    VR = None
+                value = to_set_type(ds[tag].value, VR)
 
         # If a tag is not present in the dataset, check if it can be derived
         if value is None:
@@ -374,6 +399,7 @@ def derive_data_element(ds, tag):
     # To be extended ad hoc with other tags that can be derived
 
 
+
 def format_value(value, VR=None, tag=None):
 
     # If the change below is made (TM, DA, DT) then this needs to 
@@ -459,6 +485,7 @@ def set_affine_matrix(ds, affine):
     set_values(ds, 'SliceThickness', 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']))
 
 
 def map_mask_to(ds_source, ds_target):

dbdicom/ds/types/mr_image.py

@@ -126,11 +126,11 @@ def rider(ds): # required only - check
     ds.SeriesNumber = '14'
     ds.AcquisitionNumber = '1'
     ds.InstanceNumber = '1'
-    ds.ImagePositionPatient = [75.561665058136, -163.6216506958, 118.50172901154]
-    ds.ImageOrientationPatient = [0, 1, 0, 0, 0, -1]
+    ds.ImagePositionPatient = [0, 0, 0]
+    ds.ImageOrientationPatient = [1, 0, 0, 0, 1, 0]
     ds.FrameOfReferenceUID = '1.3.6.1.4.1.9328.50.16.22344679587635360510174487884943834158'
     ds.PositionReferenceIndicator = ''
-    ds.SliceLocation = '75.561665058136'
+    ds.SliceLocation = '0.0'
     ds.SamplesPerPixel = 1
     ds.PhotometricInterpretation = 'MONOCHROME2'
     ds.Rows = 64
@@ -156,7 +156,8 @@ def rider(ds): # required only - check
     ds.RequestAttributesSequence = Sequence()
     ds.RequestedProcedureID = '5133240'
     ds.StorageMediaFileSetUID = '1.3.6.1.4.1.9328.50.16.162890465625511526068665093825399871205'
-    ds.PixelData = np.arange(ds.Rows*ds.Columns, dtype=np.uint16)*ds.LargestImagePixelValue/(ds.Rows*ds.Columns)
+    pixel_values = np.arange(ds.Rows*ds.Columns)*ds.LargestImagePixelValue/(ds.Rows*ds.Columns)
+    ds.PixelData = pixel_values.astype(np.uint16).tobytes()
 
     return ds
 
@@ -190,15 +191,25 @@ def set_pixel_array(ds, array):
         del ds[0x2005, 0x100E]  # Delete 'Philips Rescale Slope'
     if (0x2005, 0x100D) in ds: 
         del ds[0x2005, 0x100D]
-    
+
     # clipping may slow down a lot
     array = image.clip(array.astype(np.float32))
     array, slope, intercept = image.scale_to_range(array, ds.BitsAllocated)
     array = np.transpose(array)
 
     ds.PixelRepresentation = 0
-    ds.set_values('SmallestImagePixelValue', int(0))
-    ds.set_values('LargestImagePixelValue', int(2**ds.BitsAllocated - 1))
+
+    # Does this need setting? Optional and should not be used like this anyway.
+    # Prob
+    # 11 june 2016: commented this out it produced busg in some cases due to US vs SS confusion
+    # vr = ds.data_element('SmallestImagePixelValue').VR 
+    # if vr =='US':
+    #     ds.set_values('SmallestImagePixelValue', int(0))
+    #     ds.set_values('LargestImagePixelValue', int(2**ds.BitsAllocated - 1))
+    # else:
+    #     ds.set_values('SmallestImagePixelValue', int(-2**(ds.BitsAllocated - 1)))
+    #     ds.set_values('LargestImagePixelValue', int(2**(ds.BitsAllocated - 1)-1))
+
     ds.RescaleSlope = 1 / slope
     ds.RescaleIntercept = - intercept / slope
 #        ds.WindowCenter = (maximum + minimum) / 2

dbdicom/extensions/__init__.py

@@ -0,0 +1,10 @@
+from . import (
+    dipy,
+    elastix,
+    numpy,
+    scipy, 
+    skimage,
+    sklearn,
+    vreg,
+    matplotlib,
+)