dbdicom 0.2.0__py3-none-any.whl → 0.3.16__py3-none-any.whl

dbdicom/sop_classes/segmentation.py

@@ -0,0 +1,311 @@
+import numpy as np
+import pydicom
+from pydicom.dataset import Dataset, FileDataset
+from pydicom.sequence import Sequence
+import datetime
+
+
+def create_binary_segmentation_dicom(rows=128, cols=128):
+    # Create file metadata
+    meta = Dataset()
+    meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.66.4'  # Segmentation Storage
+    meta.MediaStorageSOPInstanceUID = pydicom.uid.generate_uid()
+    meta.TransferSyntaxUID = pydicom.uid.ExplicitVRLittleEndian
+    meta.ImplementationClassUID = pydicom.uid.generate_uid()
+
+    # Create the FileDataset (in memory)
+    ds = FileDataset(None, {}, file_meta=meta, preamble=b"\0" * 128)
+    ds.is_little_endian = True
+    ds.is_implicit_VR = False
+
+    # Required general attributes
+    ds.SOPClassUID = meta.MediaStorageSOPClassUID
+    ds.SOPInstanceUID = meta.MediaStorageSOPInstanceUID
+    ds.Modality = 'SEG'
+    ds.SeriesInstanceUID = pydicom.uid.generate_uid()
+    ds.StudyInstanceUID = pydicom.uid.generate_uid()
+    ds.FrameOfReferenceUID = pydicom.uid.generate_uid()
+    ds.PatientName = 'Seg^Test'
+    ds.PatientID = 'SEG001'
+
+    # Set content date/time
+    dt = datetime.datetime.now()
+    ds.ContentDate = dt.strftime('%Y%m%d')
+    ds.ContentTime = dt.strftime('%H%M%S.%f')[:13]
+
+    # Segmentation-specific
+    ds.SegmentationType = 'BINARY'
+    ds.ContentLabel = 'MASK'
+    ds.ContentDescription = 'Binary segmentation mask'
+    ds.ContentCreatorName = 'AutoGen'
+
+    ds.Rows = rows
+    ds.Columns = cols
+    ds.SamplesPerPixel = 1
+    ds.BitsAllocated = 1
+    ds.BitsStored = 1
+    ds.HighBit = 0
+    ds.PixelRepresentation = 0
+    ds.PhotometricInterpretation = 'MONOCHROME2'
+    ds.NumberOfFrames = 1
+    ds.BurnedInAnnotation = 'NO'
+    ds.ImageType = ['DERIVED', 'PRIMARY']
+
+    # Create a dummy mask (circle in center)
+    Y, X = np.ogrid[:rows, :cols]
+    mask = ((X - cols // 2)**2 + (Y - rows // 2)**2) < (min(rows, cols) // 4)**2
+    binary_frame = np.packbits(mask.astype(np.uint8).flatten())
+
+    # Assign Pixel Data
+    ds.PixelData = binary_frame.tobytes()
+
+    # SegmentSequence: define what the mask means
+    segment = Dataset()
+    segment.SegmentNumber = 1
+    segment.SegmentLabel = 'Kidney'
+    segment.SegmentAlgorithmType = 'MANUAL'
+    segment.SegmentAlgorithmName = 'ManualDraw'
+
+    segment.SegmentedPropertyCategoryCodeSequence = Sequence([Dataset()])
+    segment.SegmentedPropertyCategoryCodeSequence[0].CodeValue = 'T-D0050'
+    segment.SegmentedPropertyCategoryCodeSequence[0].CodingSchemeDesignator = 'SRT'
+    segment.SegmentedPropertyCategoryCodeSequence[0].CodeMeaning = 'Tissue'
+
+    segment.SegmentedPropertyTypeCodeSequence = Sequence([Dataset()])
+    segment.SegmentedPropertyTypeCodeSequence[0].CodeValue = 'T-71000'
+    segment.SegmentedPropertyTypeCodeSequence[0].CodingSchemeDesignator = 'SRT'
+    segment.SegmentedPropertyTypeCodeSequence[0].CodeMeaning = 'Kidney'
+
+    ds.SegmentSequence = Sequence([segment])
+
+    # Functional groups (Plane Position)
+    fg = Dataset()
+    pp = Dataset()
+    pp.ImagePositionPatient = [0.0, 0.0, 0.0]
+    fg.PlanePositionSequence = Sequence([pp])
+    ds.PerFrameFunctionalGroupsSequence = Sequence([fg])
+
+    return ds
+
+
+
+
+def create_multi_segment_segmentation_dicom(masks_dict, spacing=(1.0, 1.0), origin=(0.0, 0.0, 0.0)):
+    """
+    Create a multi-segment binary DICOM Segmentation object.
+
+    Parameters:
+    - masks_dict: dict of {label: binary 2D NumPy array}
+    - spacing: (row_spacing, col_spacing)
+    - origin: (x, y, z) ImagePositionPatient
+
+    Returns:
+    - pydicom FileDataset object
+    """
+
+    labels = list(masks_dict.keys())
+    first_mask = next(iter(masks_dict.values()))
+    rows, cols = first_mask.shape
+
+    # Create metadata
+    meta = Dataset()
+    meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.66.4'
+    meta.MediaStorageSOPInstanceUID = pydicom.uid.generate_uid()
+    meta.TransferSyntaxUID = pydicom.uid.ExplicitVRLittleEndian
+    meta.ImplementationClassUID = pydicom.uid.generate_uid()
+
+    ds = FileDataset(None, {}, file_meta=meta, preamble=b"\0" * 128)
+    ds.is_little_endian = True
+    ds.is_implicit_VR = False
+
+    # Required general attributes
+    ds.SOPClassUID = meta.MediaStorageSOPClassUID
+    ds.SOPInstanceUID = meta.MediaStorageSOPInstanceUID
+    ds.Modality = 'SEG'
+    ds.SeriesInstanceUID = pydicom.uid.generate_uid()
+    ds.StudyInstanceUID = pydicom.uid.generate_uid()
+    ds.FrameOfReferenceUID = pydicom.uid.generate_uid()
+    ds.PatientName = 'Seg^Multi'
+    ds.PatientID = 'MULTISEG001'
+    ds.ContentDate = datetime.datetime.now().strftime('%Y%m%d')
+    ds.ContentTime = datetime.datetime.now().strftime('%H%M%S.%f')[:13]
+
+    ds.Rows = rows
+    ds.Columns = cols
+    ds.SamplesPerPixel = 1
+    ds.BitsAllocated = 1
+    ds.BitsStored = 1
+    ds.HighBit = 0
+    ds.PixelRepresentation = 0
+    ds.PhotometricInterpretation = 'MONOCHROME2'
+    ds.SegmentationType = 'BINARY'
+    ds.BurnedInAnnotation = 'NO'
+    ds.ImageType = ['DERIVED', 'PRIMARY']
+    ds.ContentLabel = 'MULTI_SEG'
+    ds.ContentCreatorName = 'AutoGen'
+
+    # SegmentSequence
+    segment_sequence = []
+    pixel_data_bytes = b''
+    fg_sequence = []
+
+    for i, label in enumerate(labels):
+        segment = Dataset()
+        segment.SegmentNumber = i + 1
+        segment.SegmentLabel = label
+        segment.SegmentAlgorithmType = 'MANUAL'
+        segment.SegmentAlgorithmName = 'ManualDraw'
+
+        # Use generic SRT codes for tissue/organ
+        segment.SegmentedPropertyCategoryCodeSequence = Sequence([Dataset()])
+        segment.SegmentedPropertyCategoryCodeSequence[0].CodeValue = 'T-D0050'
+        segment.SegmentedPropertyCategoryCodeSequence[0].CodingSchemeDesignator = 'SRT'
+        segment.SegmentedPropertyCategoryCodeSequence[0].CodeMeaning = 'Tissue'
+
+        segment.SegmentedPropertyTypeCodeSequence = Sequence([Dataset()])
+        segment.SegmentedPropertyTypeCodeSequence[0].CodeValue = 'T-00000'
+        segment.SegmentedPropertyTypeCodeSequence[0].CodingSchemeDesignator = '99LOCAL'
+        segment.SegmentedPropertyTypeCodeSequence[0].CodeMeaning = label
+
+        segment_sequence.append(segment)
+
+        # Mask -> 1-bit packed frame
+        mask = masks_dict[label]
+        assert mask.shape == (rows, cols), f"Shape mismatch for label '{label}'"
+        packed = np.packbits(mask.astype(np.uint8).flatten())
+        pixel_data_bytes += packed.tobytes()
+
+        # Per-frame functional group (Plane Position and Segment Identification)
+        fg = Dataset()
+
+        # Plane Position
+        pp = Dataset()
+        pp.ImagePositionPatient = [float(origin[0]), float(origin[1]), float(origin[2] + i)]
+        fg.PlanePositionSequence = Sequence([pp])
+
+        # Segment Identification
+        si = Dataset()
+        si.ReferencedSegmentNumber = i + 1
+        fg.SegmentIdentificationSequence = Sequence([si])
+
+        fg_sequence.append(fg)
+
+
+
+def create_multiframe_segmentation(masks_dict, pixel_spacing=(1.0, 1.0), slice_thickness=1.0, origin=(0.0, 0.0, 0.0)):
+    """
+    Create a DICOM Segmentation object with multiple frames per segment (e.g., 3D masks).
+    
+    Parameters:
+        masks_dict: dict {label: 3D numpy array (Z, Y, X)}
+        pixel_spacing: tuple of (row_spacing, col_spacing)
+        slice_thickness: float
+        origin: tuple of (x, y, z)
+    """
+    labels = list(masks_dict.keys())
+    first_volume = next(iter(masks_dict.values()))
+    num_slices, rows, cols = first_volume.shape
+
+    meta = Dataset()
+    meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.66.4'
+    meta.MediaStorageSOPInstanceUID = pydicom.uid.generate_uid()
+    meta.TransferSyntaxUID = pydicom.uid.ExplicitVRLittleEndian
+    meta.ImplementationClassUID = pydicom.uid.generate_uid()
+
+    ds = FileDataset(None, {}, file_meta=meta, preamble=b"\0" * 128)
+    ds.is_little_endian = True
+    ds.is_implicit_VR = False
+
+    ds.SOPClassUID = meta.MediaStorageSOPClassUID
+    ds.SOPInstanceUID = meta.MediaStorageSOPInstanceUID
+    ds.Modality = 'SEG'
+    ds.SeriesInstanceUID = pydicom.uid.generate_uid()
+    ds.StudyInstanceUID = pydicom.uid.generate_uid()
+    ds.FrameOfReferenceUID = pydicom.uid.generate_uid()
+    ds.PatientName = 'Seg^3D'
+    ds.PatientID = 'SEG3D001'
+    dt = datetime.datetime.now()
+    ds.ContentDate = dt.strftime('%Y%m%d')
+    ds.ContentTime = dt.strftime('%H%M%S.%f')[:13]
+
+    ds.Rows = rows
+    ds.Columns = cols
+    ds.SamplesPerPixel = 1
+    ds.BitsAllocated = 1
+    ds.BitsStored = 1
+    ds.HighBit = 0
+    ds.PixelRepresentation = 0
+    ds.PhotometricInterpretation = 'MONOCHROME2'
+    ds.SegmentationType = 'BINARY'
+    ds.BurnedInAnnotation = 'NO'
+    ds.ImageType = ['DERIVED', 'PRIMARY']
+    ds.ContentLabel = 'MULTIFRAME_SEG'
+    ds.ContentCreatorName = 'AutoGen'
+
+    ds.NumberOfFrames = num_slices * len(labels)
+
+    pixel_data_bytes = b''
+    segment_sequence = []
+    per_frame_sequence = []
+
+    for seg_index, label in enumerate(labels):
+        vol = masks_dict[label]
+        assert vol.shape == (num_slices, rows, cols)
+
+        segment = Dataset()
+        segment.SegmentNumber = seg_index + 1
+        segment.SegmentLabel = label
+        segment.SegmentAlgorithmType = 'MANUAL'
+        segment.SegmentAlgorithmName = 'ManualDraw'
+
+        segment.SegmentedPropertyCategoryCodeSequence = Sequence([Dataset()])
+        segment.SegmentedPropertyCategoryCodeSequence[0].CodeValue = 'T-D0050'
+        segment.SegmentedPropertyCategoryCodeSequence[0].CodingSchemeDesignator = 'SRT'
+        segment.SegmentedPropertyCategoryCodeSequence[0].CodeMeaning = 'Tissue'
+
+        segment.SegmentedPropertyTypeCodeSequence = Sequence([Dataset()])
+        segment.SegmentedPropertyTypeCodeSequence[0].CodeValue = 'T-00000'
+        segment.SegmentedPropertyTypeCodeSequence[0].CodingSchemeDesignator = '99LOCAL'
+        segment.SegmentedPropertyTypeCodeSequence[0].CodeMeaning = label
+
+        segment_sequence.append(segment)
+
+        for z in range(num_slices):
+            # Pack each slice (frame)
+            frame = np.packbits(vol[z].astype(np.uint8).flatten())
+            pixel_data_bytes += frame.tobytes()
+
+            # Functional Group for this frame
+            fg = Dataset()
+
+            # Position
+            pos = list(origin)
+            pos[2] += z * slice_thickness
+            plane = Dataset()
+            plane.ImagePositionPatient = [str(v) for v in pos]
+            fg.PlanePositionSequence = Sequence([plane])
+
+            # Segment reference
+            seg_id = Dataset()
+            seg_id.ReferencedSegmentNumber = seg_index + 1
+            fg.SegmentIdentificationSequence = Sequence([seg_id])
+
+            per_frame_sequence.append(fg)
+
+    ds.SegmentSequence = Sequence(segment_sequence)
+    ds.PixelData = pixel_data_bytes
+    ds.PerFrameFunctionalGroupsSequence = Sequence(per_frame_sequence)
+
+    # Shared functional groups
+    shared = Dataset()
+    geom = Dataset()
+    geom.PixelSpacing = [str(pixel_spacing[0]), str(pixel_spacing[1])]
+    geom.SliceThickness = str(slice_thickness)
+    geom.ImageOrientationPatient = ['1', '0', '0', '0', '1', '0']
+    shared.PixelMeasuresSequence = Sequence([geom])
+    ds.SharedFunctionalGroupsSequence = Sequence([shared])
+
+    return ds
+
+
+

dbdicom/{ds/types → sop_classes}/ultrasound_multiframe_image.py

@@ -3,23 +3,9 @@
 import numpy as np
 
 import pydicom
-from pydicom.dataset import Dataset, FileMetaDataset
+from pydicom.dataset import FileMetaDataset
 from pydicom.sequence import Sequence
 
-from dbdicom.ds.dataset import DbDataset
-
-class UltrasoundMultiFrameImage(DbDataset):
-    def __init__(self, dataset=None, template=None):
-        super().__init__()
-
-        if (dataset is None) and (template is None):
-            template = 'DEFAULT'
-
-        if dataset is not None:
-            self.__dict__ = dataset.__dict__
-
-        if template == 'DEFAULT': 
-            default(self)
 
 def default(ds):
 

dbdicom/{ds/types → sop_classes}/xray_angiographic_image.py

@@ -2,25 +2,10 @@
 # Produced by pydicom codify utility script
 import numpy as np
 import pydicom
-from pydicom.dataset import Dataset, FileMetaDataset
+from pydicom.dataset import FileMetaDataset
 from pydicom.sequence import Sequence
 
-from dbdicom.ds.dataset import DbDataset
-
-class XrayAngiographicImage(DbDataset):
-    def __init__(self, dataset=None, template=None):
-        super().__init__()
-
-        if (dataset is None) and (template is None):
-            template = 'ANGIO'
-
-        if dataset is not None:
-            self.__dict__ = dataset.__dict__
-
-        if template == 'ANGIO': 
-            angio(self)
-
-def angio(ds):
+def default(ds):
 
     # File meta info data elements
     ds.file_meta = FileMetaDataset()

dbdicom/utils/arrays.py

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

dbdicom/utils/files.py

@@ -1,29 +1,9 @@
 import os
 import platform
 import zipfile
-import imageio
-import numpy as np
 
-from PIL import Image, ImageSequence
-import numpy as np
 
 
-def _load_gif_frames(image: Image, mode='RGBA'):
-    return np.array([
-        np.array(frame.convert(mode))
-        for frame in ImageSequence.Iterator(image)
-    ])
-
-def gif2numpy(file):
-    with Image.open(file) as im:
-        frames = _load_gif_frames(im)
-    # GIF files are in RGBA format but assume grescale for now
-    frames = frames[...,0] 
-    # Transpose in-plane x-y
-    frames = np.transpose(frames, (0,2,1))
-    return frames
-    #return imageio.imread(file)
-
 def all_files(path):
     files = [item.path for item in scan_tree(path) if item.is_file()]
     # Windows has maximum path length of 260 - ignore any files that are longer