def test_find_content_items_filtered_by_value_type_relationship_type(self): items = find_content_items( self._sr_document, value_type=ValueTypeValues.CODE, relationship_type=RelationshipTypeValues.HAS_OBS_CONTEXT) assert len(items) == 2 name_code_value_1 = items[0].ConceptNameCodeSequence[0].CodeValue assert name_code_value_1 == codes.DCM.ObserverType.value name_code_value_2 = items[1].ConceptNameCodeSequence[0].CodeValue assert name_code_value_2 == codes.DCM.ObserverType.value
def test_find_content_items_filtered_by_relationship_type(self): items = find_content_items( self._sr_document, relationship_type=RelationshipTypeValues.HAS_OBS_CONTEXT) assert len(items) == 4 name_code_value_1 = items[0].ConceptNameCodeSequence[0].CodeValue assert name_code_value_1 == codes.DCM.ObserverType.value name_code_value_2 = items[1].ConceptNameCodeSequence[0].CodeValue assert name_code_value_2 == codes.DCM.PersonObserverName.value name_code_value_3 = items[2].ConceptNameCodeSequence[0].CodeValue assert name_code_value_3 == codes.DCM.ObserverType.value name_code_value_4 = items[3].ConceptNameCodeSequence[0].CodeValue assert name_code_value_4 == codes.DCM.DeviceObserverUID.value
def __init__(self, evidence: Sequence[Dataset], content: Dataset, series_instance_uid: str, series_number: int, sop_instance_uid: str, instance_number: int, manufacturer: Optional[str] = None, is_complete: bool = False, is_final: bool = False, is_verified: bool = False, institution_name: Optional[str] = None, institutional_department_name: Optional[str] = None, verifying_observer_name: Optional[str] = None, verifying_organization: Optional[str] = None, performed_procedure_codes: Optional[Sequence[Union[ Code, CodedConcept]]] = None, requested_procedures: Optional[Sequence[Dataset]] = None, previous_versions: Optional[Sequence[Dataset]] = None, record_evidence: bool = True, **kwargs: Any) -> None: """ Parameters ---------- evidence: Sequence[pydicom.dataset.Dataset] Instances that are referenced in the content tree and from which the created SR document instance should inherit patient and study information content: pydicom.dataset.Dataset Root container content items that should be included in the SR document series_instance_uid: str Series Instance UID of the SR document series series_number: Union[int, None] Series Number of the SR document series sop_instance_uid: str SOP Instance UID that should be assigned to the SR document instance instance_number: int Number that should be assigned to this SR document instance manufacturer: str, optional Name of the manufacturer of the device that creates the SR document instance (in a research setting this is typically the same as `institution_name`) is_complete: bool, optional Whether the content is complete (default: ``False``) is_final: bool, optional Whether the report is the definitive means of communicating the findings (default: ``False``) is_verified: bool, optional Whether the report has been verified by an observer accountable for its content (default: ``False``) institution_name: str, optional Name of the institution of the person or device that creates the SR document instance institutional_department_name: str, optional Name of the department of the person or device that creates the SR document instance verifying_observer_name: Union[str, None], optional Name of the person that verfied the SR document (required if `is_verified`) verifying_organization: str, optional Name of the organization that verfied the SR document (required if `is_verified`) performed_procedure_codes: List[highdicom.sr.coding.CodedConcept], optional Codes of the performed procedures that resulted in the SR document requested_procedures: List[pydicom.dataset.Dataset] Requested procedures that are being fullfilled by creation of the SR document previous_versions: List[pydicom.dataset.Dataset], optional Instances representing previous versions of the SR document record_evidence: bool, optional Whether provided `evidence` should be recorded, i.e. included in Current Requested Procedure Evidence Sequence or Pertinent Other Evidence Sequence (default: ``True``) **kwargs: Any, optional Additional keyword arguments that will be passed to the constructor of `highdicom.base.SOPClass` Note ---- Each dataset in `evidence` must be part of the same study. """ # noqa: E501 super().__init__( evidence=evidence, content=content, series_instance_uid=series_instance_uid, series_number=series_number, sop_instance_uid=sop_instance_uid, sop_class_uid=ComprehensiveSRStorage, instance_number=instance_number, manufacturer=manufacturer, is_complete=is_complete, is_final=is_final, is_verified=is_verified, institution_name=institution_name, institutional_department_name=institutional_department_name, verifying_observer_name=verifying_observer_name, verifying_organization=verifying_organization, performed_procedure_codes=performed_procedure_codes, requested_procedures=requested_procedures, previous_versions=previous_versions, record_evidence=record_evidence, **kwargs) unsopported_content = find_content_items( content, value_type=ValueTypeValues.SCOORD3D, recursive=True) if len(unsopported_content) > 0: raise ValueError( 'Comprehensive SR does not support content items with ' 'SCOORD3D value type.')
def test_find_content_items_filtered_by_name(self): items = find_content_items(self._sr_document, name=codes.DCM.ProcedureReported) assert len(items) == 1 name_code_value = items[0].ConceptNameCodeSequence[0].CodeValue assert name_code_value == codes.DCM.ProcedureReported.value
def test_find_content_items(self): items = find_content_items(self._sr_document) assert len(items) == 8
def test_find_content_items_filter_by_relationship_type_recursively(self): items = find_content_items( self._sr_document, relationship_type=RelationshipTypeValues.CONTAINS, recursive=True) assert len(items) == 6
def test_find_content_items_filter_by_value_type_recursively_1(self): items = find_content_items(self._sr_document, value_type=ValueTypeValues.CODE, recursive=True) assert len(items) == 9
def test_find_content_items_filter_by_name_recursively(self): items = find_content_items(self._sr_document, name=codes.DCM.TrackingUniqueIdentifier, recursive=True) assert len(items) == 2
def test_find_content_items_recursively(self): items = find_content_items(self._sr_document, recursive=True) assert len(items) == 20
def test_find_content_items_filtered_by_value_type(self): items = find_content_items(self._sr_document, value_type=ValueTypeValues.UIDREF) assert len(items) == 1 name_code_value = items[0].ConceptNameCodeSequence[0].CodeValue assert name_code_value == codes.DCM.DeviceObserverUID.value
def _collect_evidence( self, evidence: Sequence[Dataset], content: Dataset) -> Tuple[List[Dataset], List[Dataset]]: """Collect evidence for the SR document. Any `evidence` that is referenced in `content` via IMAGE or COMPOSITE content items will be grouped together for inclusion in the Current Requested Procedure Evidence Sequence and all remaining evidence will be grouped for potential inclusion in the Pertinent Other Evidence Sequence. Parameters ---------- evidence: List[pydicom.dataset.Dataset] Metadata of instances that serve as evidence for the SR document content content: pydicom.dataset.Dataset SR document content Returns ------- Tuple[List[pydicom.dataset.Dataset], List[pydicom.dataset.Dataset]] Items of the Current Requested Procedure Evidence Sequence and the Pertinent Other Evidence Sequence Raises ------ ValueError When a SOP instance is referenced in `content` but not provided as `evidence` """ # noqa references = find_content_items(content, value_type=ValueTypeValues.IMAGE, recursive=True) references += find_content_items(content, value_type=ValueTypeValues.COMPOSITE, recursive=True) ref_uids = set([ ref.ReferencedSOPSequence[0].ReferencedSOPInstanceUID for ref in references ]) evd_uids = set() ref_group: Mapping[Tuple[str, str], List[Dataset]] = defaultdict(list) unref_group: Mapping[Tuple[str, str], List[Dataset]] = defaultdict(list) for evd in evidence: if evd.SOPInstanceUID in evd_uids: # Skip potential duplicates continue evd_item = Dataset() evd_item.ReferencedSOPClassUID = evd.SOPClassUID evd_item.ReferencedSOPInstanceUID = evd.SOPInstanceUID key = (evd.StudyInstanceUID, evd.SeriesInstanceUID) if evd.SOPInstanceUID in ref_uids: ref_group[key].append(evd_item) else: unref_group[key].append(evd_item) evd_uids.add(evd.SOPInstanceUID) if not (ref_uids.issubset(evd_uids)): missing_uids = ref_uids.difference(evd_uids) raise ValueError( 'No evidence was provided for the following SOP instances, ' 'which are referenced in the document content: "{}"'.format( '", "'.join(missing_uids))) ref_items = self._create_references(ref_group) unref_items = self._create_references(unref_group) return (ref_items, unref_items)