dbdicom 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

dbdicom/api.py

@@ -1,3 +1,4 @@
+from typing import Union
 
 import vreg
 
@@ -190,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:
@@ -232,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:
@@ -270,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/database.py

@@ -20,6 +20,7 @@ COLUMNS = [
     'PatientName', 
     'StudyDescription', 
     'StudyDate', 
+    'StudyID',
     'SeriesDescription', 
     'SeriesNumber', 
     'InstanceNumber', 
@@ -77,6 +78,7 @@ def _multiframe_to_singleframe(path, 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')
@@ -94,10 +96,12 @@ def _tree(df):
         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': [],
             }

dbdicom/dataset.py

@@ -229,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):
@@ -513,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']))
@@ -602,10 +595,10 @@ def set_pixel_data(ds, array):
     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:
@@ -621,7 +614,7 @@ def set_volume(ds, volume:vreg.Volume3D, multislice=False):
     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))

dbdicom/dbd.py

@@ -1,6 +1,7 @@
 import os
 from datetime import datetime
 import json
+from typing import Union
 
 from tqdm import tqdm
 import numpy as np
@@ -143,6 +144,11 @@ class DataBaseDicom():
             for patient in self.patients():
                 studies += self.studies(patient, name, contains, isin)
             return studies
+        elif len(entity)==1:
+            studies = []
+            for patient in self.patients():
+                studies += self.studies(patient, name, contains, isin)
+            return studies
         else:
             return register.studies(self.register, entity, name, contains, isin)
     
@@ -172,6 +178,11 @@ class DataBaseDicom():
             for study in self.studies(entity):
                 series += self.series(study, name, contains, isin)
             return series
+        elif len(entity)==1:
+            series = []
+            for study in self.studies(entity):
+                series += self.series(study, name, contains, isin)
+            return series            
         elif len(entity)==2:
             series = []
             for study in self.studies(entity):
@@ -181,20 +192,20 @@ class DataBaseDicom():
             return register.series(self.register, entity, name, contains, isin)
 
 
-    def volume(self, series:list, dims:list=None, multislice=False) -> vreg.Volume3D:
+    def volume(self, 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): # path to folder
+            return [self.volume(s, dims) for s in self.series(series)]
+        if len(series) < 4: # folder, patient or study
+            return [self.volume(s, dims) for s in self.series(series)]
         if dims is None:
             dims = []
         elif isinstance(dims, str):
@@ -211,7 +222,7 @@ class DataBaseDicom():
         for f in tqdm(files, desc='Reading volume..'):
             ds = dbdataset.read_dataset(f)  
             values.append(dbdataset.get_values(ds, dims))
-            volumes.append(dbdataset.volume(ds, multislice))
+            volumes.append(dbdataset.volume(ds))
 
         # Format as mesh
         coords = np.stack(values, axis=-1)
@@ -229,9 +240,21 @@ class DataBaseDicom():
                     "firstslice=True, the coordinates of the lowest "
                     "slice will be assigned to the whole volume."     
                 )
+            
+        # Infer spacing between slices from slice locations
+        # Technically only necessary if SpacingBetweenSlices not set or incorrect
+        vols = infer_slice_spacing(vols)
 
         # Join 2D volumes into 3D volumes
-        vol = vreg.join(vols)
+        try:
+            vol = vreg.join(vols)
+        except ValueError:
+            # some vendors define the slice vector as -cross product 
+            # of row and column vector. Check if that solves the issue.
+            for v in vols.reshape(-1):
+                v.affine[:3,2] = -v.affine[:3,2]
+                # Then try again
+            vol = vreg.join(vols)
         if vol.ndim > 3:
             vol.set_coords(c0)
             vol.set_dims(dims[1:])
@@ -239,19 +262,18 @@ class DataBaseDicom():
 
     
     def write_volume(
-            self, vol:vreg.Volume3D, series:list, 
-            ref:list=None, multislice=False,
+            self, 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.
             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 than the slice thickness. Defaults to False.
+            ref (list): Reference series
         """
+        if isinstance(vol, tuple):
+            vol = vreg.volume(vol[0], vol[1])
         if ref is None:
             ds = dbdataset.new_dataset('MRImage')
             #ds = dbdataset.new_dataset('ParametricMap')
@@ -270,21 +292,21 @@ class DataBaseDicom():
         if vol.ndim==3:
             slices = vol.split()
             for i, sl in tqdm(enumerate(slices), desc='Writing volume..'):
-                dbdataset.set_volume(ds, sl, multislice)
+                dbdataset.set_volume(ds, sl)
                 self._write_dataset(ds, attr, n + 1 + i)
         else:
             i=0
             vols = vol.separate().reshape(-1)
             for vt in tqdm(vols, desc='Writing volume..'):
                 for sl in vt.split():
-                    dbdataset.set_volume(ds, sl, multislice)
+                    dbdataset.set_volume(ds, sl)
                     dbdataset.set_value(ds, sl.dims, sl.coords[:,...])
                     self._write_dataset(ds, attr, n + 1 + i)
                     i+=1
         return self
 
 
-    def to_nifti(self, series:list, file:str, dims=None, multislice=False):
+    def to_nifti(self, series:list, file:str, dims=None):
         """Save a DICOM series in nifti format.
 
         Args:
@@ -292,34 +314,31 @@ class DataBaseDicom():
             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.
         """
-        vol = self.volume(series, dims, multislice)
+        vol = self.volume(series, dims)
         vreg.write_nifti(vol, file)
         return self
 
-    def from_nifti(self, file:str, series:list, ref:list=None, multislice=False):
+    def from_nifti(self, 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.
         """
         vol = vreg.read_nifti(file)
-        self.write_volume(vol, series, ref, multislice)
+        self.write_volume(vol, series, ref)
         return self
     
     def pixel_data(self, series:list, dims:list=None, coords=False, include=None) -> np.ndarray:
         """Read the pixel data from a DICOM series
 
         Args:
-            series (list): DICOM series to read
+            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.
             dims (list, optional): Dimensions of the array.
             coords (bool): If set to Trye, the coordinates of the 
                 arrays are returned alongside the pixel data
@@ -332,8 +351,12 @@ class DataBaseDicom():
                 coords is set these are returned too as an array with 
                 coordinates of the slices according to dims. If include 
                 is provide the values are returned as a dictionary in the last 
-                return value.
+                return value. 
         """
+        if isinstance(series, str): # path to folder
+            return [self.pixel_data(s, dims, coords, include) for s in self.series(series)]
+        if len(series) < 4: # folder, patient or study
+            return [self.pixel_data(s, dims, coords, include) for s in self.series(series)]
         if coords:
             if dims is None:
                 raise ValueError(
@@ -529,13 +552,19 @@ class DataBaseDicom():
             ds = dbdataset.read_dataset(f)
             self._write_dataset(ds, attr, n + 1 + i)
 
-
+    def _max_study_id(self, patient_id):
+        for pt in self.register:
+            if pt['PatientID'] == patient_id:
+                n = [int(st['StudyID']) for st in pt['studies']]
+                return int(np.amax(n))
+        return 0
+    
     def _max_series_number(self, study_uid):
         for pt in self.register:
             for st in pt['studies']:
                 if st['StudyInstanceUID'] == study_uid:
-                    n = [sr['SeriesNumber'] for sr in st['studies']]
-                    return np.amax(n)
+                    n = [sr['SeriesNumber'] for sr in st['series']]
+                    return int(np.amax(n))
         return 0
 
     def _max_instance_number(self, series_uid):
@@ -544,7 +573,7 @@ class DataBaseDicom():
                 for sr in st['series']:
                     if sr['SeriesInstanceUID'] == series_uid:
                         n = list(sr['instances'].keys())
-                        return np.amax([int(i) for i in n])
+                        return int(np.amax([int(i) for i in n]))
         return 0
 
     def _attributes(self, entity):
@@ -566,7 +595,8 @@ class DataBaseDicom():
         except:
             # If the patient does not exist, generate values
             attr = ['PatientID', 'PatientName']
-            patient_id = dbdataset.new_uid()
+            #patient_id = dbdataset.new_uid()
+            patient_id = patient[-1] if isinstance(patient[-1], str) else f"{patient[-1][0]}_{patient[-1][1]}"
             patient_name = patient[-1] if isinstance(patient[-1], str) else patient[-1][0]
             vals = [patient_id, patient_name]
         return {attr[i]:vals[i] for i in range(len(attr)) if vals[i] is not None}
@@ -581,12 +611,18 @@ class DataBaseDicom():
             ds = dbdataset.read_dataset(files[0])
             vals = dbdataset.get_values(ds, attr)
         except:
-            # If the study does not exist, generate values
-            attr = ['StudyInstanceUID', 'StudyDescription', 'StudyDate']
-            study_id = dbdataset.new_uid()
+            # If the study does not exist or is empty, generate values
+            try:
+                patient_id = register.uid(self.register, study[:-1])
+            except:
+                study_id = 1
+            else:
+                study_id = 1 + self._max_study_id(patient_id)
+            attr = ['StudyInstanceUID', 'StudyDescription', 'StudyDate', 'StudyID']
+            study_uid = dbdataset.new_uid()
             study_desc = study[-1] if isinstance(study[-1], str) else study[-1][0]
             study_date = datetime.today().strftime('%Y%m%d')
-            vals = [study_id, study_desc, study_date]
+            vals = [study_uid, study_desc, study_date, str(study_id)]
         return patient_attr | {attr[i]:vals[i] for i in range(len(attr)) if vals[i] is not None}
 
 
@@ -607,9 +643,9 @@ class DataBaseDicom():
             else:
                 series_number = 1 + self._max_series_number(study_uid)
             attr = ['SeriesInstanceUID', 'SeriesDescription', 'SeriesNumber']
-            series_id = dbdataset.new_uid()
+            series_uid = dbdataset.new_uid()
             series_desc = series[-1] if isinstance(series[-1], str) else series[-1][0]
-            vals = [series_id, series_desc, series_number]
+            vals = [series_uid, series_desc, int(series_number)]
         return study_attr | {attr[i]:vals[i] for i in range(len(attr)) if vals[i] is not None}
 
         
@@ -619,7 +655,13 @@ class DataBaseDicom():
         attr['InstanceNumber'] = str(instance_nr)
         dbdataset.set_values(ds, list(attr.keys()), list(attr.values()))
         # Save results in a new file
-        rel_path = os.path.join('dbdicom', dbdataset.new_uid() + '.dcm') 
+        rel_dir = os.path.join(
+            f"patient_{attr['PatientID']}", 
+            f"study_[{attr['StudyID']}]_{attr['StudyDescription']}", 
+            f"series_[{attr['SeriesNumber']}]_{attr['SeriesDescription']}",
+        )
+        os.makedirs(os.path.join(self.path, rel_dir), exist_ok=True)
+        rel_path = os.path.join(rel_dir, dbdataset.new_uid() + '.dcm')
         dbdataset.write(ds, os.path.join(self.path, rel_path))
         # Add an entry in the register
         register.add_instance(self.register, attr, rel_path)
@@ -656,6 +698,59 @@ class DataBaseDicom():
     #     self.register.drop('SOPClassUID', axis=1, inplace=True)
 
 
+def infer_slice_spacing(vols):
+    # In case spacing between slices is not (correctly) encoded in 
+    # DICOM it can be inferred from the slice locations.
+
+    shape = vols.shape
+    vols = vols.reshape((shape[0], -1))
+    slice_spacing = np.zeros(vols.shape[-1])
+
+    for d in range(vols.shape[-1]):
+
+        # For single slice volumes there is nothing to do
+        if vols[:,d].shape[0]==1:
+            continue
+
+        # Get a normal slice vector from the first volume.
+        mat = vols[0,d].affine[:3,:3]
+        normal = mat[:,2]/np.linalg.norm(mat[:,2])
+
+        # Get slice locations by projection on the normal.
+        pos = [v.affine[:3,3] for v in vols[:,d]]
+        slice_loc = [np.dot(p, normal) for p in pos]
+
+        # Sort slice locations and take consecutive differences.
+        slice_loc = np.sort(slice_loc)
+        distances = slice_loc[1:] - slice_loc[:-1]
+
+        # Round to micrometer and check if unique
+        distances = np.around(distances, 3)
+        slice_spacing_d = np.unique(distances)
+
+        # Check if unique - otherwise this is not a volume
+        if len(slice_spacing_d) > 1:
+            raise ValueError(
+                'Cannot build a volume - spacings between slices are not unique.'
+            )
+        else:
+            slice_spacing_d= slice_spacing_d[0]
+        
+        # Set correct slice spacing in all volumes
+        for v in vols[:,d]:
+            v.affine[:3,2] = normal * abs(slice_spacing_d)
+
+        slice_spacing[d] = slice_spacing_d
+
+    # Check slice_spacing is the same across dimensions
+    slice_spacing = np.unique(slice_spacing)
+    if len(slice_spacing) > 1:
+        raise ValueError(
+            'Cannot build a volume - spacings between slices are not unique.'
+        )    
+
+    return vols.reshape(shape)
+
 
 
 

dbdicom/register.py

@@ -21,6 +21,7 @@ def add_instance(dbtree:list, instance, rel_path):
         st = {
             'StudyDescription': instance['StudyDescription'],
             'StudyDate': instance['StudyDate'],
+            'StudyID': instance['StudyID'],
             'StudyInstanceUID': instance['StudyInstanceUID'],
             'series': [],
         }
@@ -186,7 +187,7 @@ def _patient_uid(dbtree, patient):
                 f"Please specify the index in the call to patient_uid(). "
                 f"For instance ({patient}, {len(patients)-1})'. "
             )
-    raise ValueError(f"Patient {patient} not found in database.")
+    
     
 
 def _study_uid(dbtree, study):

dbdicom/sop_classes/mr_image.py

@@ -23,33 +23,54 @@ def pixel_data(ds):
     if [0x2005, 0x100E] in ds: # 'Philips Rescale Slope'
         slope = ds[(0x2005, 0x100E)].value
         intercept = ds[(0x2005, 0x100D)].value
-        array -= intercept
-        array /= slope
+        if (intercept == 0) and (slope == 1): 
+            array = array.astype(np.int16)
+        else:
+            array = array.astype(np.float32)
+            array -= intercept
+            array /= slope
     else:
         slope = float(getattr(ds, 'RescaleSlope', 1)) 
         intercept = float(getattr(ds, 'RescaleIntercept', 0)) 
-        array *= slope
-        array += intercept
+        if (intercept == 0) and (slope == 1): 
+            array = array.astype(np.int16)
+        else:
+            array = array.astype(np.float32)
+            array *= slope
+            array += intercept
     return np.transpose(array)
 
 
 def set_pixel_data(ds, array):
 
+    # Delete 'Philips Rescale Slope'
     if (0x2005, 0x100E) in ds: 
-        del ds[0x2005, 0x100E]  # Delete 'Philips Rescale Slope'
+        del ds[0x2005, 0x100E] 
     if (0x2005, 0x100D) in ds: 
         del ds[0x2005, 0x100D]
 
+    ds.BitsAllocated = 16
+    ds.BitsStored = 16
+    ds.HighBit = 15
+
     # 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)
+    #array = image.clip(array.astype(np.float32))
+    array = image.clip(array) # remove nan and infs
+    if array.dtype==np.int16:
+        ds.PixelRepresentation = 1
+        ds.RescaleSlope = 1
+        ds.RescaleIntercept = 0
+    elif array.dtype==np.uint16:
+        ds.PixelRepresentation = 0
+        ds.RescaleSlope = 1
+        ds.RescaleIntercept = 0
+    else:
+        array, slope, intercept = image.scale_to_range(array, ds.BitsStored)
+        ds.PixelRepresentation = 0
+        ds.RescaleSlope = 1 / slope
+        ds.RescaleIntercept = - intercept / slope
 
-    ds.PixelRepresentation = 0
-    ds.RescaleSlope = 1 / slope
-    ds.RescaleIntercept = - intercept / slope
-#        ds.WindowCenter = (maximum + minimum) / 2
-#        ds.WindowWidth = maximum - minimum
+    array = np.transpose(array)
     ds.Rows = array.shape[0]
     ds.Columns = array.shape[1]
     ds.PixelData = array.tobytes()

dbdicom/utils/image.py

@@ -54,14 +54,13 @@ def dismantle_affine_matrix(affine):
     # ImagePositionPatient_i = ImagePositionPatient + i * SpacingBetweenSlices * slice_cosine
     column_spacing = np.linalg.norm(affine[:3, 0])
     row_spacing = np.linalg.norm(affine[:3, 1])
-    slice_thickness = np.linalg.norm(affine[:3, 2])
+    slice_spacing = np.linalg.norm(affine[:3, 2])
     row_cosine = affine[:3, 0] / column_spacing
     column_cosine = affine[:3, 1] / row_spacing
-    slice_cosine = affine[:3, 2] / slice_thickness
+    slice_cosine = affine[:3, 2] / slice_spacing
     return {
         'PixelSpacing': [row_spacing, column_spacing], 
-#        'SpacingBetweenSlices': slice_thickness,  # Obsolete
-        'SliceThickness': slice_thickness, 
+        'SpacingBetweenSlices': slice_spacing,  
         'ImageOrientationPatient': row_cosine.tolist() + column_cosine.tolist(), 
         'ImagePositionPatient': affine[:3, 3].tolist(), # first slice for a volume
         'slice_cosine': slice_cosine.tolist()} 

{dbdicom-0.3.2.dist-info → dbdicom-0.3.3.dist-info}/METADATA

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

{dbdicom-0.3.2.dist-info → dbdicom-0.3.3.dist-info}/RECORD

@@ -1,21 +1,21 @@
 dbdicom/__init__.py,sha256=DyogeTraV6o-FgWdBCbtVEaMmdkMQHkYkraDIE0t8OA,25
-dbdicom/api.py,sha256=Xcur6TstwvSD8QMDkFn97NDnuVymjCtHWldimG8CDP4,9783
+dbdicom/api.py,sha256=MHJBHY_ikUj93T8Vt0GAjvjLFJL-2IdIFKhr8T-bvVI,8871
 dbdicom/const.py,sha256=BqBiRRjeiSqDr1W6YvaayD8WKCjG4Cny2NT0GeLM6bI,4269
-dbdicom/database.py,sha256=w835qQHThZsIhoTXlQbZykcKnVrEADgp2mRYBTOKz4g,4627
-dbdicom/dataset.py,sha256=dm0bmBjqb_3uZLYV87gKszlqKMMLrSbaymVROafB5ac,22143
-dbdicom/dbd.py,sha256=xpDiWzlMUmXzYgRCR5jwvvHENbTsq3B89HvK2JxAo3c,26450
-dbdicom/register.py,sha256=5wBQsf4PB6ITHN3clUOMStUy5iYjMnIYUBfhVS2Drio,23692
+dbdicom/database.py,sha256=_LUbH7gc9l7j_63AC71DjwxgTUwbEjHSy5kuvRw75Hw,4764
+dbdicom/dataset.py,sha256=hLAyFlN7zQ-dOzI9V67aHfTq3VtpvCI7_83tnBqXObE,21880
+dbdicom/dbd.py,sha256=ZUXmLcQ2C6L9UTanGzTSte1XIJAcQoNNsEpweXW8N50,29921
+dbdicom/register.py,sha256=VPxS2oTlONxx5eNdGRbvFeEfQo69jo5YDp7L_Vb4x28,23676
 dbdicom/external/__init__.py,sha256=XNQqfspyf6vFGedXlRKZsUB8k8E-0W19Uamwn8Aioxo,316
-dbdicom/external/__pycache__/__init__.cpython-311.pyc,sha256=cIySrImYKo1fJP3-0ZMV-5ZKcZEEDX-uwfZ7I4U-jRs,534
+dbdicom/external/__pycache__/__init__.cpython-311.pyc,sha256=pXAQ35ixd92fm6YcuHgzR1t6RcASQ-cHhU1wOA5b8sw,542
 dbdicom/external/dcm4che/README.md,sha256=0aAGRs36W3_0s5LzWHRGf_tqariS_JP4iJggaxnD4Xw,8987
 dbdicom/external/dcm4che/__init__.py,sha256=YwpeMCLrxffGOkchsGjgAuB6ia3VX_tx9Y7ru9EWtoY,35
-dbdicom/external/dcm4che/__pycache__/__init__.cpython-311.pyc,sha256=QsnVh0zH1ZSOoNwtTqiirWH8CB0b2eJ0DEvgVoVhZ0Y,248
+dbdicom/external/dcm4che/__pycache__/__init__.cpython-311.pyc,sha256=FB8wyWqXDUt_1P-QmE4yt9uD6dDm5YqYWjqVuRwGdSo,256
 dbdicom/external/dcm4che/bin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbdicom/external/dcm4che/bin/deidentify,sha256=64MNIEpp-CWzFSb6TV0KtyCBvD7XyEsovRjBeyxDqSc,1698
 dbdicom/external/dcm4che/bin/deidentify.bat,sha256=kVXUkcy1C4Y3KjC2NJwmmR0pufSJWmaof_LR5CTAxMg,1455
 dbdicom/external/dcm4che/bin/emf2sf,sha256=svCzkZ-QhdVTV0NNHOpBiwNBMODVWZHJIFA7cWaN2bM,1622
 dbdicom/external/dcm4che/bin/emf2sf.bat,sha256=Vh0ry9KNJX_WXcyCrLSxbJ_6Crot9rjmwi__u2GZqLY,1375
-dbdicom/external/dcm4che/bin/__pycache__/__init__.cpython-311.pyc,sha256=M2mla4vNW1gSUWQps3dx4g8NRd4BaQJLP1OKQHmi6Sk,195
+dbdicom/external/dcm4che/bin/__pycache__/__init__.cpython-311.pyc,sha256=GYcm47ETjYvRUN5RPTe5R-c0prd14GP8gm96eJcy0uQ,203
 dbdicom/external/dcm4che/etc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbdicom/external/dcm4che/etc/emf2sf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbdicom/external/dcm4che/etc/emf2sf/log4j.properties,sha256=3hHcBFt2oNRjvHtix5bfuEsnKfdv5IYOkbsyoY9g7cM,223
@@ -36,7 +36,7 @@ dbdicom/external/dcm4che/lib/windows-x86/opencv_java.dll,sha256=QanyzLy0Cd79-aOV
 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=13j4EGXniBpJxpzzL3Xa4y3g5OKhMd5Ct7cjPGOYQY4,35496
-dbdicom/sop_classes/mr_image.py,sha256=nHSQIh_zpdmZ0VhwKCVr9iqkluHxl1ASQ75Fr9OeNXI,10270
+dbdicom/sop_classes/mr_image.py,sha256=kNcrWXZ3VC3hhfqjMRjrlZOVqZH3Q5KfWXYLfLD-bEY,10913
 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
@@ -45,10 +45,10 @@ dbdicom/sop_classes/xray_angiographic_image.py,sha256=nWysCGaEWKVNItnOgyJfcGMpS3
 dbdicom/utils/arrays.py,sha256=wiqCczLXlNl0qIePVOwCYvbAJhPveNorplkhtGleS48,1121
 dbdicom/utils/dcm4che.py,sha256=Vxq8NYWWK3BuqJkzhBQ89oMqzJlnxqTxgsgTo_Frznc,2317
 dbdicom/utils/files.py,sha256=qhWNJqeWnRjDNbERpC6Mz962_TW9mFdvd2lnBbK3xt4,2259
-dbdicom/utils/image.py,sha256=dCjukz9Zvpl4cP3KR1Y4hmKkox5KaFiEhdxDWDEdNec,4110
+dbdicom/utils/image.py,sha256=D46CD_ezpp2uq8VMqug5Z09fAyoJ9U6VwuxIFNJK8zg,4048
 dbdicom/utils/variables.py,sha256=vUh5cDnmCft5hoXDYXUvfkg5Cy5WlgMAogU38Y_BKRo,5753
-dbdicom-0.3.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-dbdicom-0.3.2.dist-info/METADATA,sha256=zqs5ghuuW4o1UR_QkGhiM9afOqmKYWMg0d54ThWRV0k,1030
-dbdicom-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dbdicom-0.3.2.dist-info/top_level.txt,sha256=nJWxXg4YjD6QblfmhrzTMXcr8FSKNc0Yk-CAIDUsYkQ,8
-dbdicom-0.3.2.dist-info/RECORD,,
+dbdicom-0.3.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+dbdicom-0.3.3.dist-info/METADATA,sha256=aMYhKPS907fOj0pgSkQh7vbFeYspNvJP5-ZYNZ6LpMs,1030
+dbdicom-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dbdicom-0.3.3.dist-info/top_level.txt,sha256=nJWxXg4YjD6QblfmhrzTMXcr8FSKNc0Yk-CAIDUsYkQ,8
+dbdicom-0.3.3.dist-info/RECORD,,