Source code for imagedata.header

"""Image series header

"""

import copy
import logging
import pydicom.dataset
import pydicom.datadict
import imagedata.formats
import imagedata.formats.dicomlib.uid


logger = logging.getLogger(__name__)

header_tags = ['input_format',
               'seriesNumber',
               'seriesDescription', 'imageType', 'frameOfReferenceUID',
               'studyInstanceUID', 'studyID', 'seriesInstanceUID',
               'SOPClassUID',
               'accessionNumber',
               'patientName', 'patientID', 'patientBirthDate',
               'input_sort']
geometry_tags = ['sliceLocations', 'tags', 'spacing',
                 'imagePositions', 'orientation', 'transformationMatrix',
                 'color', 'photometricInterpretation', 'axes']






[docs]def add_template(this, template):
    """Add template data to this header.
    Does not add geometry data.

    Args:
        this: header or dict
        template: template header or dict. Can be None.
    Raises:
        ValueError: When the template is not a Header or dict.
    """

    if template is None:
        return
    if not issubclass(type(this), Header) and not issubclass(type(this), dict):
        raise ValueError('Object is not Header or dict.')
    for attr in __attributes(template):
        if attr in header_tags and attr != 'seriesInstanceUID':
            __set_attribute(this, attr, __get_attribute(template, attr))
    # Make sure DicomHeaderDict is set last
    template_dhd = __get_attribute(template, 'DicomHeaderDict')
    if template_dhd is not None:
        __set_attribute(this, 'DicomHeaderDict',
                        __make_DicomHeaderDict_from_template(this, template_dhd))



def __get_tags_and_slices(obj):
    slices = tags = 1
    try:
        axes = __get_attribute(obj, 'axes')
    except Exception as e:
        print(e)
        raise
    for axis in axes:
        if axis.name == 'slice':
            slices = len(axis)
        elif axis.name not in {'row', 'column', 'rgb'}:
            tags = len(axis)
    return tags, slices


def __make_DicomHeaderDict_from_template(this, template):
    DicomHeaderDict = {}
    default_header = template[0][0][2]
    tags, slices = __get_tags_and_slices(this)
    for _slice in range(slices):
        DicomHeaderDict[_slice] = []
        for tag in range(tags):
            try:
                template_tag = template[_slice][tag][0]
            except KeyError:
                template_tag = tag
            try:
                templateHeader = template[_slice][tag][2]
            except KeyError:
                templateHeader = default_header
            DicomHeaderDict[_slice].append((template_tag, None, templateHeader))
    return DicomHeaderDict


def __make_tags_from_template(this, template, geometry):
    tag_dict = {}
    tags, slices = __get_tags_and_slices(this)
    for _slice in range(slices):
        tag_dict[_slice] = []
        if issubclass(type(geometry[_slice]), dict):
            geometry_tag_list = list(geometry[_slice].values())
        else:
            geometry_tag_list = list(geometry[_slice])
        template_tag_list = []
        if template is not None:
            if issubclass(type(template[_slice]), dict):
                template_tag_list = list(template[_slice].values())
            else:
                template_tag_list = list(template[_slice])
        if len(geometry_tag_list) >= tags:
            tag_dict[_slice] = geometry_tag_list[:tags]
        elif len(template_tag_list) >= tags:
            tag_dict[_slice] = template_tag_list[:tags]
        else:
            raise IndexError('Cannot get tag list with length {}'.format(tags))
    return tag_dict


def __make_axes_from_template(this, template_axes, geometry_axes):
    axes = __get_attribute(this, 'axes')
    for i, axis in enumerate(axes):
        if geometry_axes is not None:
            for geometry_axis in geometry_axes:
                if geometry_axis.name == axis.name:
                    axes[i] = copy.copy(geometry_axis)
        elif template_axes is not None:
            for template_axis in template_axes:
                if template_axis.name == axis.name:
                    axes[i] = copy.copy(template_axis)
    return axes



[docs]def add_geometry(this, template, geometry):
    """Add geometry data to this header.

    Args:
        this: header or dict
        template: template header or dict. Can be None.
        geometry: geometry template header or dict. Can be None.
    Raises:
        ValueError: When the template is not a Header or dict.
    """

    if geometry is None:
        return
    if not issubclass(type(this), Header) and not issubclass(type(this), dict):
        raise ValueError('Object is not Header or dict.')
    for attr in __attributes(geometry):
        if attr in geometry_tags and attr not in ['tags', 'axes']:
            __set_attribute(this, attr, __get_attribute(geometry, attr))
    # Make sure tags and axes are set last
    __set_attribute(this, 'tags',
                    __make_tags_from_template(
                        this,
                        __get_attribute(template, 'tags'),
                        __get_attribute(geometry, 'tags')
                    ))
    __set_attribute(this, 'axes',
                    __make_axes_from_template(
                        this,
                        __get_attribute(template, 'axes'),
                        __get_attribute(geometry, 'axes')
                    ))
    return



def __attributes(obj):
    if issubclass(type(obj), Header):
        for attr in obj.__dict__:
            yield attr
    elif issubclass(type(obj), dict):
        for attr in obj:
            yield attr
    else:
        raise ValueError('Template is not Header nor dict.')


def __get_attribute(obj, name):
    if obj is None:
        return None
    if issubclass(type(obj), Header):
        return getattr(obj, name, None)
    elif issubclass(type(obj), dict):
        return copy.copy(obj[name])
    else:
        raise ValueError('Object is not Header nor dict.')


def __set_attribute(obj, name, value):
    if issubclass(type(obj), Header):
        setattr(obj, name, value)
    elif issubclass(type(obj), dict):
        obj[name] = value
    else:
        raise ValueError('Source is not Header nor dict.')