imagedata 3.8.15__tar.gz → 3.9.0.dev3__tar.gz

{imagedata-3.8.15 → imagedata-3.9.0.dev3}/CHANGELOG.md

@@ -6,6 +6,31 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 <!--next-version-placeholder-->
+## [v3.9.0-dev3] - 2026-05-21
+### Fixed
+* Series.__getitem__(): Slice the tags even when there is no tag axis.
+* DICOMPLUGIN._join_axes(): Only accept tag axes of length > 1.
+
+## [v3.9.0-dev2] - 2026-05-20
+* Support for python 3.14
+
+## [v3.9.0-rc1] - 2026-05-20
+### Added
+* VariableAxis: Accept list of tuples as values.
+* DICOMPlugin: Implement setting DTI tuple (b, bvector).
+### Fixed
+* Sorting av duplicate tags fixed.
+
+## [v3.9.0-rc0] - 2026-05-19
+### Added
+* DICOMPlugin: Sort DTI series where tags are (b, bvector) tuple.
+### Changed
+* DICOMPlugin: Refactored sorting of n-dimensional datasets.
+
+## [v3.8.16-dev0] - 2026-05-15
+### Changed
+* DICOMPlugin: Refactored sorting of n-dimensional datasets.
+
 ## [v3.8.15] - 2026-05-15
 
 ## [v3.8.15-dev4] - 2026-05-15

{imagedata-3.8.15 → imagedata-3.9.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imagedata
-Version: 3.8.15
+Version: 3.9.0.dev3
 Summary: Read/write medical image data
 Author-email: Erling Andersen <Erling.Andersen@Helse-Bergen.NO>
 Maintainer-email: Erling Andersen <Erling.Andersen@Helse-Bergen.NO>

imagedata-3.9.0.dev3/VERSION.txt

@@ -0,0 +1 @@
+3.9.0-dev3

{imagedata-3.8.15 → imagedata-3.9.0.dev3}/docs/Sorting.rst

@@ -36,6 +36,7 @@ Several sort criteria are predefined:
 * triggertime: Sort on Trigger Time
 * b: Sort on MR diffusion b-value
 * bvector: Sort on MR diffusion b vector
+* dti: Sort on MR DTI (b, b vector) tuple
 * fa: Sort on MR Flip Angle
 * te: Sort on MR Echo Time
 
@@ -103,6 +104,25 @@ Trigger Time is the sorting criteria:
         trigger=get_TriggerTime)
     )
 
+MRI DTI sorting
+---------------
+
+MRI diffusion tensor images (DTI) are sorted on diffusion b-value and b-vectors.
+The tags (b, bvector) are tuples.
+
+.. code-block:: python
+
+    img = Series('dti', input_order='dti', input_format='dicom')
+    tags = img.tags[0]
+    for idx in np.ndindex(tags.shape):
+        try:
+            b, bvector = tags[idx]
+        except TypeError:
+            continue
+        dti = img[idx]
+        print(b, bvector, dti.shape)
+
+
 N-dimensional sorting
 ---------------------
 
@@ -115,7 +135,8 @@ A dynamic dual-echo MR acquisition can be sorted on time and echo time into a 5D
 
     img = Series('dyn_dual_echo', input_order='time,te')
 
-In particular, MR RSI diffusion data can be sorted on `b` value and `b` vector:
+In particular, MR RSI diffusion data can be sorted on `b` value and `b` vector
+(remember that the `dti` sort criteria can be used to sort these data as 4D):
 
 .. code-block:: python
 

{imagedata-3.8.15 → imagedata-3.9.0.dev3}/src/imagedata/archives/__init__.py

@@ -3,12 +3,10 @@
 Standard plugins provide support for local filesystem and zip archives.
 """
 
-# Copyright (c) 2018-2024 Erling Andersen, Haukeland University Hospital, Bergen, Norway
+# Copyright (c) 2018-2026 Erling Andersen, Haukeland University Hospital, Bergen, Norway
 
-import os.path
 import logging
 import urllib.parse
-import fnmatch
 from ..transports import Transport
 
 logger = logging.getLogger(__name__)

{imagedata-3.8.15 → imagedata-3.9.0.dev3}/src/imagedata/axis.py

@@ -258,7 +258,11 @@ class VariableAxis(Axis):
 
     def __init__(self, name: str, values: Sequence) -> None:
         super(VariableAxis, self).__init__(name)
-        if issubclass(type(values[0]), Sequence):
+        if issubclass(type(values[0]), tuple):
+            self._values = np.ndarray(len(values), dtype=tuple)
+            for i, value in enumerate(values):
+                self._values[i] = value
+        elif issubclass(type(values[0]), Sequence):
             self._values = np.ndarray(len(values), dtype=np.ndarray)
             for i, value in enumerate(values):
                 self._values[i] = np.array(value)

{imagedata-3.8.15 → imagedata-3.9.0.dev3}/src/imagedata/collection.py

@@ -453,9 +453,7 @@ class Study(IndexedDict):
                 raise Exception(_url) from e
 
     def anonymize(self, uid_table: dict = {}, actions: dict = {}, **kwargs):
-        _actions = {
-
-        } | actions
+        _actions = {} | actions
         rules = anonymization_rules | kwargs
         if rules['studyTime'] is None:
             rules['studyTime'] = self.studyTime
@@ -667,9 +665,7 @@ class Patient(IndexedDict):
                     raise Exception(_url) from e
 
     def anonymize(self, uid_table: dict = {}, actions: dict = {}, **kwargs):
-        _actions = {
-
-                   } | actions
+        _actions = {} | actions
         rules = anonymization_rules | kwargs
         _copy = Patient(None)
         for _rule in rules:
@@ -851,10 +847,9 @@ class Cohort(IndexedDict):
                         _series.write(_url, opts=opts, formats=formats)
                     except Exception as e:
                         raise Exception(_url) from e
-    def anonymize(self, uid_table: dict = {}, actions: dict = {}, **kwargs):
-        _actions = {
 
-                   } | actions
+    def anonymize(self, uid_table: dict = {}, actions: dict = {}, **kwargs):
+        _actions = {} | actions
         rules = anonymization_rules | kwargs
         _copy = Cohort(None)
         for _rule in rules:

{imagedata-3.8.15 → imagedata-3.9.0.dev3}/src/imagedata/formats/__init__.py

@@ -3,7 +3,7 @@
 Standard plugins provides support for DICOM and Nifti image file formats.
 """
 
-# Copyright (c) 2013-2024 Erling Andersen, Haukeland University Hospital, Bergen, Norway
+# Copyright (c) 2013-2026 Erling Andersen, Haukeland University Hospital, Bergen, Norway
 
 import os
 import sys
@@ -23,11 +23,13 @@ INPUT_ORDER_TIME = 'time'
 INPUT_ORDER_TRIGGERTIME = 'triggertime'
 INPUT_ORDER_B = 'b'
 INPUT_ORDER_BVECTOR = 'bvector'
+INPUT_ORDER_DTI = 'dti'
 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_BVECTOR,
+                   INPUT_ORDER_DTI,
                    INPUT_ORDER_RSI, INPUT_ORDER_FA, INPUT_ORDER_TRIGGERTIME,
                    INPUT_ORDER_TE, INPUT_ORDER_FAULTY}
 

imagedata-3.9.0.dev3/src/imagedata/formats/dicomlib/datatypes.py

@@ -0,0 +1,269 @@
+"""
+Data types
+==========
+
+SourceList: A list of source input urls.
+    SourceList is list[dict].
+            - 'archive'  : archive plugin
+            - 'files'    : list of file names or regexp. May be empty list.
+    SourceList is provided by a calling party.
+
+class ObjectList: A list of all source objects.
+    ObjectList is list[tuple[AbstractArchive, Member]]
+    ObjectList is collected by self._get_dicom_files().
+    - _get_dicom_files() collects all DICOM objects from input sources.
+      The DICOM objects are not sorted.
+
+class DatasetList: A list of all source Instance objects.
+    DatasetList is list[Instance]
+    DatasetList is collected by self._extract_member.
+
+class DatasetDict: The source Instances are sorted according to SeriesUID.
+    DatasetDict is defaultdict[SeriesUID, DatasetList]
+    DatasetDict is collected by self._catalog_on_instance_uid(), and
+      processed by self._select_imaging_datasets() and
+      self._select_non_imaging_datasets().
+    - _catalog_on_instance_uid() takes an ObjectList and sort objects on
+      SeriesUID.
+    - _select_imaging_datasets() takes a DatasetDict and return the imaging
+      datasets only.
+    - _select_non_imaging_datasets() takes a DatasetDict and return the
+      non-imaging datasets only.
+
+class SortedDatasetList: Collection of DatasetLists for each slice location (float).
+    Sorted by slice location and tag.
+    SortedDatasetList is defaultdict[float, DatasetList]
+    SortedDatasetList is constructed by self._sort_dataset_geometry(),
+    and collected by self._sort_datasets().
+    SortedDatasetList is processed by self._get_headers._extract_all_tags(),
+    self._sort_dataset_geometry(), and _verify_spacing().
+    SortedHeaderDict is collected by self._get_headers()
+      and self._get_non_image_headers().
+
+class SortedData: A tuple of SortedDatasetList and Header.
+    SortedDataDict is collected by self._sort_datasets() (see
+    SortedDataDict).
+
+class SortedDataDict: Collection of SortedData, key is SeriesUID.
+    SortedDataDict is defaultdict[SeriesUID, SortedData]
+    SortedDataDict is collected by self._sort_datasets() (see
+      SortedDatasetList).
+    self._process_image_members() NOT in use.
+
+class SortedHeaderDict: Collection of Headers, key is SeriesUID.
+    SortedHeaderDict is dict[SeriesUID, Header]
+    SortedHeaderDict is collected by self._get_headers()
+      and self._get_non_image_headers().
+
+class PixelDict: Collection of pixel data arrays, key is SeriesUID.
+    PixelDict is dict[SeriesUID, np.ndarray]
+    PixelDict is collected by self._construct_pixel_arrays().
+"""
+
+import logging
+from collections import defaultdict, namedtuple
+import numpy as np
+from ...archives.abstractarchive import AbstractArchive, Member
+from .instance import Instance
+from ...header import Header
+
+
+logger = logging.getLogger(__name__)
+
+
+# Type definitions
+SourceList = list[dict]
+
+SeriesUID = namedtuple('SeriesUID', 'patientID, studyInstanceUID, seriesInstanceUID, ' +
+                       'acquisitionNumber, echoNumber', defaults=(None, None))
+
+
+# Class definitions
+class ObjectList(list):
+    """ObjectList is list[tuple[AbstractArchive, Member]]"""
+
+    def __init__(self):
+        super().__init__()
+
+    def append(self, *args):
+        for arg in args:
+            assert isinstance(arg, tuple), self.__doc__
+            assert len(arg) == 2, self.__doc__
+            assert isinstance(arg[0], AbstractArchive), self.__doc__
+            assert isinstance(arg[1], Member), self.__doc__
+        super().append(*args)
+
+
+class DatasetList(list):
+    """DatasetList is list[Instance]"""
+
+    def __init__(self):
+        super().__init__()
+
+    def __str__(self):
+        """Get printable description of series"""
+        dataset = self[0]
+        try:
+            message = '{} ({})'.format(dataset.SeriesDescription, dataset.SeriesNumber)
+        except AttributeError:
+            try:
+                message = '{} ({})'.format('', dataset.SeriesNumber)
+            except AttributeError:
+                message = '{}'.format(dataset.SeriesInstanceUID)
+        return message
+
+    def append(self, *args):
+        for arg in args:
+            assert isinstance(arg, Instance), self.__doc__
+        super().append(*args)
+
+    def getDicomAttribute(self, tag):
+        instance: Instance = self[0]
+        return instance[tag].value
+
+    def getDicomAttributeValues(self, tag) -> list:
+        values = []
+        instance: Instance
+        for instance in self:
+            try:
+                values.append(instance[tag].value)
+            except KeyError:
+                pass
+        return values
+
+    def get_image_orientation_patient(self) -> np.ndarray:
+        instance: Instance = self[0]
+        return instance.get_image_orientation_patient()
+
+    def get_image_position_patient(self) -> np.ndarray:
+        instance: Instance = self[0]
+        return instance.get_image_position_patient()
+
+
+class DatasetDict(defaultdict):
+    """DatasetDict is defaultdict[SeriesUID, DatasetList]"""
+
+    def __init__(self):
+        super().__init__(DatasetList)
+
+    def __setitem__(self, key, value):
+        assert isinstance(key, SeriesUID), self.__doc__
+        assert isinstance(value, DatasetList), self.__doc__
+        super().__setitem__(key, value)
+
+
+class SortedDatasetList(defaultdict):
+    """SortedDatasetList is defaultdict[float, DatasetList]"""
+
+    def __init__(self):
+        super().__init__(DatasetList)
+        self.axes = None
+        self.spacing = None
+        self.transformationMatrix = None
+        self.imagePositions = None
+
+    def __setitem__(self, key, value):
+        assert isinstance(key, float), self.__doc__
+        assert isinstance(value, DatasetList), self.__doc__
+        super().__setitem__(key, value)
+
+    def __str__(self):
+        """Get printable description of series"""
+        dataset: DatasetList = self[next(iter(self))][0]
+        try:
+            message = '{} ({})'.format(dataset.SeriesDescription, dataset.SeriesNumber)
+        except AttributeError:
+            try:
+                message = '{} ({})'.format('', dataset.SeriesNumber)
+            except AttributeError:
+                message = '{}'.format(dataset.SeriesInstanceUID)
+        return message
+
+    def get_headers(self) -> Header:
+        """Extract DICOM attributes
+
+        Args:
+            self: DICOMPlugin instance
+            sorted_dataset_list: SortedDatasetList
+            hdr: existing header (Header)
+            message: series description
+            opts:
+        Returns:
+            hdr: header
+                - seriesNumber
+                - seriesDescription
+                - imageType
+                - spacing
+                - orientation
+                - imagePositions
+                - axes
+                - modality, laterality, protocolName, bodyPartExamined
+                - seriesDate, seriesTime, patientPosition
+        """
+        dataset = self[next(iter(self))][0]
+        hdr = Header()
+        hdr.input_format = 'dicom'
+        dataset.copy_attributes_to_header(hdr)
+
+        # Extract geometry
+        hdr.axes = self.axes
+        hdr.orientation = dataset.get_image_orientation_patient()
+        hdr.imagePositions = self.imagePositions
+        hdr.transformationMatrix = self.transformationMatrix
+        hdr.spacing = self.spacing
+
+        hdr.color = False
+        if 'SamplesPerPixel' in dataset and dataset.SamplesPerPixel == 3:
+            hdr.color = True
+
+        # Testing IPP and transformationMatrix
+        T0 = hdr.transformationMatrix[:3, 3]
+        ipp = np.array(T0)
+        warned = False
+        for i in range(len(self)):
+            if not warned and not np.allclose(ipp, hdr.imagePositions[i], rtol=1e-3):
+                logger.warning(f'{self}: DICOM ImagePosition is inconsistent with ImageOrientation')
+                warned = True
+            ipp += hdr.transformationMatrix[:3, 0]
+        return hdr
+
+
+SortedData = tuple[SortedDatasetList, Header]
+
+
+class SortedDataDict(defaultdict):
+    """SortedDataDict is defaultdict[SeriesUID, SortedData]"""
+
+    def __init__(self):
+        super().__init__(lambda: SortedData)
+
+    def __setitem__(self, key, value):
+        assert isinstance(key, SeriesUID), self.__doc__
+        assert isinstance(value, tuple), self.__doc__
+        super().__setitem__(key, value)
+
+
+class SortedHeaderDict(dict):
+    """SortedHeaderDict is dict[SeriesUID, Header]"""
+
+    def __init__(self):
+        super().__init__()
+
+    def __setitem__(self, key, value):
+        assert isinstance(key, SeriesUID), self.__doc__
+        assert isinstance(value, Header), self.__doc__
+        super().__setitem__(key, value)
+
+
+class PixelDict(dict):
+    """PixelDict is dict[SeriesUID, np.ndarray]"""
+
+    def __init__(self):
+        super().__init__()
+
+    def __setitem__(self, key, value):
+        assert isinstance(key, SeriesUID), self.__doc__
+        assert isinstance(value, np.ndarray), self.__doc__
+        super().__setitem__(key, value)
+
+