dbdicom 0.3.5__tar.gz → 0.3.7__tar.gz

{dbdicom-0.3.5/src/dbdicom.egg-info → dbdicom-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbdicom
-Version: 0.3.5
+Version: 0.3.7
 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.5 → dbdicom-0.3.7}/pyproject.toml

@@ -7,7 +7,7 @@ requires = ['setuptools>=61.2']
 
 [project]
 name = "dbdicom"
-version = "0.3.5"
+version = "0.3.7"
 dependencies = [ 
     "tqdm",
     "importlib-resources",

dbdicom-0.3.7/src/dbdicom/__init__.py

@@ -0,0 +1,4 @@
+from dbdicom.api import *
+
+# Utilities
+from dbdicom.utils.image import affine_matrix

{dbdicom-0.3.5 → dbdicom-0.3.7}/src/dbdicom/api.py

@@ -1,10 +1,18 @@
+import os
+import shutil
+import zipfile
+from pathlib import Path
 from typing import Union
+from tqdm import tqdm
+
 
 import vreg
 
 from dbdicom.dbd import DataBaseDicom
 
 
+
+
 def open(path:str) -> DataBaseDicom:
     """Open a DICOM database
 
@@ -262,13 +270,65 @@ def from_nifti(file:str, series:list, ref:list=None):
     dbd.from_nifti(file, series, ref)
     dbd.close()
 
-def pixel_data(series:list, dims:list=None, include:list=None) -> tuple:
+
+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
+
+    Args:
+        entity (list or str): DICOM entity to read. This can 
+            be a path to a folder containing DICOM files, or a 
+            patient or study to read all series in that patient or 
+            study. 
+
+    Returns:
+        list: list of valid dicom files.
+    """
+    if isinstance(entity, str):
+        entity = [entity]
+    dbd = open(entity[0])
+    files = dbd.files(entity)
+    dbd.close()
+    return files
+
+
+def pixel_data(series:list, dims:list=None, coords=False, attr:list=None) -> tuple:
     """Read the pixel data from a DICOM series
 
     Args:
         series (list): DICOM series to read
         dims (list, optional): Dimensions of the array.
-        include (list, optional): list of DICOM attributes that are 
+        coords (bool): If set to True, the coordinates of the 
+            slices are returned alongside the pixel data.
+        attr (list, optional): list of DICOM attributes that are 
             read on the fly to avoid reading the data twice.
 
     Returns:
@@ -280,7 +340,7 @@ def pixel_data(series:list, dims:list=None, include:list=None) -> tuple:
     if isinstance(series, str):
         series = [series]
     dbd = open(series[0])
-    array = dbd.pixel_data(series, dims, include)
+    array = dbd.pixel_data(series, dims, coords, attr)
     dbd.close()
     return array
 
@@ -311,10 +371,74 @@ def unique(pars:list, entity:list) -> dict:
     return u
 
 
+def archive(path, archive_path):
+    dbd = open(path)
+    dbd.archive(archive_path)
+    dbd.close()
 
 
+def restore(archive_path, path):
+    _copy_and_extract_zips(archive_path, path)
+    dbd = open(path)
+    dbd.close()
 
 
-if __name__=='__main__':
+def _copy_and_extract_zips(src_folder, dest_folder):
+    if not os.path.exists(dest_folder):
+        os.makedirs(dest_folder)
+
+    # First pass: count total files
+    total_files = sum(len(files) for _, _, files in os.walk(src_folder))
 
+    with tqdm(total=total_files, desc="Copying and extracting") as pbar:
+        for root, dirs, files in os.walk(src_folder):
+            rel_path = os.path.relpath(root, src_folder)
+            dest_path = os.path.join(dest_folder, rel_path)
+            os.makedirs(dest_path, exist_ok=True)
+
+            for file in files:
+                src_file_path = os.path.join(root, file)
+                dest_file_path = os.path.join(dest_path, file)
+
+                if file.lower().endswith('.zip'):
+                    try:
+                        zip_dest_folder = dest_file_path[:-4]
+                        with zipfile.ZipFile(src_file_path, 'r') as zip_ref:
+                            zip_ref.extractall(zip_dest_folder)
+                        #tqdm.write(f"Extracted ZIP: {src_file_path}")
+                        #_flatten_folder(zip_dest_folder) # still needed?
+                    except zipfile.BadZipFile:
+                        tqdm.write(f"Bad ZIP file skipped: {src_file_path}")
+                else:
+                    shutil.copy2(src_file_path, dest_file_path)
+
+                pbar.update(1)
+
+
+def _flatten_folder(root_folder):
+    for dirpath, dirnames, filenames in os.walk(root_folder, topdown=False):
+        for filename in filenames:
+            src_path = os.path.join(dirpath, filename)
+            dst_path = os.path.join(root_folder, filename)
+            
+            # If file with same name exists, optionally rename or skip
+            if os.path.exists(dst_path):
+                base, ext = os.path.splitext(filename)
+                counter = 1
+                while os.path.exists(dst_path):
+                    dst_path = os.path.join(root_folder, f"{base}_{counter}{ext}")
+                    counter += 1
+
+            shutil.move(src_path, dst_path)
+
+        # Remove empty subdirectories (but skip the root folder)
+        if dirpath != root_folder:
+            try:
+                os.rmdir(dirpath)
+            except OSError:
+                print(f"Could not remove {dirpath} — not empty or in use.")
+
+
+
+if __name__=='__main__':
     pass

{dbdicom-0.3.5 → dbdicom-0.3.7}/src/dbdicom/dataset.py

@@ -574,25 +574,51 @@ def set_pixel_data(ds, array):
     if hasattr(mod, 'set_pixel_data'):
         return getattr(mod, 'set_pixel_data')(ds, array)
     
-    # if array.ndim >= 3: # remove spurious dimensions of 1
-    #     array = np.squeeze(array) 
+    ds.BitsAllocated = 16
+    ds.BitsStored = 16
+    ds.HighBit = 15
+
+    if array.dtype==np.int16:
+        array = image.clip(array) # remove nan and infs
+        ds.PixelRepresentation = 1
+        ds.RescaleSlope = 1
+        ds.RescaleIntercept = 0
+    elif array.dtype==np.uint16:
+        array = image.clip(array) # remove nan and infs
+        ds.PixelRepresentation = 0
+        ds.RescaleSlope = 1
+        ds.RescaleIntercept = 0
+    else:
+        array = image.clip(array) # remove nan and infs
+        array, slope, intercept = image.scale_to_range(array, ds.BitsStored)
+        ds.PixelRepresentation = 0
+        ds.RescaleSlope = 1 / slope
+        ds.RescaleIntercept = - intercept / slope
 
-    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.SmallestImagePixelValue = int(0)
-    #ds.LargestImagePixelValue = int(2**ds.BitsAllocated - 1)
-    #ds.set_values('SmallestImagePixelValue', int(0))
-    #ds.set_values('LargestImagePixelValue', int(2**ds.BitsAllocated - 1))
-    ds.RescaleSlope = 1 / slope
-    ds.RescaleIntercept = - intercept / slope
-#        ds.WindowCenter = (maximum + minimum) / 2
-#        ds.WindowWidth = maximum - minimum
     ds.Rows = array.shape[0]
     ds.Columns = array.shape[1]
     ds.PixelData = array.tobytes()
+    
+#     # if array.ndim >= 3: # remove spurious dimensions of 1
+#     #     array = np.squeeze(array) 
+
+#     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.SmallestImagePixelValue = int(0)
+#     #ds.LargestImagePixelValue = int(2**ds.BitsAllocated - 1)
+#     #ds.set_values('SmallestImagePixelValue', int(0))
+#     #ds.set_values('LargestImagePixelValue', int(2**ds.BitsAllocated - 1))
+#     ds.RescaleSlope = 1 / slope
+#     ds.RescaleIntercept = - intercept / slope
+# #        ds.WindowCenter = (maximum + minimum) / 2
+# #        ds.WindowWidth = maximum - minimum
+#     ds.Rows = array.shape[0]
+#     ds.Columns = array.shape[1]
+#     ds.PixelData = array.tobytes()
 
 
 def volume(ds):

{dbdicom-0.3.5 → dbdicom-0.3.7}/src/dbdicom/dbd.py

@@ -2,6 +2,7 @@ import os
 from datetime import datetime
 import json
 from typing import Union
+import zipfile
 
 from tqdm import tqdm
 import numpy as np
@@ -39,7 +40,12 @@ class DataBaseDicom():
                 # have been made which are not reflected in the json 
                 # file on disk
                 # os.remove(file)
-            except:
+            except Exception as e:
+                # raise ValueError(
+                #     f'Cannot open {file}. Please close any programs that are '
+                #     f'using it and try again. Alternatively you can delete the file '
+                #     f'manually and try again.'
+                # )
                 # If the file can't be read, delete it and load again
                 os.remove(file)
                 self.read()
@@ -239,9 +245,7 @@ class DataBaseDicom():
             if not np.array_equal(coords[1:,k+1,...], c0):
                 raise ValueError(
                     "Cannot build a single volume. Not all slices "
-                    "have the same coordinates. \nIf you set " 
-                    "firstslice=True, the coordinates of the lowest "
-                    "slice will be assigned to the whole volume."     
+                    "have the same coordinates."     
                 )
             
         # Infer spacing between slices from slice locations
@@ -335,7 +339,7 @@ class DataBaseDicom():
         self.write_volume(vol, series, ref)
         return self
     
-    def pixel_data(self, series:list, dims:list=None, coords=False, include=None) -> np.ndarray:
+    def pixel_data(self, series:list, dims:list=None, coords=False, attr=None) -> np.ndarray:
         """Read the pixel data from a DICOM series
 
         Args:
@@ -344,9 +348,9 @@ class DataBaseDicom():
                 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 
+            coords (bool): If set to True, the coordinates of the 
                 arrays are returned alongside the pixel data
-            include (list, optional): list of DICOM attributes that are 
+            attr (list, optional): list of DICOM attributes that are 
                 read on the fly to avoid reading the data twice.
 
         Returns:
@@ -354,48 +358,42 @@ class DataBaseDicom():
                 at least 3 dimensions (x,y,z). If 
                 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 
+                is provided the values are returned as a dictionary in the last 
                 return value. 
         """
         if isinstance(series, str): # path to folder
-            return [self.pixel_data(s, dims, coords, include) for s in self.series(series)]
+            return [self.pixel_data(s, dims, coords, attr) 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(
-                    "Coordinates can only be returned if dimensions are specified."
-                )
+            return [self.pixel_data(s, dims, coords, attr) for s in self.series(series)]
 
         if dims is None:
-            dims = []
+            dims = ['InstanceNumber']
         elif np.isscalar(dims):
             dims = [dims]
         else:
             dims = list(dims)
-        dims = ['SliceLocation'] + dims
 
         # Ensure return_vals is a list
-        if include is None:
+        if attr is None:
             params = []
-        elif np.isscalar(include):
-            params = [include]
+        elif np.isscalar(attr):
+            params = [attr]
         else:
-            params = list(include)
+            params = list(attr)
 
         files = register.files(self.register, series)
         
         # Read dicom files
         coords_array = []
         arrays = np.empty(len(files), dtype=dict)
-        if include is not None:
+        if attr is not None:
             values = np.empty(len(files), dtype=dict)
         for i, f in tqdm(enumerate(files), desc='Reading pixel data..'):
             ds = dbdataset.read_dataset(f)  
             coords_array.append(dbdataset.get_values(ds, dims))
             # save as dict so numpy does not stack as arrays
             arrays[i] = {'pixel_data': dbdataset.pixel_data(ds)}
-            if include is not None:
+            if attr is not None:
                 values[i] = {'values': dbdataset.get_values(ds, params)}
 
         # Format as mesh
@@ -406,20 +404,169 @@ class DataBaseDicom():
         arrays = np.stack([a['pixel_data'] for a in arrays.reshape(-1)], axis=-1)
         arrays = arrays.reshape(arrays.shape[:2] + coords_array.shape[1:])
 
-        if include is None:
+        if attr is None:
             if coords:
-                return arrays, coords_array[1:,...]
+                return arrays, coords_array
             else:
                 return arrays
+
+        # Return values as a dictionary
+        values = values[inds].reshape(-1)
+        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 array 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[params[p]] = vp
+
+        # If only one, return as value
+        if len(params) == 1:
+            values_return = values_dict[attr[0]]
+        else:
+            values_return = values_dict
         
-        values = values[inds].reshape(coords_array.shape[1:])
-        values = np.stack([a['values'] for a in values.reshape(-1)], axis=-1)
-        values = values.reshape((len(params), ) + coords_array.shape[1:])
+        # problem if the values are a list. Needs an array with a prespeficied dtype
+        # values = values[inds].reshape(coords_array.shape[1:])
+        # values = np.stack([a['values'] for a in values.reshape(-1)], axis=-1) 
+        # values = values.reshape((len(params), ) + coords_array.shape[1:])
 
         if coords:
-            return arrays, coords_array[1:,...], values
+            return arrays, coords_array, values_return
         else:
-            return arrays, values
+            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 = dbdataset.read_dataset(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 = dbdataset.read_dataset(f)  
+            coords_array.append(dbdataset.get_values(ds, dims))
+            # save as dict so numpy does not stack as arrays
+            values[i] = {'values': dbdataset.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:
+        """Read the files in a DICOM entity
+
+        Args:
+            entity (list or str): DICOM entity to read. This can 
+                be a path to a folder containing DICOM files, or a 
+                patient or study to read all series in that patient or 
+                study. 
+
+        Returns:
+            list: list of valid dicom files.
+        """
+        if isinstance(entity, str): # path to folder
+            files = []
+            for s in self.series(entity):
+                files += self.files(s)
+            return files
+        if len(entity) < 4: # folder, patient or study
+            files = []
+            for s in self.series(entity):
+                files += self.files(s)
+            return files
+
+        return register.files(self.register, entity)
+
     
     
     def unique(self, pars:list, entity:list) -> dict:
@@ -723,9 +870,9 @@ class DataBaseDicom():
         dbdataset.set_values(ds, list(attr.keys()), list(attr.values()))
         # Save results in a new file
         rel_dir = os.path.join(
-            f"patient_{attr['PatientID']}", 
-            f"study_[{attr['StudyID']}]_{attr['StudyDescription']}", 
-            f"series_[{attr['SeriesNumber']}]_{attr['SeriesDescription']}",
+            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')
@@ -734,6 +881,34 @@ class DataBaseDicom():
         register.add_instance(self.register, attr, rel_path)
 
 
+    def archive(self, archive_path):
+        # TODO add flat=True option for zipping at patient level
+        for pt in tqdm(self.register, desc='Archiving '):
+            for st in pt['studies']:
+                zip_dir = os.path.join(
+                    archive_path,
+                    f"Patient__{pt['PatientID']}", 
+                    f"Study__{st['StudyID']}__{st['StudyDescription']}", 
+                )
+                os.makedirs(zip_dir, exist_ok=True)
+                for sr in st['series']:
+                    try:
+                        zip_file = os.path.join(
+                            zip_dir, 
+                            f"Series__{sr['SeriesNumber']}__{sr['SeriesDescription']}.zip",
+                        )
+                        with zipfile.ZipFile(zip_file, 'w') as zipf:
+                            for rel_path in sr['instances'].values():
+                                file = os.path.join(self.path, rel_path)
+                                zipf.write(file, arcname=os.path.basename(file))
+                    except Exception as e:
+                        raise RuntimeError(
+                            f"Error extracting series {sr['SeriesDescription']} "
+                            f"in study {st['StudyDescription']} of patient {pt['PatientID']}."
+                        )
+
+
+
 
 def infer_slice_spacing(vols):
     # In case spacing between slices is not (correctly) encoded in 
@@ -761,8 +936,8 @@ def infer_slice_spacing(vols):
         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)
+        # Round to 10 micrometer and check if unique
+        distances = np.around(distances, 2)
         slice_spacing_d = np.unique(distances)
 
         # Check if unique - otherwise this is not a volume

{dbdicom-0.3.5 → dbdicom-0.3.7}/src/dbdicom/sop_classes/mr_image.py

@@ -1,6 +1,7 @@
 import os
 
 import numpy as np
+import vreg
 import pydicom
 from pydicom.dataset import FileMetaDataset, Dataset, FileDataset
 from pydicom.sequence import Sequence
@@ -53,18 +54,18 @@ def set_pixel_data(ds, array):
     ds.BitsStored = 16
     ds.HighBit = 15
 
-    # clipping may slow down a lot
-    #array = image.clip(array.astype(np.float32))
-    array = image.clip(array) # remove nan and infs
     if array.dtype==np.int16:
+        array = image.clip(array) # remove nan and infs
         ds.PixelRepresentation = 1
         ds.RescaleSlope = 1
         ds.RescaleIntercept = 0
     elif array.dtype==np.uint16:
+        array = image.clip(array) # remove nan and infs
         ds.PixelRepresentation = 0
         ds.RescaleSlope = 1
         ds.RescaleIntercept = 0
     else:
+        array = image.clip(array) # remove nan and infs
         array, slope, intercept = image.scale_to_range(array, ds.BitsStored)
         ds.PixelRepresentation = 0
         ds.RescaleSlope = 1 / slope
@@ -76,6 +77,7 @@ def set_pixel_data(ds, array):
     ds.PixelData = array.tobytes()
 
 
+
 def default(): # from the RIDER dataset
 
     # File meta info data elements

{dbdicom-0.3.5 → dbdicom-0.3.7}/src/dbdicom/utils/arrays.py

@@ -29,8 +29,12 @@ def _mesh_shape(sorted_array):
 
     if np.prod(shape) != sorted_array.size:
         raise ValueError(
-            'These are not mesh coordinates.'
-            'Make sure to specify dimensions for a multidimensional series.'
+            '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.5 → dbdicom-0.3.7}/src/dbdicom/utils/image.py

@@ -7,7 +7,7 @@ def affine_matrix(      # single slice function
     image_orientation,  # ImageOrientationPatient
     image_position,     # ImagePositionPatient
     pixel_spacing,      # PixelSpacing
-    slice_thickness):     # SliceThickness
+    slice_spacing):     # SpacingBetweenSlices
 
     row_spacing = pixel_spacing[0]
     column_spacing = pixel_spacing[1]
@@ -16,15 +16,10 @@ def affine_matrix(      # single slice function
     column_cosine = np.array(image_orientation[3:])
     slice_cosine = np.cross(row_cosine, column_cosine)
 
-    # This should not be addressed here
-    # # The coronal orientation has a left-handed reference frame
-    # if np.array_equal(np.around(image_orientation, 3), [1,0,0,0,0,-1]):
-    #     slice_cosine = -slice_cosine
-
     affine = np.identity(4, dtype=np.float32)
     affine[:3, 0] = row_cosine * column_spacing
     affine[:3, 1] = column_cosine * row_spacing
-    affine[:3, 2] = slice_cosine * slice_thickness
+    affine[:3, 2] = slice_cosine * slice_spacing
     affine[:3, 3] = image_position
     
     return affine 
@@ -91,8 +86,8 @@ def scale_to_range(array, bits_allocated, signed=False):
     else:
         slope = range / (maximum - minimum)
     intercept = -slope * minimum + minval
-    array *= slope
-    array += intercept
+    array = array * slope
+    array = array + intercept
 
     if bits_allocated == 8:
         if signed:

{dbdicom-0.3.5 → dbdicom-0.3.7/src/dbdicom.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbdicom
-Version: 0.3.5
+Version: 0.3.7
 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.5/src/dbdicom/__init__.py

@@ -1 +0,0 @@
-from dbdicom.api import *