def __init__(self, coordinate_system: Union[str, CoordinateSystemNames],
image_orientation: Sequence[float]) -> None:
"""
Parameters
----------
coordinate_system: Union[str, highdicom.enum.CoordinateSystemNames]
Subject (``"PATIENT"`` or ``"SLIDE"``) that was the target of
imaging
image_orientation: Sequence[float]
Direction cosines for the first row (first triplet) and the first
column (second triplet) of an image with respect to the X, Y, and Z
axis of the three-dimensional coordinate system
"""
super().__init__()
item = Dataset()
coordinate_system = CoordinateSystemNames(coordinate_system)
if coordinate_system == CoordinateSystemNames.SLIDE:
item.ImageOrientationSlide = list(image_orientation)
elif coordinate_system == CoordinateSystemNames.PATIENT:
item.ImageOrientationPatient = list(image_orientation)
else:
raise ValueError(
f'Unknown coordinate system "{coordinate_system.value}".')
self.append(item)
def __init__(
self,
coordinate_system: Union[str, CoordinateSystemNames],
image_position: Sequence[float],
pixel_matrix_position: Optional[Tuple[int, int]] = None) -> None:
"""
Parameters
----------
image_position: Sequence[float]
Offset of the first row and first column of the plane (frame) in
millimeter along the x, y, and z axis of the three-dimensional
patient or slide coordinate system
pixel_matrix_position: Tuple[int, int], optional
Offset of the first column and first row of the plane (frame) in
pixels along the row and column direction of the total pixel matrix
(only required if `coordinate_system` is ``"SLIDE"``)
Note
----
The values of both `image_position` and `pixel_matrix_position` are
one-based.
"""
super().__init__()
item = Dataset()
def ds(num: float) -> float:
return float(str(num)[:16])
coordinate_system = CoordinateSystemNames(coordinate_system)
if coordinate_system == CoordinateSystemNames.SLIDE:
if pixel_matrix_position is None:
raise TypeError(
'Position in Pixel Matrix must be specified for '
'slide coordinate system.')
col_position, row_position = pixel_matrix_position
x, y, z = image_position
item.XOffsetInSlideCoordinateSystem = ds(x)
item.YOffsetInSlideCoordinateSystem = ds(y)
item.ZOffsetInSlideCoordinateSystem = ds(z)
item.RowPositionInTotalImagePixelMatrix = row_position
item.ColumnPositionInTotalImagePixelMatrix = col_position
elif coordinate_system == CoordinateSystemNames.PATIENT:
item.ImagePositionPatient = list(image_position)
else:
raise ValueError(
f'Unknown coordinate system "{coordinate_system.value}".')
self.append(item)
def __init__(self,
coordinate_system: Union[str, CoordinateSystemNames]) -> None:
"""
Parameters
----------
coordinate_system: Union[str, highdicom.enum.CoordinateSystemNames]
Subject (``"PATIENT"`` or ``"SLIDE"``) that was the target of
imaging
"""
super().__init__()
coordinate_system = CoordinateSystemNames(coordinate_system)
if coordinate_system == CoordinateSystemNames.SLIDE:
dim_uid = '1.2.826.0.1.3680043.9.7433.2.4'
segment_number_index = Dataset()
segment_number_index.DimensionIndexPointer = tag_for_keyword(
'ReferencedSegmentNumber')
segment_number_index.FunctionalGroupPointer = tag_for_keyword(
'SegmentIdentificationSequence')
segment_number_index.DimensionOrganizationUID = dim_uid
segment_number_index.DimensionDescriptionLabel = 'Segment Number'
x_image_dimension_index = Dataset()
x_image_dimension_index.DimensionIndexPointer = tag_for_keyword(
'XOffsetInSlideCoordinateSystem')
x_image_dimension_index.FunctionalGroupPointer = tag_for_keyword(
'PlanePositionSlideSequence')
x_image_dimension_index.DimensionOrganizationUID = dim_uid
x_image_dimension_index.DimensionDescriptionLabel = \
'X Offset in Slide Coordinate System'
y_image_dimension_index = Dataset()
y_image_dimension_index.DimensionIndexPointer = tag_for_keyword(
'YOffsetInSlideCoordinateSystem')
y_image_dimension_index.FunctionalGroupPointer = tag_for_keyword(
'PlanePositionSlideSequence')
y_image_dimension_index.DimensionOrganizationUID = dim_uid
y_image_dimension_index.DimensionDescriptionLabel = \
'Y Offset in Slide Coordinate System'
z_image_dimension_index = Dataset()
z_image_dimension_index.DimensionIndexPointer = tag_for_keyword(
'ZOffsetInSlideCoordinateSystem')
z_image_dimension_index.FunctionalGroupPointer = tag_for_keyword(
'PlanePositionSlideSequence')
z_image_dimension_index.DimensionOrganizationUID = dim_uid
z_image_dimension_index.DimensionDescriptionLabel = \
'Z Offset in Slide Coordinate System'
col_image_dimension_index = Dataset()
col_image_dimension_index.DimensionIndexPointer = tag_for_keyword(
'ColumnPositionInTotalImagePixelMatrix')
col_image_dimension_index.FunctionalGroupPointer = tag_for_keyword(
'PlanePositionSlideSequence')
col_image_dimension_index.DimensionOrganizationUID = dim_uid
col_image_dimension_index.DimensionDescriptionLabel = \
'Column Position In Total Image Pixel Matrix'
row_image_dimension_index = Dataset()
row_image_dimension_index.DimensionIndexPointer = tag_for_keyword(
'RowPositionInTotalImagePixelMatrix')
row_image_dimension_index.FunctionalGroupPointer = tag_for_keyword(
'PlanePositionSlideSequence')
row_image_dimension_index.DimensionOrganizationUID = dim_uid
row_image_dimension_index.DimensionDescriptionLabel = \
'Row Position In Total Image Pixel Matrix'
self.extend([
segment_number_index,
x_image_dimension_index,
y_image_dimension_index,
z_image_dimension_index,
col_image_dimension_index,
row_image_dimension_index,
])
elif coordinate_system == CoordinateSystemNames.PATIENT:
dim_uid = '1.2.826.0.1.3680043.9.7433.2.3'
segment_number_index = Dataset()
segment_number_index.DimensionIndexPointer = tag_for_keyword(
'ReferencedSegmentNumber')
segment_number_index.FunctionalGroupPointer = tag_for_keyword(
'SegmentIdentificationSequence')
segment_number_index.DimensionOrganizationUID = dim_uid
segment_number_index.DimensionDescriptionLabel = 'Segment Number'
image_position_index = Dataset()
image_position_index.DimensionIndexPointer = tag_for_keyword(
'ImagePositionPatient')
image_position_index.FunctionalGroupPointer = tag_for_keyword(
'PlanePositionSequence')
image_position_index.DimensionOrganizationUID = dim_uid
image_position_index.DimensionDescriptionLabel = \
'Image Position Patient'
self.extend([
segment_number_index,
image_position_index,
])
def __init__(
self,
pixel_array: np.ndarray,
photometric_interpretation: Union[str,
PhotometricInterpretationValues],
bits_allocated: int,
coordinate_system: Union[str, CoordinateSystemNames],
study_instance_uid: str,
series_instance_uid: str,
series_number: int,
sop_instance_uid: str,
instance_number: int,
manufacturer: str,
patient_id: Optional[str] = None,
patient_name: Optional[Union[str, PersonName]] = None,
patient_birth_date: Optional[str] = None,
patient_sex: Optional[str] = None,
accession_number: Optional[str] = None,
study_id: str = None,
study_date: Optional[Union[str, datetime.date]] = None,
study_time: Optional[Union[str, datetime.time]] = None,
referring_physician_name: Optional[Union[str, PersonName]] = None,
pixel_spacing: Optional[Tuple[int, int]] = None,
laterality: Optional[Union[str, LateralityValues]] = None,
patient_orientation: Optional[
Union[Tuple[str, str], Tuple[PatientOrientationValuesBiped,
PatientOrientationValuesBiped, ],
Tuple[PatientOrientationValuesQuadruped,
PatientOrientationValuesQuadruped, ]]] = None,
anatomical_orientation_type: Optional[Union[
str, AnatomicalOrientationTypeValues]] = None,
container_identifier: Optional[str] = None,
issuer_of_container_identifier: Optional[
IssuerOfIdentifier] = None,
specimen_descriptions: Optional[
Sequence[SpecimenDescription]] = None,
transfer_syntax_uid: str = ImplicitVRLittleEndian,
**kwargs: Any):
"""
Parameters
----------
pixel_array: numpy.ndarray
Array of unsigned integer pixel values representing a single-frame
image; either a 2D grayscale image or a 3D color image
(RGB color space)
photometric_interpretation: Union[str, highdicom.enum.PhotometricInterpretationValues]
Interpretation of pixel data; either ``"MONOCHROME1"`` or
``"MONOCHROME2"`` for 2D grayscale images or ``"RGB"`` or
``"YBR_FULL"`` for 3D color images
bits_allocated: int
Number of bits that should be allocated per pixel value
coordinate_system: Union[str, highdicom.enum.CoordinateSystemNames]
Subject (``"PATIENT"`` or ``"SLIDE"``) that was the target of
imaging
study_instance_uid: str
Study Instance UID
series_instance_uid: str
Series Instance UID of the SC image series
series_number: Union[int, None]
Series Number of the SC image series
sop_instance_uid: str
SOP instance UID that should be assigned to the SC image instance
instance_number: int
Number that should be assigned to this SC image instance
manufacturer: str
Name of the manufacturer of the device that creates the SC image
instance (in a research setting this is typically the same
as `institution_name`)
patient_id: str, optional
ID of the patient (medical record number)
patient_name: Optional[Union[str, PersonName]], optional
Name of the patient
patient_birth_date: str, optional
Patient's birth date
patient_sex: str, optional
Patient's sex
study_id: str, optional
ID of the study
accession_number: str, optional
Accession number of the study
study_date: Union[str, datetime.date], optional
Date of study creation
study_time: Union[str, datetime.time], optional
Time of study creation
referring_physician_name: Optional[Union[str, PersonName]], optional
Name of the referring physician
pixel_spacing: Tuple[int, int], optional
Physical spacing in millimeter between pixels along the row and
column dimension
laterality: Union[str, highdicom.enum.LateralityValues], optional
Laterality of the examined body part
patient_orientation:
Union[Tuple[str, str], Tuple[highdicom.enum.PatientOrientationValuesBiped, highdicom.enum.PatientOrientationValuesBiped], Tuple[highdicom.enum.PatientOrientationValuesQuadruped, highdicom.enum.PatientOrientationValuesQuadruped]], optional
Orientation of the patient along the row and column axes of the
image (required if `coordinate_system` is ``"PATIENT"``)
anatomical_orientation_type: Union[str, highdicom.enum.AnatomicalOrientationTypeValues], optional
Type of anatomical orientation of patient relative to image (may be
provide if `coordinate_system` is ``"PATIENT"`` and patient is
an animal)
container_identifier: str, optional
Identifier of the container holding the specimen (required if
`coordinate_system` is ``"SLIDE"``)
issuer_of_container_identifier: highdicom.IssuerOfIdentifier, optional
Issuer of `container_identifier`
specimen_descriptions: Sequence[highdicom.SpecimenDescriptions], optional
Description of each examined specimen (required if
`coordinate_system` is ``"SLIDE"``)
transfer_syntax_uid: str, optional
UID of transfer syntax that should be used for encoding of
data elements. The following lossless compressed transfer syntaxes
are supported: RLE Lossless (``"1.2.840.10008.1.2.5"``).
**kwargs: Any, optional
Additional keyword arguments that will be passed to the constructor
of `highdicom.base.SOPClass`
""" # noqa
supported_transfer_syntaxes = {
ImplicitVRLittleEndian,
ExplicitVRLittleEndian,
RLELossless,
}
if transfer_syntax_uid not in supported_transfer_syntaxes:
raise ValueError(
f'Transfer syntax "{transfer_syntax_uid}" is not supported')
# Check names
if patient_name is not None:
check_person_name(patient_name)
if referring_physician_name is not None:
check_person_name(referring_physician_name)
super().__init__(study_instance_uid=study_instance_uid,
series_instance_uid=series_instance_uid,
series_number=series_number,
sop_instance_uid=sop_instance_uid,
sop_class_uid=SecondaryCaptureImageStorage,
instance_number=instance_number,
manufacturer=manufacturer,
modality='OT',
transfer_syntax_uid=transfer_syntax_uid,
patient_id=patient_id,
patient_name=patient_name,
patient_birth_date=patient_birth_date,
patient_sex=patient_sex,
accession_number=accession_number,
study_id=study_id,
study_date=study_date,
study_time=study_time,
referring_physician_name=referring_physician_name,
**kwargs)
coordinate_system = CoordinateSystemNames(coordinate_system)
if coordinate_system == CoordinateSystemNames.PATIENT:
if patient_orientation is None:
raise TypeError(
'Patient orientation is required if coordinate system '
'is "PATIENT".')
# General Series
if laterality is not None:
laterality = LateralityValues(laterality)
self.Laterality = laterality.value
# General Image
if anatomical_orientation_type is not None:
anatomical_orientation_type = AnatomicalOrientationTypeValues(
anatomical_orientation_type)
self.AnatomicalOrientationType = \
anatomical_orientation_type.value
else:
anatomical_orientation_type = \
AnatomicalOrientationTypeValues.BIPED
row_orientation, col_orientation = patient_orientation
if (anatomical_orientation_type ==
AnatomicalOrientationTypeValues.BIPED):
patient_orientation = (
PatientOrientationValuesBiped(row_orientation).value,
PatientOrientationValuesBiped(col_orientation).value,
)
else:
patient_orientation = (
PatientOrientationValuesQuadruped(row_orientation).value,
PatientOrientationValuesQuadruped(col_orientation).value,
)
self.PatientOrientation = list(patient_orientation)
elif coordinate_system == CoordinateSystemNames.SLIDE:
if container_identifier is None:
raise TypeError(
'Container identifier is required if coordinate system '
'is "SLIDE".')
if specimen_descriptions is None:
raise TypeError(
'Specimen descriptions are required if coordinate system '
'is "SLIDE".')
# Specimen
self.ContainerIdentifier = container_identifier
self.IssuerOfTheContainerIdentifierSequence: List[Dataset] = []
if issuer_of_container_identifier is not None:
self.IssuerOftheContainerIdentifierSequence.append(
issuer_of_container_identifier)
container_type_item = CodedConcept(*codes.SCT.MicroscopeSlide)
self.ContainerTypeCodeSequence = [container_type_item]
self.SpecimenDescriptionSequence = specimen_descriptions
# SC Equipment
self.ConversionType = ConversionTypeValues.DI.value
# SC Image
now = datetime.datetime.now()
self.DateOfSecondaryCapture = DA(now.date())
self.TimeOfSecondaryCapture = TM(now.time())
# Image Pixel
self.ImageType = ['DERIVED', 'SECONDARY', 'OTHER']
self.Rows = pixel_array.shape[0]
self.Columns = pixel_array.shape[1]
allowed_types = [np.bool_, np.uint8, np.uint16]
if not any(pixel_array.dtype == t for t in allowed_types):
raise TypeError(
'Pixel array must be of type np.bool_, np.uint8 or np.uint16. '
f'Found {pixel_array.dtype}.')
wrong_bit_depth_assignment = (
pixel_array.dtype == np.bool_ and bits_allocated != 1,
pixel_array.dtype == np.uint8 and bits_allocated != 8,
pixel_array.dtype == np.uint16 and bits_allocated not in (12, 16),
)
if any(wrong_bit_depth_assignment):
raise ValueError('Pixel array has an unexpected bit depth.')
if bits_allocated not in (1, 8, 12, 16):
raise ValueError('Unexpected number of bits allocated.')
if transfer_syntax_uid == RLELossless and bits_allocated % 8 != 0:
raise ValueError(
'When using run length encoding, bits allocated must be a '
'multiple of 8')
self.BitsAllocated = bits_allocated
self.HighBit = self.BitsAllocated - 1
self.BitsStored = self.BitsAllocated
self.PixelRepresentation = 0
photometric_interpretation = PhotometricInterpretationValues(
photometric_interpretation)
if pixel_array.ndim == 3:
accepted_interpretations = {
PhotometricInterpretationValues.RGB.value,
PhotometricInterpretationValues.YBR_FULL.value,
PhotometricInterpretationValues.YBR_FULL_422.value,
PhotometricInterpretationValues.YBR_PARTIAL_420.value,
}
if photometric_interpretation.value not in accepted_interpretations:
raise ValueError(
'Pixel array has an unexpected photometric interpretation.'
)
if pixel_array.shape[-1] != 3:
raise ValueError(
'Pixel array has an unexpected number of color channels.')
if bits_allocated != 8:
raise ValueError('Color images must be 8-bit.')
if pixel_array.dtype != np.uint8:
raise TypeError(
'Pixel array must have 8-bit unsigned integer data type '
'in case of a color image.')
self.PhotometricInterpretation = photometric_interpretation.value
self.SamplesPerPixel = 3
self.PlanarConfiguration = 0
elif pixel_array.ndim == 2:
accepted_interpretations = {
PhotometricInterpretationValues.MONOCHROME1.value,
PhotometricInterpretationValues.MONOCHROME2.value,
}
if photometric_interpretation.value not in accepted_interpretations:
raise ValueError(
'Pixel array has an unexpected photometric interpretation.'
)
self.PhotometricInterpretation = photometric_interpretation.value
self.SamplesPerPixel = 1
else:
raise ValueError(
'Pixel array has an unexpected number of dimensions.')
if pixel_spacing is not None:
self.PixelSpacing = pixel_spacing
encoded_frame = encode_frame(
pixel_array,
transfer_syntax_uid=self.file_meta.TransferSyntaxUID,
bits_allocated=self.BitsAllocated,
bits_stored=self.BitsStored,
photometric_interpretation=self.PhotometricInterpretation,
pixel_representation=self.PixelRepresentation,
planar_configuration=getattr(self, 'PlanarConfiguration', None))
if self.file_meta.TransferSyntaxUID.is_encapsulated:
self.PixelData = encapsulate([encoded_frame])
else:
self.PixelData = encoded_frame