Add domain classes for study selected series and selection operator

Author: MMelQin

monai/deploy/core/domain/__init__.py

@@ -19,10 +19,13 @@
     DICOMStudy
     DICOMSeries
     DICOMSOPInstance
+    SelectedSeries
+    StudySelectedSeries
 """
 
 from .datapath import DataPath, NamedDataPath
 from .dicom_series import DICOMSeries
+from .dicom_series_selection import SelectedSeries, StudySelectedSeries
 from .dicom_sop_instance import DICOMSOPInstance
 from .dicom_study import DICOMStudy
 from .domain import Domain

monai/deploy/core/domain/dicom_series.py

@@ -50,70 +50,85 @@ def add_sop_instance(self, sop_instance):
     def get_sop_instances(self):
         return self._sop_instances
 
+    # Properties named after DICOM Series module attribute keywords
+    # There are two required (Type 1) attrbutes for a series:
+    #     Keyword: SeriesInstanceUID, Tag: (0020,000E)
+    #     Keyword: Modality, Tag: (0008,0060)
+    #
     @property
-    def series_date(self):
+    def SeriesInstanceUID(self):
+        return self._series_instance_uid
+
+    @SeriesInstanceUID.setter
+    def SeriesInstanceUID(self, val):
+        self._series_instance_uid = val
+
+    @property
+    def SeriesDate(self):
         return getattr(self, "_series_date", None)
 
-    @series_date.setter
-    def series_date(self, val):
+    @SeriesDate.setter
+    def SeriesDate(self, val):
         self._series_date = val
 
     @property
-    def series_time(self):
+    def SeriesTime(self):
         return getattr(self, "_series_time", None)
 
-    @series_time.setter
-    def series_time(self, val):
+    @SeriesTime.setter
+    def SeriesTime(self, val):
         self._series_time = val
 
     @property
-    def modality(self):
+    def Modality(self):
         return getattr(self, "_modality", None)
 
-    @modality.setter
-    def modality(self, val):
+    @Modality.setter
+    def Modality(self, val):
         self._modality = val
 
     @property
-    def series_description(self):
+    def SeriesDescription(self):
         return getattr(self, "_series_description", None)
 
-    @series_description.setter
-    def series_description(self, val):
+    @SeriesDescription.setter
+    def SeriesDescription(self, val):
         self._series_description = val
 
     @property
-    def body_part_examined(self):
+    def BodyPartExamined(self):
         return getattr(self, "_body_part_examined", None)
 
-    @body_part_examined.setter
-    def body_part_examined(self, val):
+    @BodyPartExamined.setter
+    def BodyPartExamined(self, val):
         self._body_part_examined = val
 
     @property
-    def patient_position(self):
+    def PatientPosition(self):
         return getattr(self, "_patient_position", None)
 
-    @patient_position.setter
-    def patient_position(self, val):
+    @PatientPosition.setter
+    def PatientPosition(self, val):
         self._patient_position = val
 
     @property
-    def series_number(self):
+    def SeriesNumber(self):
         return getattr(self, "_series_number", None)
 
-    @series_number.setter
-    def series_number(self, val):
+    @SeriesNumber.setter
+    def SeriesNumber(self, val):
         self._series_number = val
 
     @property
-    def laterality(self):
-        return getattr(self, "_laterality", None)
+    def Laterality(self):
+        return getattr(self, "_Laterality", None)
 
-    @laterality.setter
-    def laterality(self, val):
+    @Laterality.setter
+    def Laterality(self, val):
         self._laterality = val
 
+    # Derived properties based on image module attributes
+    #
     @property
     def row_pixel_spacing(self):
         return getattr(self, "_row_pixel_spacing", None)
@@ -179,28 +194,28 @@ def nifti_affine_transform(self, val):
         self._nifti_affine_transform = val
 
     def __str__(self):
-        result = "---------------" + "\n"
+        result = "\n---------------" + "\n"
 
         series_instance_uid_attr = "Series Instance UID: " + self._series_instance_uid + "\n"
         result += series_instance_uid_attr
 
         num_sop_instances = "Num SOP Instances: " + str(len(self._sop_instances)) + "\n"
         result += num_sop_instances
 
-        if self.series_date is not None:
-            series_date_attr = "Series Date: " + self.series_date + "\n"
+        if self.SeriesDate is not None:
+            series_date_attr = "Series Date: " + self.SeriesDate + "\n"
             result += series_date_attr
 
-        if self.series_time is not None:
-            series_time_attr = "Series Time: " + self.series_time + "\n"
+        if self.SeriesTime is not None:
+            series_time_attr = "Series Time: " + self.SeriesTime + "\n"
             result += series_time_attr
 
-        if self.modality is not None:
-            modality_attr = "Modality: " + self.modality + "\n"
+        if self.Modality is not None:
+            modality_attr = "Modality: " + self.Modality + "\n"
             result += modality_attr
 
-        if self.series_description is not None:
-            series_desc_attr = "Series Description: " + self.series_description + "\n"
+        if self.SeriesDescription is not None:
+            series_desc_attr = "Series Description: " + self.SeriesDescription + "\n"
             result += series_desc_attr
 
         if self.row_pixel_spacing is not None:

monai/deploy/core/domain/dicom_series_selection.py

@@ -0,0 +1,138 @@
+# Copyright 2021 MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Dict, List, Optional, Union
+
+from .dicom_series import DICOMSeries
+from .dicom_study import DICOMStudy
+from .domain import Domain
+from .image import Image
+
+
+class SelectedSeries(Domain):
+    """This class encapsulates a DICOM series that has been selected with a given selection name.
+
+    It references the DICOMSeries object with the name associated with selection, and a Image if applicable.
+    """
+
+    def __init__(
+        self,
+        selection_name: str,
+        dicom_series: DICOMSeries,
+        image: Optional[Image] = None,
+        metadata: Optional[Dict] = None,
+    ) -> None:
+        """Creates an instance of this class
+
+        Args:
+            selection_name (str): Name given to this selection, if None, then series instance UID is used.
+            dicom_series (DICOMSeries): The referenced DICOMSeries object.
+            image (Optional[Image], optional): Converted image of the series, if applicable. Defaults to None.
+            metadata (Optional[Dict], optional): Metadata dictionary for the instance. Defaults to None.
+
+        Raises:
+            ValueError: If argument dicom_series is not a DICOMSeries object.
+        """
+        if not isinstance(dicom_series, DICOMSeries):
+            raise ValueError("Argument dicom_series must be a DICOMSeries object.")
+        super().__init__(metadata)
+        self._series = dicom_series
+        self._image = image
+
+        if not selection_name or not selection_name.strip():
+            self._name = str(dicom_series.SeriesInstanceUID)
+        else:
+            self._name = selection_name.strip()
+
+    @property
+    def series(self) -> DICOMSeries:
+        return self._series
+
+    @property
+    def slection_name(self) -> str:
+        return self._name
+
+    @property
+    def image(self) -> Union[Image, None]:
+        return self._image
+
+    @image.setter
+    def image(self, val):
+        self._image = val
+
+
+class StudySelectedSeries(Domain):
+    """This class encapsulates a DICOM study and a list of selected DICOM series within it.
+
+    It references the DICOMStudy object and a dictionary of SelectedSeries objects.
+    """
+
+    def __init__(self, study: DICOMStudy, metadata: Optional[Dict] = None) -> None:
+        """Creates a instance with a DICOMStudy object.
+
+        Args:
+            study (DICOMStudy): The DICOMStudy object referenced.
+            metadata (Optional[Dict], optional): Metadata dictionary for the instance. Defaults to None.
+
+        Raises:
+            ValueError: If argument study is not a DICOMStudy object.
+        """
+        if not isinstance(study, DICOMStudy):
+            raise ValueError("A DICOMStudy object is required.")
+        super().__init__(metadata)
+        self._study: DICOMStudy = study
+        self._select_series_dict: Dict = {}  # "selection_name": [SelectedSeries]
+
+    @property
+    def study(self) -> DICOMStudy:
+        """Returns the DICOMStudy object referenced.
+
+        Returns:
+            DICOMStudy: The referenced DICOMStudy object.
+        """
+        return self._study
+
+    @property
+    def selected_series(self) -> List[SelectedSeries]:
+        """Returns a view of the list of all the SelectedSeries objects.
+
+        Returns:
+            List[SelectedSeries]: A view of the flat list of all SelectedSeries objects.
+        """
+        list_of_sublists = list(self._select_series_dict.values())
+        return [item for sublist in list_of_sublists for item in sublist]
+
+    @property
+    def series_by_selection_name(self) -> Dict:
+        """Returns the list of SelectedSeries by selection names in a dictionary.
+
+        Returns:
+            Dict: Dictionary with selection name as key and list of SelectedSeries as value.
+        """
+        return self._select_series_dict
+
+    def add_selected_series(self, selected_series: SelectedSeries) -> None:
+        """Adds a SelectedSeries object in the referenced DICOMStudy.
+
+        The SelectedSeries object is grouped by the selection name in a list,
+        so there could be one or more objects for a given selection name.
+
+        Args:
+            selected_series (SelectedSeries): The reference of the SelectedSeries object.
+
+        Raises:
+            ValueError: If argument selected_series is not a SelectedSeries object.
+        """
+        if not isinstance(selected_series, SelectedSeries):
+            raise ValueError("A SelectedSeries object is required.")
+        selected_series_list = self._select_series_dict.get(selected_series.slection_name, [])
+        selected_series_list.append(selected_series)
+        self._select_series_dict[selected_series.slection_name] = selected_series_list