imagedata 3.7.2.dev1__tar.gz → 3.8.0rc0__tar.gz

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/CHANGELOG.md

@@ -7,7 +7,50 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 <!--next-version-placeholder-->
 
-## [v3.7.2-dev1] - 2024-10-23
+## [v3.8.0-rc0] - 2025-03-25
+* Implemented n-dimensional Series data, axes and tags.
+
+## [v3.7.3-dev8] - 2025-03-07
+* Corrected parsing windows UNC path names with leading double slash.
+
+## [v3.7.3-dev7] - 2025-03-07
+* ZipFileArchive: Windows: Do not complain when temporary local file cannot be removed.
+* Improved some test suites to run better on Windows.
+
+## [v3.7.3-rc0] - 2025-01-06
+* Release candidate 3.7.3-rc0
+
+## [v3.7.3-dev6] - 2024-12-13
+* Series.__getitem__(): Accept tuple slicing specification, like ((2,),(2,),(2,)).
+
+## [v3.7.3-dev5] - 2024-12-12
+* Patient class: Limit the strict check of patient attributes to
+  patientName, patientID, patientBirthDate
+  and patientSex.
+
+## [v3.7.3-dev4] - 2024-12-04
+* evidence2roi: Do not raise exception for unknown roi type. Log a warning instead.
+
+## [v3.7.3-dev3] - 2024-11-26
+* Working on n-dimensional sorting.
+* Added code to sort series on diffusion gradient direction (b-vector),
+  and specifically diffusion RSI data.
+
+## [v3.7.3-dev2] - 2024-11-25
+* diffusion.py: Added code to get diffusion b value from Siemens E11 format.
+
+## [v3.7.3-dev1] - 2024-11-06
+* Viewer.viewport_set(): Fixed error where the viewport did not include the last image.
+
+## [v3.7.3-dev0] - 2024-11-04
+* XnatTransport.open(): Corrected scan search to search for series description,
+  not series number.
+
+## [v3.7.2] - 2024-10-28
+* Fixed viewing in jupyter notebook using backend `widget`.
+* Renamed collections.py to collection.py.
+* 
+## [v3.7.2-dev2] - 2024-10-25
 * Fixed viewing in jupyter notebook using backend `widget`.
 
 ## [v3.7.2-dev0] - 2024-10-10

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: imagedata
-Version: 3.7.2.dev1
+Version: 3.8.0rc0
 Summary: Read/write medical image data
 Author-email: Erling Andersen <Erling.Andersen@Helse-Bergen.NO>
 Maintainer-email: Erling Andersen <Erling.Andersen@Helse-Bergen.NO>
@@ -63,6 +63,7 @@ Requires-Dist: pillow>=10.0.0
 Requires-Dist: xnat
 Requires-Dist: matplotlib>=3.8.0
 Requires-Dist: opencv-python-headless
+Dynamic: license-file
 
 #########
 imagedata

imagedata-3.8.0rc0/VERSION.txt

@@ -0,0 +1 @@
+3.8.0-rc0

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/src/imagedata/apps/Siemens/evidence2mask.py

@@ -135,8 +135,28 @@ def evidence2roi(im, uid_table=None, content=None):
             roi_name = finding[(0x0029, 0x1030)].value
         except KeyError:
             roi_name = 'NONAME'
+        if roi_type_value not in (
+            'PolygonApplication3D', 'FreehandApplication3D',
+            'MarkerApplication3D', 'EllipseApplication3D',
+            'StandaloneTextApplication3D', 'DistanceLineApplication3D'
+        ):
+            # Attempt to find roi type in advanced presentation sequence (0029,1091)
+            try:
+                adv_pres_seq = finding[(0x0029, 0x1091)][0]
+                try:
+                    roi_type_value = adv_pres_seq[(0x0029, 0x108e)].value.decode()
+                    roi_name = finding[(0x0029, 0x1032)].value.decode()
+                except AttributeError:
+                    roi_type_value = adv_pres_seq[(0x0029, 0x108e)].value
+                    roi_name = finding[(0x0029, 0x1032)].value
+            except KeyError:
+                pass
         logger.info("Finding: {} {} {}".format(content['creator'], roi_name, roi_type_value))
-        if roi_type_value == 'PolygonApplication3D' or roi_type_value == 'FreehandApplication3D':
+        if roi_type_value in ('PolygonApplication3D', 'FreehandApplication3D', 'ROI2D'):
+            polygon = _get_measurement_points(finding[(0x0029, 0x1096)], zyx=True)
+            rois.append(PolygonROI(polygon, roi_name, stu_ins_uid, ser_ins_uid, sop_ins_uid))
+            logger.debug('ROI {}: {} points'.format(meas_appl_number, len(polygon) // 3))
+        elif roi_type_value == 'ROI2D':
             polygon = _get_measurement_points(finding[(0x0029, 0x1096)], zyx=True)
             rois.append(PolygonROI(polygon, roi_name, stu_ins_uid, ser_ins_uid, sop_ins_uid))
             logger.debug('ROI {}: {} points'.format(meas_appl_number, len(polygon) // 3))
@@ -159,7 +179,9 @@ def evidence2roi(im, uid_table=None, content=None):
             logger.warning("DistanceLineApplication3D ROI not implemented.")
             pass
         else:
-            raise ValueError("ROI type {} ({}) not implemented.".format(
-                roi_type_value, type(roi_type_value)))
+            logging.warning(
+                "ROI type {} ({}) not implemented.".format(
+                    roi_type_value, type(roi_type_value))
+            )
 
     return rois, content

imagedata-3.8.0rc0/src/imagedata/apps/diffusion.py

@@ -0,0 +1,341 @@
+"""Extract diffusion MRI parameters.
+"""
+# Copyright (c) 2013-2024 Erling Andersen, Haukeland University Hospital, Bergen, Norway
+
+import numpy as np
+import struct
+import warnings
+import pandas as pd
+from pydicom import Dataset
+from typing import SupportsFloat
+from ..series import Series
+from ..formats import NotImageError, CannotSort
+
+Number = type[SupportsFloat]
+
+
+def get_g_vectors(img):
+    """Get diffusion gradient vectors
+
+    Extracting diffusion gradient vectors has been tested on MRI data from some major vendors.
+
+    Args:
+        img (imagedata.Series): Series object.
+    Returns:
+        pd.DataFrame: Diffusion gradient vectors, columns b, z, y, x.
+    Raises:
+        IndexError: when no gradient vector is present in dataset.
+    Examples:
+        >>> from imagedata import Series
+        >>> from imagedata.apps.diffusion import get_g_vectors
+        >>> im = Series('data', 'b', opts={'accept_duplicate_tag': 'True'})
+        >>> g = get_g_vectors(im)
+        >>> print(g)
+                   b         z         y         x
+            0      0       NaN       NaN       NaN
+            1    500 -0.706399  0.000000  0.707814
+            2    500 -0.706399  0.000000 -0.707814
+            3    500 -0.706399 -0.707814  0.000000
+            4    500  0.707814 -0.706399  0.000000
+            5    500  0.000000 -0.707107  0.707107
+            6    500  0.000000 -0.707107 -0.707107
+            7   1000 -0.706752  0.000000  0.707461
+            8   1000 -0.706752  0.000000 -0.707461
+            9   1000 -0.706753 -0.707460  0.000000
+            10  1000  0.707460 -0.706754  0.000000
+            11  1000  0.001414 -0.707106  0.707106
+            12  1000  0.001414 -0.707106 -0.707106
+            13  2500 -0.706824  0.000000  0.707390
+
+    """
+
+    def get_DICOM_g_vector(ds):
+        # Attempt to address standard DICOM attributes
+        return ds['DiffusionGradientOrientation'].value
+
+    def get_Siemens_g_vector(ds):
+        block = ds.private_block(0x0019, 'SIEMENS MR HEADER')
+        return block[0x0e].value
+
+    def get_GEMS_g_vector(ds):
+        block = ds.private_block(0x0019, 'GEMS_ACQU_01')
+        return [block[0xbb].value, block[0xbc].value, block[0xbd].value]
+
+    _v = []
+    # Extract pydicom dataset for first slice and each tag
+    _dwi_weighted = False
+    for tag in range(img.shape[0]):
+        _b = get_b_value(img, tag)
+        _dwi_weighted = _dwi_weighted or not np.isnan(_b)
+        _G = [np.nan, np.nan, np.nan]
+        _ds: Dataset = img.dicomTemplate
+
+        for _method in [get_DICOM_g_vector, get_Siemens_g_vector, get_GEMS_g_vector]:
+            try:
+                _G = _method(_ds)
+                break
+            except KeyError:
+                pass
+
+        _v.append({'b': _b, 'z': _G[2], 'y': _G[1], 'x': _G[0]})
+    if _dwi_weighted:
+        return pd.DataFrame(_v)
+    else:
+        raise IndexError('No b values found in dataset')
+
+
+def get_b_value(img: Series) -> float:
+    """Get diffusion b value
+
+    Extracting diffusion b value has been tested on MRI data from some major vendors.
+
+    Args:
+        img (imagedata.Series): Series object.
+    Returns:
+        float: b value. Returns NaN when no b value is present in dataset.
+    """
+
+    # Extract pydicom dataset for given slice and tag
+    _ds: Dataset = img.dicomTemplate
+
+    return get_ds_b_value(_ds)
+
+
+def get_ds_b_vectors(ds: Dataset) -> np.ndarray:
+    """Get diffusion b vector from Dataset
+
+    Getting diffusion b vector has been tested on MRI data from some major vendors.
+
+    Args:
+        ds: Input dataset
+    Returns:
+        b vector
+
+    """
+
+    def get_DICOM_b_vector(_ds):
+        # Attempt to address standard DICOM attribute
+        raise NotImplementedError('get_DICOM_b_vector not implemented')
+        return _ds['DiffusionBValue'].value
+
+    def get_Siemens_b_vector(_ds):
+        raise NotImplementedError('get_Siemens_b_vector not implemented')
+        block = _ds.private_block(0x0019, 'SIEMENS MR HEADER')
+        return block[0x0c].value
+
+    def get_Siemens_CSA_b_vector(_ds):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=UserWarning)
+            import nibabel.nicom.csareader as csa
+        try:
+            csa_head = csa.get_csa_header(_ds)
+        except csa.CSAReadError:
+            raise CannotSort("Unable to extract b value from header.")
+        if 'tags' in csa_head and 'DiffusionGradientDirection' in csa_head['tags']:
+            bvec = csa_head['tags']['DiffusionGradientDirection']['items']
+            return np.array(bvec)
+        raise CannotSort("Unable to extract b value from header.")
+
+    def get_Siemens_E11_b_vector(_ds):
+        try:
+            block = _ds.private_block(0x0029, 'SIEMENS CSA HEADER')
+            im_info = block[0x10].value
+            # se_info = block[0x20].value
+            if im_info[:4] == b'SV10':
+                _h = _get_CSA2_header(im_info)
+            else:
+                _h = _get_CSA1_header(im_info)
+            return np.array(_h['DiffusionGradientDirection'])
+        except Exception:
+            raise IndexError('Cannot get b vector')
+
+    def get_GEMS_b_vector(_ds):
+        raise NotImplementedError('get_GEMS_b_vector not implemented')
+        block = _ds.private_block(0x0043, 'GEMS_PARM_01')
+        return block[0x39].value
+
+    errmsg = ""
+    for _method in [get_DICOM_b_vector,
+                    get_Siemens_b_vector, get_Siemens_CSA_b_vector,
+                    get_Siemens_E11_b_vector,
+                    get_GEMS_b_vector]:
+        try:
+            return _method(ds)
+        except (KeyError, IndexError) as e:
+            errmsg = '{}'.format(e)
+            pass
+        except NotImplementedError:
+            pass
+    raise IndexError('Cannot get b vector: {}'.format(errmsg))
+
+
+def get_ds_b_value(ds: Dataset) -> float:
+    """Get diffusion b value from Dataset
+
+    Setting diffusion b value has been tested on MRI data from some major vendors.
+
+    Args:
+        ds: Input dataset
+    Returns:
+        b value
+
+    """
+
+    def get_DICOM_b_value(_ds):
+        # Attempt to address standard DICOM attribute
+        return _ds['DiffusionBValue'].value
+
+    def get_Siemens_b_value(_ds):
+        block = _ds.private_block(0x0019, 'SIEMENS MR HEADER')
+        return block[0x0c].value
+
+    def get_Siemens_CSA_b_value(_ds):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=UserWarning)
+            import nibabel.nicom.csareader as csa
+        try:
+            csa_head = csa.get_csa_header(_ds)
+        except csa.CSAReadError:
+            raise CannotSort("Unable to extract b value from header.")
+        if csa_head is None:
+            raise CannotSort("Unable to extract b value from header.")
+        try:
+            value = csa.get_b_value(csa_head)
+        except TypeError:
+            raise CannotSort("Unable to extract b value from header.")
+        return value
+
+    def get_Siemens_E11_b_value(_ds):
+        try:
+            block = _ds.private_block(0x0029, 'SIEMENS CSA HEADER')
+            im_info = block[0x10].value
+            # se_info = block[0x20].value
+            if im_info[:4] == b'SV10':
+                _h = _get_CSA2_header(im_info)
+            else:
+                _h = _get_CSA1_header(im_info)
+            return float(_h['B_value'][0])
+        except Exception:
+            raise IndexError('Cannot get b value')
+
+    def get_GEMS_b_value(_ds):
+        block = _ds.private_block(0x0043, 'GEMS_PARM_01')
+        return block[0x39].value
+
+    errmsg = ""
+    for _method in [get_DICOM_b_value,
+                    get_Siemens_b_value, get_Siemens_CSA_b_value,
+                    get_Siemens_E11_b_value,
+                    get_GEMS_b_value]:
+        try:
+            return float(_method(ds))
+        except (KeyError, IndexError) as e:
+            errmsg = '{}'.format(e)
+            pass
+    raise IndexError('Cannot get b value: {}'.format(errmsg))
+
+
+def set_ds_b_value(ds: Dataset, value: Number):
+    """Set diffusion b value
+
+    Setting diffusion b value has been tested on MRI data from some major vendors.
+
+    Args:
+        ds (pydicom.Dataset): Dataset
+        value: b value
+    """
+
+    def set_DICOM_b_value(_ds, _value):
+        # Attempt to address standard DICOM attribute
+        _ds.DiffusionBValue = _value
+
+    def set_Siemens_b_value(_ds, _value):
+        block = _ds.private_block(0x0019, 'SIEMENS MR HEADER')
+        block[0x0c].value = _value
+
+    def set_GEMS_b_value(_ds, _value):
+        block = _ds.private_block(0x0043, 'GEMS_PARM_01')
+        block[0x39].value = _value
+
+    for _method in [set_DICOM_b_value, set_Siemens_b_value, set_GEMS_b_value]:
+        try:
+            _method(ds, value)
+            return
+        except (KeyError, IndexError):
+            pass
+    raise IndexError('Cannot set b value')
+
+
+def _get_CSA1_header(data):
+    values = {}
+    try:
+        (n_tags, unused2) = struct.unpack('<ii', data[:8])
+    except struct.error as e:
+        raise NotImageError('{}'.format(e))
+    except Exception as e:
+        # logging.debug('{}: exception\n{}'.format(_name, e))
+        raise NotImageError('{}'.format(e))
+    pos = 8
+    for t in range(n_tags):
+        try:
+            (name, vm, vr, syngodt, nitems, xx
+             ) = struct.unpack('<64si4s3i', data[pos:pos+84])
+            pos += 84
+            i = name.find(b'\0')
+            name = name[:i]
+            name = name.decode("utf-8")
+            values[name] = []
+            for _item in range(nitems):
+                (item_len, xx1, xx2, xx3
+                 ) = struct.unpack('<4i', data[pos:pos+16])
+                pos += 16
+                if item_len > 0:
+                    value = data[pos:pos+item_len]
+                    value = value.decode("utf-8").split('\0')[0].strip()
+                    pos += (item_len // 4) * 4
+                    if item_len % 4 > 0:
+                        pos += 4
+                    values[name].append(value)
+        except struct.error as e:
+            raise NotImageError('{}'.format(e))
+        except Exception as e:
+            raise
+    return values
+
+
+def _get_CSA2_header(data):
+    values = {}
+    try:
+        (hdr_id, unused1,
+         n_tags, unused2) = struct.unpack('<4siii', data[:16])
+    except struct.error as e:
+        raise NotImageError('{}'.format(e))
+    except Exception as e:
+        # logging.debug('{}: exception\n{}'.format(_name, e))
+        raise NotImageError('{}'.format(e))
+    pos = 16
+    for t in range(n_tags):
+        try:
+            (name, vm, vr, syngodt, nitems, xx
+             ) = struct.unpack('<64si4s3i', data[pos:pos+84])
+            pos += 84
+            i = name.find(b'\0')
+            name = name[:i]
+            name = name.decode("utf-8")
+            values[name] = []
+            for _item in range(nitems):
+                (item_len, xx1, xx2, xx3
+                 ) = struct.unpack('<4i', data[pos:pos+16])
+                pos += 16
+                if item_len > 0:
+                    value = data[pos:pos+item_len]
+                    value = value.decode("utf-8").split('\0')[0].strip()
+                    pos += (item_len // 4) * 4
+                    if item_len % 4 > 0:
+                        pos += 4
+                    values[name].append(value)
+        except struct.error as e:
+            raise NotImageError('{}'.format(e))
+        except Exception as e:
+            raise
+    return values

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/src/imagedata/archives/zipfilearchive.py

@@ -64,7 +64,10 @@ class WriteFileIO(io.FileIO):
         ret = super(WriteFileIO, self).close()
         if isinstance(self.__local_file, str):
             self.__archive.write(self.__local_file, self.__filename)
-            os.remove(self.__local_file)
+            try:
+                os.remove(self.__local_file)
+            except PermissionError:
+                pass
         else:
             self.__local_file.close()
             logger.debug("{}: zip {} as {}".format(
@@ -74,7 +77,10 @@ class WriteFileIO(io.FileIO):
             logger.debug("{}: remove {}".format(
                 _name, self.__local_file.name)
             )
-            os.remove(self.__local_file.name)
+            try:
+                os.remove(self.__local_file.name)
+            except PermissionError:
+                pass
         return ret
 
     def __enter__(self):

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/src/imagedata/axis.py

@@ -279,7 +279,11 @@ class VariableAxis(Axis):
         """Return a copy of the axis, where the length n can be different."""
         name = self.name if name is None else name
         n = len(self._values) if n is None else n
-        return VariableAxis(name, np.array(self._values[:n]))
+        _values = self._values.tolist()
+        while len(_values) < n:
+            delta = _values[-1] - _values[-2] if len(_values) >= 2 else 1
+            _values.append(_values[-1] + delta)
+        return VariableAxis(name, _values[:n])
 
     @overload
     def __getitem__(self, index: int) -> Number:

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/src/imagedata/cmdline.py

@@ -8,7 +8,7 @@ import ast
 import copy
 import logging
 from . import __version__
-from .formats import str_to_sort_on, str_to_input_order, str_to_dtype
+from .formats import str_to_sort_on, str_to_dtype
 from .formats import SORT_ON_SLICE
 from .formats import INPUT_ORDER_AUTO
 
@@ -80,7 +80,7 @@ class InputOrderAction(argparse.Action):
 
     def __call__(self, _parser, namespace, values, option_string=None):
         # print('%r %r %r' % (namespace, values, option_string))
-        input_order = str_to_input_order(values)
+        input_order = values
         setattr(namespace, self.dest, input_order)
 
 

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/src/imagedata/collection.py

@@ -425,6 +425,8 @@ class Patient(IndexedDict):
                    'patientIdentityRemoved', 'deidentificationMethod'
                    ]
 
+    _strict_attributes = ['patientName', 'patientID', 'patientBirthDate', 'patientSex']
+
     def __init__(self, data, opts=None, **kwargs):
 
         super(Patient, self).__init__()
@@ -478,6 +480,7 @@ class Patient(IndexedDict):
                 if getattr(self, _attr, None) is None:
                     setattr(self, _attr, _value)
                 elif _strict_values and \
+                        _attr in self._strict_attributes and \
                         getattr(self, _attr, None) != _value:
                     # Patient attributes differ, should be considered an exception.
                     raise ValueError('Patient attribute "{}" differ ("{}" vs. "{}")'.format(

{imagedata-3.7.2.dev1 → imagedata-3.8.0rc0}/src/imagedata/formats/__init__.py

@@ -20,10 +20,13 @@ INPUT_ORDER_AUTO = 'auto'
 INPUT_ORDER_NONE = 'none'
 INPUT_ORDER_TIME = 'time'
 INPUT_ORDER_B = 'b'
+INPUT_ORDER_BVECTOR = 'bvector'
+INPUT_ORDER_RSI = 'rsi'
 INPUT_ORDER_FA = 'fa'
 INPUT_ORDER_TE = 'te'
 INPUT_ORDER_FAULTY = 'faulty'
-input_order_set = {INPUT_ORDER_NONE, INPUT_ORDER_TIME, INPUT_ORDER_B, INPUT_ORDER_FA,
+input_order_set = {INPUT_ORDER_NONE, INPUT_ORDER_TIME, INPUT_ORDER_B, INPUT_ORDER_BVECTOR,
+                   INPUT_ORDER_RSI, INPUT_ORDER_FA,
                    INPUT_ORDER_TE, INPUT_ORDER_FAULTY}
 
 
@@ -104,63 +107,6 @@ def str_to_dtype(s):
         raise (ValueError("Output data type {} not implemented.".format(s)))
 
 
-def input_order_to_str(input_order):
-    if input_order == INPUT_ORDER_NONE:
-        return "INPUT_ORDER_NONE"
-    elif input_order == INPUT_ORDER_TIME:
-        return "INPUT_ORDER_TIME"
-    elif input_order == INPUT_ORDER_B:
-        return "INPUT_ORDER_B"
-    elif input_order == INPUT_ORDER_FA:
-        return "INPUT_ORDER_FA"
-    elif input_order == INPUT_ORDER_TE:
-        return "INPUT_ORDER_TE"
-    elif input_order == INPUT_ORDER_FAULTY:
-        return "INPUT_ORDER_FAULTY"
-    elif issubclass(type(input_order), str):
-        return input_order
-    else:
-        raise (UnknownTag("Unknown numerical input_order {:d}.".format(input_order)))
-
-
-def input_order_to_dirname_str(input_order):
-    if input_order == INPUT_ORDER_NONE:
-        return "none"
-    elif input_order == INPUT_ORDER_TIME:
-        return "time"
-    elif input_order == INPUT_ORDER_B:
-        return "b"
-    elif input_order == INPUT_ORDER_FA:
-        return "fa"
-    elif input_order == INPUT_ORDER_TE:
-        return "te"
-    elif input_order == INPUT_ORDER_FAULTY:
-        return "faulty"
-    elif issubclass(type(input_order), str):
-        keepcharacters = ('-', '_', '.', ' ')
-        return ''.join([c for c in input_order if c.isalnum() or c in keepcharacters]).rstrip()
-    else:
-        raise (UnknownTag("Unknown numerical input_order {:d}.".format(input_order)))
-
-
-def str_to_input_order(s):
-    if s == "none":
-        return INPUT_ORDER_NONE
-    elif s == "time":
-        return INPUT_ORDER_TIME
-    elif s == "b":
-        return INPUT_ORDER_B
-    elif s == "fa":
-        return INPUT_ORDER_FA
-    elif s == "te":
-        return INPUT_ORDER_TE
-    elif s == "faulty":
-        return INPUT_ORDER_FAULTY
-    else:
-        # raise (UnknownTag("Unknown input order {}.".format(s)))
-        return s
-
-
 def shape_to_str(shape):
     """Convert numpy image shape to printable string