dbdicom 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

dbdicom/api.py

@@ -4,8 +4,7 @@ import zipfile
 from pathlib import Path
 from typing import Union
 from tqdm import tqdm
-
-
+import numpy as np
 import vreg
 
 from dbdicom.dbd import DataBaseDicom
@@ -164,16 +163,22 @@ def series(entity:str | list, desc:str=None, contains:str=None, isin:list=None)-
             "To retrieve a series, the entity must be a database, patient or study."
         )
     
-def copy(from_entity:list, to_entity:list):
-    """Copy a DICOM entity (patient, study or series)
+def copy(from_entity:list, to_entity=None):
+    """Copy a DICOM  entity (patient, study or series)
 
     Args:
         from_entity (list): entity to copy
-        to_entity (list): entity after copying.
+        to_entity (list, optional): entity after copying. If this is not 
+            provided, a copy will be made in the same study and returned.
+
+    Returns:
+        entity: the copied entity. If th to_entity is provided, this is 
+        returned.
     """
     dbd = open(from_entity[0])
-    dbd.copy(from_entity, to_entity)
+    from_entity_copy = dbd.copy(from_entity, to_entity)
     dbd.close()
+    return from_entity_copy
 
 
 def delete(entity:list):
@@ -216,25 +221,42 @@ def split_series(series:list, attr:Union[str, tuple], key=None)->list:
     return split_series
 
 
-def volume(entity:Union[list, str], dims:list=None, verbose=1) -> Union[vreg.Volume3D, list]:
-    """Read volume or volumes.
+def volume(series:list, dims:list=None, verbose=1) -> vreg.Volume3D:
+    """Read volume from a series.
 
     Args:
-        entity (list, str): DICOM entity to read
+        series (list, str): DICOM entity to read
         dims (list, optional): Non-spatial dimensions of the volume. Defaults to None.
         verbose (bool, optional): If set to 1, shows progress bar. Defaults to 1.
 
     Returns:
-        vreg.Volume3D | list: If the entity is a series this returns 
-        a volume, else a list of volumes.
+        vreg.Volume3D.
     """
-    if isinstance(entity, str):
-        entity = [entity]
-    dbd = open(entity[0])
-    vol = dbd.volume(entity, dims, verbose)
+    dbd = open(series[0])
+    vol = dbd.volume(series, dims, verbose)
     dbd.close()
     return vol
 
+
+def values(series:list, *attr, dims:list=None, verbose=1) -> Union[np.ndarray, list]:
+    """Read the values of some attributes from a DICOM series
+
+    Args:
+        series (list): DICOM series to read. 
+        attr (tuple, optional): DICOM attributes to read.
+        dims (list, optional): Dimensions to sort the values. 
+            If dims is not provided, values are sorted by 
+            InstanceNumber.
+
+    Returns:
+        tuple: arrays with values for the attributes.
+    """
+    dbd = open(series[0])
+    values = dbd.values(series, *attr, dims=dims, verbose=verbose)
+    dbd.close()
+    return values
+
+
 def write_volume(vol:Union[vreg.Volume3D, tuple], series:list, ref:list=None):
     """Write a vreg.Volume3D to a DICOM series
 
@@ -247,6 +269,25 @@ def write_volume(vol:Union[vreg.Volume3D, tuple], series:list, ref:list=None):
     dbd.write_volume(vol, series, ref)
     dbd.close()
 
+
+def edit(series:list, new_values:dict, dims:list=None, verbose=1):
+    """Edit attribute values in a DICOM series
+
+    Warning: this function edits all values as requested. Please take care 
+    when editing attributes that affect the DICOM file organisation, such as 
+    UIDs, as this could corrupt the database.
+
+    Args:
+        series (list): DICOM series to edit
+        new_values (dict): dictionary with attribute: value pairs to write to the series
+        dims (list, optional): Non-spatial dimensions of the volume. Defaults to None.
+        verbose (bool, optional): If set to 1, shows progress bar. Defaults to 1.
+        
+    """
+    dbd = open(series[0])
+    dbd.edit(series, new_values, dims=dims, verbose=verbose)
+    dbd.close()
+
 def to_nifti(series:list, file:str, dims:list=None, verbose=1):
     """Save a DICOM series in nifti format.
 
@@ -274,35 +315,6 @@ def from_nifti(file:str, series:list, ref:list=None):
     dbd.close()
 
 
-def values(series:list, attr=None, dims:list=None, coords=False) -> Union[dict, tuple]:
-    """Read the values of some or all attributes from a DICOM series
-
-    Args:
-        series (list or str): DICOM series to read. This can also 
-            be a path to a folder containing DICOM files, or a 
-            patient or study to read all series in that patient or 
-            study. In those cases a list is returned.
-        attr (list, optional): list of DICOM attributes to read.
-        dims (list, optional): Dimensions to sort the attributes. 
-            If dims is not provided, values are sorted by 
-            InstanceNumber.
-        coords (bool): If set to True, the coordinates of the 
-            attributes are returned alongside the values
-
-    Returns:
-        dict or tuple: values as a dictionary in the last 
-            return value, where each value is a numpy array with 
-            the required dimensions. If coords is set to True, 
-            these are returned too.
-    """
-    if isinstance(series, str):
-        series = [series]
-    dbd = open(series[0])
-    array = dbd.values(series, attr, dims, coords)
-    dbd.close()
-    return array
-
-
 def files(entity:list) -> list:
     """Read the files in a DICOM entity
 

dbdicom/dataset.py

@@ -370,7 +370,7 @@ def set_volume(ds, volume:vreg.Volume3D):
     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))
+        coords = [c.reshape(-1) for c in volume.coords]
         for i, d in enumerate(volume.dims):
             if not is_valid_dicom_tag(d):
                 raise ValueError(
@@ -380,7 +380,7 @@ def set_volume(ds, volume:vreg.Volume3D):
                     "tags to change the dimensions."
                 )
             else:
-                set_values(ds, d, coords[i,0])
+                set_values(ds, d, coords[i][0])
 
 
 

dbdicom/dbd.py

@@ -1,8 +1,10 @@
 import os
+import shutil
 import json
 from typing import Union
 import zipfile
 import re
+from copy import deepcopy
 
 from tqdm import tqdm
 import numpy as np
@@ -76,14 +78,16 @@ class DataBaseDicom():
         Args:
             entity (list): entity to delete
         """
+        # delete datasets on disk
         removed = register.index(self.register, entity)
-        # delete datasets marked for removal
         for index in removed:
             file = os.path.join(self.path, index)
             if os.path.exists(file): 
                 os.remove(file)
-        # and drop then from the register
-        self.register = register.drop(self.register, removed)
+        # drop the entity from the register
+        register.remove(self.register, entity)
+        # cleanup empty folders
+        remove_empty_folders(entity[0])
         return self
     
 
@@ -206,22 +210,22 @@ class DataBaseDicom():
             return register.series(self.register, entity, desc, contains, isin)
 
 
-    def volume(self, entity:Union[list, str], dims:list=None, verbose=1) -> Union[vreg.Volume3D, list]:
-        """Read volume or volumes.
+    def volume(self, entity:Union[list, str], dims:list=None, verbose=1) -> vreg.Volume3D:
+        """Read volume.
 
         Args:
-            entity (list, str): DICOM entity to read
+            entity (list, str): DICOM series to read
             dims (list, optional): Non-spatial dimensions of the volume. Defaults to None.
             verbose (bool, optional): If set to 1, shows progress bar. Defaults to 1.
 
         Returns:
-            vreg.Volume3D | list: If the entity is a series this returns 
-            a volume, else a list of volumes.
+            vreg.Volume3D:
         """
-        if isinstance(entity, str): # path to folder
-            return [self.volume(s, dims) for s in self.series(entity)]
-        if len(entity) < 4: # folder, patient or study
-            return [self.volume(s, dims) for s in self.series(entity)]
+        # if isinstance(entity, str): # path to folder
+        #     return [self.volume(s, dims) for s in self.series(entity)]
+        # if len(entity) < 4: # folder, patient or study
+        #     return [self.volume(s, dims) for s in self.series(entity)]
+        
         if dims is None:
             dims = []
         elif isinstance(dims, str):
@@ -230,33 +234,39 @@ class DataBaseDicom():
             dims = list(dims)
         dims = ['SliceLocation'] + dims
 
-        files = register.files(self.register, entity)
-        
         # Read dicom files
-        values = []
+        values = [[] for _ in dims]
         volumes = []
+
+        files = register.files(self.register, entity)
         for f in tqdm(files, desc='Reading volume..', disable=(verbose==0)):
             ds = pydicom.dcmread(f)
-            values.append(get_values(ds, dims))
+            values_f = get_values(ds, dims)
+            for d in range(len(dims)):
+                values[d].append(values_f[d])
             volumes.append(dbdataset.volume(ds))
 
-        # Format as mesh
-        # coords = np.stack(values, axis=-1, dtype=object) 
-        values = [np.array(v, dtype=object) for v in values] # object array to allow for mixed types
-        coords = np.stack(values, axis=-1)
+        # Format coordinates as mesh
+        coords = [np.array(v) for v in values]
         coords, inds = dbdicom.utils.arrays.meshvals(coords)
-        vols = np.array(volumes)
-        vols = vols[inds].reshape(coords.shape[1:])
 
         # Check that all slices have the same coordinates
-        c0 = coords[1:,0,...]
-        for k in range(coords.shape[1]-1):
-            if not np.array_equal(coords[1:,k+1,...], c0):
-                raise ValueError(
-                    "Cannot build a single volume. Not all slices "
-                    "have the same coordinates."     
-                )
-            
+        if len(dims) > 1:
+            # Loop over all coordinates after slice location
+            for c in coords[1:]:
+                # Loop over all slice locations
+                for k in range(1, c.shape[0]):
+                    # Coordinate c of slice k
+                    if not np.array_equal(c[k,...], c[0,...]):
+                        raise ValueError(
+                            "Cannot build a single volume. Not all slices "
+                            "have the same coordinates."     
+                        )
+
+        # Build volumes
+        vols = np.array(volumes)
+        vols = vols[inds].reshape(coords[0].shape)
+
         # Infer spacing between slices from slice locations
         # Technically only necessary if SpacingBetweenSlices not set or incorrect
         vols = infer_slice_spacing(vols)
@@ -272,11 +282,66 @@ class DataBaseDicom():
                 # Then try again
             vol = vreg.join(vols)
         if vol.ndim > 3:
+            # Coordinates of slice 0
+            c0 = [c[0,...] for c in coords[1:]]
             vol.set_coords(c0)
             vol.set_dims(dims[1:])
         return vol
 
-    
+
+    def values(self, series:list, *attr, dims:list=None, verbose=1) -> Union[dict, tuple]:
+        """Read the values of some attributes from a DICOM series
+
+        Args:
+            series (list): DICOM series to read. 
+            attr (tuple, optional): DICOM attributes to read.
+            dims (list, optional): Non-spatial dimensions of the volume. Defaults to None.
+            verbose (bool, optional): If set to 1, shows progress bar. Defaults to 1.
+
+        Returns:
+            tuple: arrays with values for the attributes.
+        """
+        # if isinstance(series, str): # path to folder
+        #     return [self.values(s, attr, dims) for s in self.series(series)]
+        # if len(series) < 4: # folder, patient or study
+        #     return [self.values(s, attr, dims) for s in self.series(series)]
+
+        if dims is None:
+            dims = ['InstanceNumber']
+        elif np.isscalar(dims):
+            dims = [dims]
+        else:
+            dims = list(dims)
+            
+        # Read dicom files
+        coord_values = [[] for _ in dims]
+        attr_values = [[] for _ in attr]
+
+        files = register.files(self.register, series)
+        for f in tqdm(files, desc='Reading values..', disable=(verbose==0)):
+            ds = pydicom.dcmread(f)
+            coord_values_f = get_values(ds, dims)
+            for d in range(len(dims)):
+                coord_values[d].append(coord_values_f[d])
+            attr_values_f = get_values(ds, attr)
+            for a in range(len(attr)):
+                attr_values[a].append(attr_values_f[a])
+
+        # Format coordinates as mesh
+        coords = [np.array(v) for v in coord_values]
+        coords, inds = dbdicom.utils.arrays.meshvals(coords)
+
+        # Sort values accordingly
+        values = [np.array(v) for v in attr_values]
+        values = [v[inds].reshape(coords[0].shape) for v in values]
+
+        # Return values
+        if len(values) == 1:
+            return values[0]
+        else:
+            return tuple(values)
+
+
     def write_volume(
             self, vol:Union[vreg.Volume3D, tuple], series:list, 
             ref:list=None, 
@@ -288,6 +353,10 @@ class DataBaseDicom():
             series (list): DICOM series to read
             ref (list): Reference series
         """
+        series_full_name = full_name(series)
+        if series_full_name in self.series():
+            raise ValueError(f"Series {series_full_name[-1]} already exists in study {series_full_name[-2]}.")
+
         if isinstance(vol, tuple):
             vol = vreg.volume(vol[0], vol[1])
         if ref is None:
@@ -318,11 +387,85 @@ class DataBaseDicom():
                 slices = vt.split()
                 for sl in slices:
                     dbdataset.set_volume(ds, sl)
-                    sl_coords = [sl.coords[i,...].ravel()[0] for i in range(len(sl.dims))]
+                    sl_coords = [c.ravel()[0] for c in sl.coords]
                     set_value(ds, sl.dims, sl_coords)
                     self._write_dataset(ds, attr, n + 1 + i)
                     i+=1
         return self
+    
+
+    def edit(
+            self, series:list, new_values:dict, dims:list=None, verbose=1,
+        ):
+        """Edit attribute values in a new DICOM series
+
+        Args:
+            series (list): DICOM series to edit
+            new_values (dict): dictionary with attribute: value pairs to write to the series
+            dims (list, optional): Non-spatial dimensions of the volume. Defaults to None.
+            verbose (bool, optional): If set to 1, shows progress bar. Defaults to 1.
+        """
+
+        if dims is None:
+            dims = ['InstanceNumber']
+        elif np.isscalar(dims):
+            dims = [dims]
+        else:
+            dims = list(dims)
+            
+        # Check that all values have the correct nr of elements
+        files = register.files(self.register, series)
+        for a in new_values.values():
+            if np.isscalar(a):
+                pass
+            elif np.array(a).size != len(files):
+                raise ValueError(
+                    f"Incorrect value lengths. All values need to have {len(files)} elements"
+                )
+
+        # Read dicom files to sort them
+        coord_values = [[] for _ in dims]
+        for f in tqdm(files, desc='Sorting series..', disable=(verbose==0)):
+            ds = pydicom.dcmread(f)
+            coord_values_f = get_values(ds, dims)
+            for d in range(len(dims)):
+                coord_values[d].append(coord_values_f[d])
+
+        # Format coordinates as mesh
+        coords = [np.array(v) for v in coord_values]
+        coords, inds = dbdicom.utils.arrays.meshvals(coords)
+
+        # Sort files accordingly
+        files = np.array(files)[inds]
+
+        # Now edit and write the files
+        attr = self._series_attributes(series)
+        n = self._max_instance_number(attr['SeriesInstanceUID'])
+
+        # Drop existing attributes if they are edited
+        attr = {a:attr[a] for a in attr if a not in new_values}
+
+        # List instances to be edited
+        to_drop = register.index(self.register, series)
+         
+        # Write the instances
+        tags = list(new_values.keys())
+        for i, f in tqdm(enumerate(files), desc='Writing values..', disable=(verbose==0)):
+            ds = pydicom.dcmread(f)
+            values = []
+            for a in new_values.values():
+                if np.isscalar(a):
+                    values.append(a)
+                else:
+                    values.append(np.array(a).reshape(-1)[i])
+            set_values(ds, tags, values)
+            self._write_dataset(ds, attr, n + 1 + i)
+
+        # Delete the originals files
+        register.drop(self.register, to_drop)
+        [os.remove(os.path.join(self.path, idx)) for idx in to_drop]
+
+        return self
 
 
     def to_nifti(self, series:list, file:str, dims=None, verbose=1):
@@ -456,103 +599,7 @@ class DataBaseDicom():
             return arrays, values_return
         
 
-    def values(self, series:list, attr=None, dims:list=None, coords=False) -> Union[dict, tuple]:
-        """Read the values of some or all attributes from a DICOM series
 
-        Args:
-            series (list or str): DICOM series to read. This can also 
-                be a path to a folder containing DICOM files, or a 
-                patient or study to read all series in that patient or 
-                study. In those cases a list is returned.
-            attr (list, optional): list of DICOM attributes to read.
-            dims (list, optional): Dimensions to sort the attributes. 
-                If dims is not provided, values are sorted by 
-                InstanceNumber.
-            coords (bool): If set to True, the coordinates of the 
-                attributes are returned alongside the values
-
-        Returns:
-            dict or tuple: values as a dictionary in the last 
-                return value, where each value is a numpy array with 
-                the required dimensions. If coords is set to True, 
-                these are returned too.
-        """
-        if isinstance(series, str): # path to folder
-            return [self.values(s, attr, dims, coords) for s in self.series(series)]
-        if len(series) < 4: # folder, patient or study
-            return [self.values(s, attr, dims, coords) for s in self.series(series)]
-
-        if dims is None:
-            dims = ['InstanceNumber']
-        elif np.isscalar(dims):
-            dims = [dims]
-        else:
-            dims = list(dims)
-
-        files = register.files(self.register, series)
-
-        # Ensure return_vals is a list
-        if attr is None:
-            # If attributes are not provided, read all 
-            # attributes from the first file
-            ds = pydicom.dcmread(files[0])
-            exclude = ['PixelData', 'FloatPixelData', 'DoubleFloatPixelData']
-            params = []
-            param_labels = []
-            for elem in ds:
-                if elem.keyword not in exclude:
-                    params.append(elem.tag)
-                    # For known tags use the keyword as label
-                    label = elem.tag if len(elem.keyword)==0 else elem.keyword
-                    param_labels.append(label)
-        elif np.isscalar(attr):
-            params = [attr]
-            param_labels = params[:]
-        else:
-            params = list(attr)
-            param_labels = params[:]
-
-        # Read dicom files
-        coords_array = []
-        values = np.empty(len(files), dtype=dict)
-        for i, f in tqdm(enumerate(files), desc='Reading values..'):
-            ds = pydicom.dcmread(f)  
-            coords_array.append(get_values(ds, dims))
-            # save as dict so numpy does not stack as arrays
-            values[i] = {'values': get_values(ds, params)}
-
-        # Format as mesh
-        coords_array = np.stack([v for v in coords_array], axis=-1)
-        coords_array, inds = dbdicom.utils.arrays.meshvals(coords_array)
-
-        # Sort values accordingly
-        values = values[inds].reshape(-1)
-
-        # Return values as a dictionary
-        values_dict = {}
-        for p in range(len(params)):
-            # Get the type from the first value
-            vp0 = values[0]['values'][p]
-            # Build an array of the right type
-            vp = np.zeros(values.size, dtype=type(vp0))
-            # Populate the arrate with values for parameter p
-            for i, v in enumerate(values):
-                vp[i] = v['values'][p]
-            # Reshape values for parameter p
-            vp = vp.reshape(coords_array.shape[1:])
-            # Eneter in the dictionary
-            values_dict[param_labels[p]] = vp
-
-        # If only one, return as value
-        if len(params) == 1:
-            values_return = values_dict[params[0]]
-        else:
-            values_return = values_dict
-
-        if coords:
-            return values_return, coords_array
-        else:
-            return values_return
         
 
     def files(self, entity:list) -> list:
@@ -622,34 +669,66 @@ class DataBaseDicom():
         else:
             return {p: values[i] for i, p in enumerate(pars)} 
     
-    def copy(self, from_entity, to_entity):
+    def copy(self, from_entity, to_entity=None):
         """Copy a DICOM  entity (patient, study or series)
 
         Args:
             from_entity (list): entity to copy
-            to_entity (list): entity after copying.
+            to_entity (list, optional): entity after copying. If this is not 
+                provided, a copy will be made in the same study and returned
+
+        Returns:
+            entity: the copied entity. If th to_entity is provided, this is 
+            returned.
         """
         if len(from_entity) == 4:
+            if to_entity is None:
+                to_entity = deepcopy(from_entity)
+                if isinstance(to_entity[-1], tuple):
+                    to_entity[-1] = (to_entity[-1][0] + '_copy', 0)
+                else:
+                    to_entity[-1] = (to_entity[-1] + '_copy', 0)
+                while to_entity in self.series():
+                    to_entity[-1][1] += 1
             if len(to_entity) != 4:
                 raise ValueError(
                     f"Cannot copy series {from_entity} to series {to_entity}. "
                     f"{to_entity} is not a series (needs 4 elements)."
                 )
-            return self._copy_series(from_entity, to_entity)
+            self._copy_series(from_entity, to_entity)
+            return to_entity
+        
         if len(from_entity) == 3:
+            if to_entity is None:
+                to_entity = deepcopy(from_entity)
+                if isinstance(to_entity[-1], tuple):
+                    to_entity[-1] = (to_entity[-1][0] + '_copy', 0)
+                else:
+                    to_entity[-1] = (to_entity[-1] + '_copy', 0)
+                while to_entity in self.studies():
+                    to_entity[-1][1] += 1
             if len(to_entity) != 3:
                 raise ValueError(
                     f"Cannot copy study {from_entity} to study {to_entity}. "
                     f"{to_entity} is not a study (needs 3 elements)."
                 )
-            return self._copy_study(from_entity, to_entity)
+            self._copy_study(from_entity, to_entity)
+            return to_entity
+        
         if len(from_entity) == 2:
+            if to_entity is None:
+                to_entity = deepcopy(from_entity)
+                to_entity[-1] += '_copy'
+                while to_entity in self.patients():
+                    to_entity[-1] += '_copy'
             if len(to_entity) != 2:
                 raise ValueError(
                     f"Cannot copy patient {from_entity} to patient {to_entity}. "
                     f"{to_entity} is not a patient (needs 2 elements)."
                 )                
-            return self._copy_patient(from_entity, to_entity)
+            self._copy_patient(from_entity, to_entity)
+            return to_entity
+        
         raise ValueError(
             f"Cannot copy {from_entity} to {to_entity}. "
         )
@@ -930,6 +1009,28 @@ class DataBaseDicom():
 
 
 
+def full_name(entity):
+
+    if len(entity)==3: # study
+        if isinstance(entity[-1], tuple):
+            return entity
+        else:
+            full_name_study = deepcopy(entity)
+            full_name_study[-1] = (full_name_study[-1], 0)
+            return full_name_study
+        
+    elif len(entity)==4: # series
+        full_name_study = full_name(entity[:3])
+        series = full_name_study + [entity[-1]]
+        if isinstance(series[-1], tuple):
+            return series
+        else:
+            full_name_series = deepcopy(series)
+            full_name_series[-1] = (full_name_series[-1], 0)
+            return full_name_series
+    else:
+        return entity
+
 
 def clean_folder_name(name, replacement="", max_length=255):
     # Strip leading/trailing whitespace
@@ -954,6 +1055,30 @@ def clean_folder_name(name, replacement="", max_length=255):
 
 
 
+def remove_empty_folders(path):
+    """
+    Removes all empty subfolders from a given directory.
+
+    This function walks through the directory tree from the bottom up.
+    This is crucial because it allows child directories to be removed before
+    their parents, potentially making the parent directory empty and
+    eligible for removal in the same pass.
+
+    Args:
+        path (str): The absolute or relative path to the directory to scan.
+    """
+    # Walk the directory tree in a bottom-up manner (topdown=False)
+    for dirpath, dirnames, filenames in os.walk(path, topdown=False):
+        # A directory is considered empty if it has no subdirectories and no files
+        if not dirnames and not filenames:
+            try:
+                shutil.rmtree(dirpath)
+            except OSError as e:
+                # This might happen due to permissions issues
+                print(f"Error removing {dirpath}: {e}")
+
+
+
 def infer_slice_spacing(vols):
     # In case spacing between slices is not (correctly) encoded in 
     # DICOM it can be inferred from the slice locations.
@@ -1010,3 +1135,4 @@ def infer_slice_spacing(vols):
 
 
 
+

dbdicom/register.py

@@ -96,6 +96,27 @@ def index(dbtree, entity):
                     if sr['SeriesInstanceUID'] == series_uid:
                         return list(sr['instances'].values())
                     
+def remove(dbtree, entity):
+    if len(entity)==2:
+        patient_id = entity[1]
+        for pt in sorted(dbtree, key=lambda pt: pt['PatientID']):
+            if pt['PatientID'] == patient_id:
+                dbtree.remove(pt)
+    elif len(entity)==3:
+        study_uid = uid(dbtree, entity)
+        for pt in sorted(dbtree, key=lambda pt: pt['PatientID']):
+            for st in sorted(pt['studies'], key=lambda st: st['StudyInstanceUID']):
+                if st['StudyInstanceUID'] == study_uid:
+                    pt['studies'].remove(st)
+    elif len(entity)==4:
+        series_uid = uid(dbtree, entity)
+        for pt in sorted(dbtree, key=lambda pt: pt['PatientID']):
+            for st in sorted(pt['studies'], key=lambda st: st['StudyInstanceUID']):
+                for sr in sorted(st['series'], key=lambda sr: sr['SeriesNumber']):
+                    if sr['SeriesInstanceUID'] == series_uid:
+                        st['series'].remove(sr)
+    return dbtree
+                    
 
 def drop(dbtree, relpaths):
     for pt in sorted(dbtree[:], key=lambda pt: pt['PatientID']):

dbdicom/sop_classes/enhanced_mr_image.py

@@ -110,7 +110,7 @@ def from_volume(vol:vreg.Volume3D):
 
         # Assign parameters using dims as DICOM keywords
         for ax_i, axis in enumerate(vol.dims):
-            val = vol.coords[(ax_i,) + tuple(indices)]
+            val = vol.coords[ax_i][indices]
 
             sequence, attr = axis.split("/")
             if not hasattr(frame_ds, sequence):

dbdicom/utils/arrays.py

@@ -1,40 +1,128 @@
 import numpy as np
 
+from typing import List, Tuple
 
-def meshvals(coords):
-    # Input array shape: (d, f) with d = nr of dims and f = nr of frames
-    # Output array shape: (d, f1,..., fd)
-    if coords.size == 0:
-        return np.array([])
-    # Sort by column
-    sorted_indices = np.lexsort(coords[::-1])
-    sorted_array = coords[:, sorted_indices]
-    # Find shape
-    shape = _mesh_shape(sorted_array)  
-    # Reshape
-    mesh_array = sorted_array.reshape(shape)
-    return mesh_array, sorted_indices
-
-
-def _mesh_shape(sorted_array):
-    
-    nd = np.unique(sorted_array[0,:]).size
-    shape = (sorted_array.shape[0], nd)
-
-    for dim in range(1,shape[0]):
-        shape_dim = (shape[0], np.prod(shape[1:]), -1)
-        sorted_array = sorted_array.reshape(shape_dim)
-        nd = [np.unique(sorted_array[dim,d,:]).size for d in range(shape_dim[1])]
-        shape = shape + (max(nd),)
-
-    if np.prod(shape) != sorted_array.size:
+
+def meshvals(arrays) -> Tuple[List[np.ndarray], np.ndarray]:
+    """
+    Lexicographically sort flattened N coordinate arrays and reshape back to inferred grid shape,
+    preserving original type of each input array.
+    
+    Parameters
+    ----------
+    *arrays : array-like
+        Flattened coordinate arrays of the same length. Can be numbers, strings, or list objects.
+    
+    Returns
+    -------
+    sorted_arrays : list[np.ndarray]
+        Coordinate arrays reshaped to inferred N-D grid shape, dtype/type preserved.
+    indices : np.ndarray
+        Permutation indices applied to the flattened arrays.
+    shape : tuple[int, ...]
+        Inferred grid shape (number of unique values per axis).
+    """
+    # Remember original type/dtype for each array
+    orig_types = [a.dtype if isinstance(a[0], np.ndarray) else type(a[0]) for a in arrays]
+
+    # Convert non arrays to object arrays
+    arrs = []
+    for a in arrays:
+        arrs_a = np.empty(len(a), dtype=object)
+        arrs_a[:] = a
+        arrs.append(arrs_a)
+    
+    # Stack arrays as columns (M x N)
+    coords = np.stack(arrs, axis=1)
+    
+    # Lexicographic sort using structured array
+    indices = np.lexsort(coords.T[::-1])
+    sorted_coords = coords[indices]
+
+    # Check that all coordinates are unique
+    points = [tuple(col) for col in sorted_coords]
+    if not all_elements_unique(points):
         raise ValueError(
-            'Improper dimensions for the series. This usually means '
-            'that there are multiple images at the same location, \n or that '
-            'there are no images at one or more locations. \n\n'
-            'Make sure to specify proper dimensions when reading a pixel array or volume. \n'
-            'If the default dimensions of pixel_array (InstanceNumber) generate this error, '
-            'the DICOM data may be corrupted.'
-        ) 
-    
-    return shape
+            f"Improper coordinates. Coordinate values are not unique."
+        )
+    
+    # Infer shape from unique values per axis
+    shape = tuple(len(np.unique(sorted_coords[:, i])) for i in range(sorted_coords.shape[1]))
+    
+    # Check perfect grid
+    if np.prod(shape) != sorted_coords.shape[0]:
+        raise ValueError(
+            f"Coordinates do not form a perfect Cartesian grid: inferred shape {shape} "
+            f"does not match number of points {sorted_coords.shape[0]}"
+        )
+    
+    # Split back into individual arrays and cast to original type
+    sorted_arrays = []
+    for i, orig_type in enumerate(orig_types):
+        arr = sorted_coords[:, i]
+        arr = arr.astype(orig_type).reshape(shape)
+        sorted_arrays.append(arr)
+    
+    return sorted_arrays, indices
+
+
+def all_elements_unique(items):
+    """
+    The most general uniqueness check, but also the slowest (O(n^2)).
+    
+    It works for ANY type that supports equality checking (==), including
+    lists, dicts, and custom objects, without requiring them to be hashable.
+    """
+    for i in range(len(items)):
+        for j in range(i + 1, len(items)):
+            if items[i] == items[j]:
+                return False
+    return True
+
+
+
+# def NEWmeshvals(coords):
+#     stack_coords = [np.array(c, dtype=object) for c in coords]
+#     stack_coords = np.stack(stack_coords)
+#     mesh_coords, sorted_indices = _meshvals(stack_coords)
+#     mesh_coords = [mesh_coords[d,...] for d in range(mesh_coords.shape[0])]
+#     return mesh_coords, sorted_indices
+
+
+# def _meshvals(coords):
+#     # Input array shape: (d, f) with d = nr of dims and f = nr of frames
+#     # Output array shape: (d, f1,..., fd)
+#     if coords.size == 0:
+#         return np.array([])
+#     # Sort by column
+#     sorted_indices = np.lexsort(coords[::-1])
+#     sorted_array = coords[:, sorted_indices]
+#     # Find shape
+#     shape = _mesh_shape(sorted_array)  
+#     # Reshape
+#     mesh_array = sorted_array.reshape(shape)
+#     return mesh_array, sorted_indices
+
+
+# def _mesh_shape(sorted_array):
+    
+#     nd = np.unique(sorted_array[0,:]).size
+#     shape = (sorted_array.shape[0], nd)
+
+#     for dim in range(1,shape[0]):
+#         shape_dim = (shape[0], np.prod(shape[1:]), -1)
+#         sorted_array = sorted_array.reshape(shape_dim)
+#         nd = [np.unique(sorted_array[dim,d,:]).size for d in range(shape_dim[1])]
+#         shape = shape + (max(nd),)
+
+#     if np.prod(shape) != sorted_array.size:
+#         raise ValueError(
+#             'Improper dimensions for the series. This usually means '
+#             'that there are multiple images at the same location, \n or that '
+#             'there are no images at one or more locations. \n\n'
+#             'Make sure to specify proper dimensions when reading a pixel array or volume. \n'
+#             'If the default dimensions of pixel_array (InstanceNumber) generate this error, '
+#             'the DICOM data may be corrupted.'
+#         ) 
+    
+#     return shape

{dbdicom-0.3.9.dist-info → dbdicom-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbdicom
-Version: 0.3.9
+Version: 0.3.10
 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/

{dbdicom-0.3.9.dist-info → dbdicom-0.3.10.dist-info}/RECORD

@@ -1,10 +1,10 @@
 dbdicom/__init__.py,sha256=dW5aezonmMc_41Dp1PuYmXQlr307RkyJxsJuetkpWso,87
-dbdicom/api.py,sha256=oIvTktChBoEl4z0NXHMPVn2ZnPxUUXtZahwrIM7zfx0,14426
+dbdicom/api.py,sha256=5jOJjwOahDrj97Hu0XEJbryvhihpv4iuPSXdX8INpsE,14731
 dbdicom/const.py,sha256=BqBiRRjeiSqDr1W6YvaayD8WKCjG4Cny2NT0GeLM6bI,4269
 dbdicom/database.py,sha256=mkYQAAf9fETzUhSQflQFp7RQUBdPlSlDty9nn6KY1jQ,4771
-dbdicom/dataset.py,sha256=2_MB7t9nMzTyq6sEhbu__MjU1VEnO0MdZuhzZK13a1I,14433
-dbdicom/dbd.py,sha256=AP3BGcwWXnHwSov9kcm4CdWzgIDKod9WiGFNOf2aHLE,39799
-dbdicom/register.py,sha256=_NyNbOEAN_hkwjxupNpr9F5DWUwARCsci8knK41-EsA,13931
+dbdicom/dataset.py,sha256=pokXlcXLM33OdqMKGfVcWHlVE9ez4iBfpoefVWw1ob8,14421
+dbdicom/dbd.py,sha256=isqBzCE5bxfixZTH5ShNmJ123vCAhueGxV7pCTrqBF8,44035
+dbdicom/register.py,sha256=5yXnTbRUu8rYJqeIbSv5SiRf2E4BZ0JZyvKm_xvaXZQ,14944
 dbdicom/external/__init__.py,sha256=XNQqfspyf6vFGedXlRKZsUB8k8E-0W19Uamwn8Aioxo,316
 dbdicom/external/__pycache__/__init__.cpython-311.pyc,sha256=pXAQ35ixd92fm6YcuHgzR1t6RcASQ-cHhU1wOA5b8sw,542
 dbdicom/external/dcm4che/README.md,sha256=0aAGRs36W3_0s5LzWHRGf_tqariS_JP4iJggaxnD4Xw,8987
@@ -35,20 +35,20 @@ dbdicom/external/dcm4che/lib/windows-x86/clib_jiio_util.dll,sha256=wi4yyrI1gTRo_
 dbdicom/external/dcm4che/lib/windows-x86/opencv_java.dll,sha256=QanyzLy0Cd79-aOVPwOcXwikUYeutne0Au-Um91_B4M,8505856
 dbdicom/external/dcm4che/lib/windows-x86-64/opencv_java.dll,sha256=TmjW2SbG4MR3GQ95T8xCVVDLgsdKukgaHBPUvWkfXp8,11039232
 dbdicom/sop_classes/ct_image.py,sha256=16PNv_0e1_7cfxE12JWlx5YQeaTAQVzwtXTjxs3aonk,2812
-dbdicom/sop_classes/enhanced_mr_image.py,sha256=8JWg8I86YtYBKYgiZdsA-OHPFS6_1GpW4lYCudKMAI4,33379
+dbdicom/sop_classes/enhanced_mr_image.py,sha256=6x4CEd982i64e90ZlFDKNSc83XHC2k2DVit1iyjXjCU,33368
 dbdicom/sop_classes/mr_image.py,sha256=1biIw7R26Fc38FAeSlWxd29VO17e8cEQdDIdLbeXTzw,10959
 dbdicom/sop_classes/parametric_map.py,sha256=2OKBuC2bo03OEpKqimQS-nVGFp1cKRPYwVgmDGVf1JU,12288
 dbdicom/sop_classes/secondary_capture.py,sha256=wgNRX8qyhV7HR7Jq2tQWPPuGpiRzYl6qPOgK6qFbPUc,4541
 dbdicom/sop_classes/segmentation.py,sha256=I8-PciIoIz27_-dZ4esBZSw0TBBbO8KbNYTiTmVe62g,11465
 dbdicom/sop_classes/ultrasound_multiframe_image.py,sha256=j3KN5R90j6WwPMy01hAN2_XSum5TvksF2MYoNGfX_yE,2797
 dbdicom/sop_classes/xray_angiographic_image.py,sha256=nWysCGaEWKVNItnOgyJfcGMpS3oEK1T0_uNR2D7p0Ls,3270
-dbdicom/utils/arrays.py,sha256=cZo6hKk-pg_e2WCs9vxW9dxX04gmH3EwSZKFX1n8pq4,1451
+dbdicom/utils/arrays.py,sha256=_dJGFQPVRfchIRN6vra08RBYnEezobclHv5rEndQ3OA,4588
 dbdicom/utils/dcm4che.py,sha256=Vxq8NYWWK3BuqJkzhBQ89oMqzJlnxqTxgsgTo_Frznc,2317
 dbdicom/utils/files.py,sha256=qhWNJqeWnRjDNbERpC6Mz962_TW9mFdvd2lnBbK3xt4,2259
 dbdicom/utils/image.py,sha256=zRM1O0bxPp-qpf3Iv_GRS1omKaMN1SgSkAwufWLJ0Fk,3863
 dbdicom/utils/pydicom_dataset.py,sha256=XM3EERsCWPlEaUzVaFQSbPNiNbEGwxIbf-sUKKf_YxA,12755
-dbdicom-0.3.9.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-dbdicom-0.3.9.dist-info/METADATA,sha256=aNhxdZoSLOvA-OIJOPGsL-BPWjUWFoNNJd2ICWjZUGk,1030
-dbdicom-0.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dbdicom-0.3.9.dist-info/top_level.txt,sha256=nJWxXg4YjD6QblfmhrzTMXcr8FSKNc0Yk-CAIDUsYkQ,8
-dbdicom-0.3.9.dist-info/RECORD,,
+dbdicom-0.3.10.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+dbdicom-0.3.10.dist-info/METADATA,sha256=0BoheAKLRKF5pClyGgZqc1Y07-AH3I7IbvB-Mh9tQQA,1031
+dbdicom-0.3.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dbdicom-0.3.10.dist-info/top_level.txt,sha256=nJWxXg4YjD6QblfmhrzTMXcr8FSKNc0Yk-CAIDUsYkQ,8
+dbdicom-0.3.10.dist-info/RECORD,,