Fix DICOM attribute handling

Existing implementation did not set attributes in
advance, and their availability are checked by
handing AttributeError.

For the reason, initializing those attributes with
None caused spleen app execution failure.
(All metadata dictionary in Domain class is filled
with None even for non-available attributes)

With this patch, the attribute's availability is checked
by checking if its value is None and getters return
None if attributes are not set (using getattr() method).

Signed-off-by: Gigon Bae <[email protected]>

Author: gigony

examples/apps/ai_spleen_seg_app/spleen_seg_operator.py

@@ -12,7 +12,6 @@
 import logging
 
 from monai.deploy.core import ExecutionContext, Image, InputContext, IOType, Operator, OutputContext, env, input, output
-
 from monai.deploy.operators.monai_seg_inference_operator import InMemImageReader, MonaiSegInferenceOperator
 from monai.transforms import (
     Activationsd,

monai/deploy/core/domain/dicom_series.py

@@ -9,8 +9,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any
-
 from .dicom_sop_instance import DICOMSOPInstance
 from .domain import Domain
 
@@ -23,22 +21,24 @@ def __init__(self, series_instance_uid):
         self._series_instance_uid = series_instance_uid
         self._sop_instances = []
 
-        self._series_date: Any = None
-        self._series_time: Any = None
-        self._modality: Any = None
-        self._series_description: Any = None
-        self._body_part_examined: Any = None
-        self._patient_position: Any = None
-        self._series_number: Any = None
-        self._laterality: Any = None
-        self._row_pixel_spacing: Any = None
-        self._col_pixel_spacing: Any = None
-        self._depth_pixel_spacing: Any = None
-        self._row_direction_cosine: Any = None
-        self._col_direction_cosine: Any = None
-        self._depth_direction_cosine: Any = None
-        self._dicom_affine_transform: Any = None
-        self._nifti_affine_transform: Any = None
+        # Do not set attributes in advance to save memory
+
+        # self._series_date: Any = None
+        # self._series_time: Any = None
+        # self._modality: Any = None
+        # self._series_description: Any = None
+        # self._body_part_examined: Any = None
+        # self._patient_position: Any = None
+        # self._series_number: Any = None
+        # self._laterality: Any = None
+        # self._row_pixel_spacing: Any = None
+        # self._col_pixel_spacing: Any = None
+        # self._depth_pixel_spacing: Any = None
+        # self._row_direction_cosine: Any = None
+        # self._col_direction_cosine: Any = None
+        # self._depth_direction_cosine: Any = None
+        # self._dicom_affine_transform: Any = None
+        # self._nifti_affine_transform: Any = None
 
     def get_series_instance_uid(self):
         return self._series_instance_uid
@@ -52,127 +52,127 @@ def get_sop_instances(self):
 
     @property
     def series_date(self):
-        return self._series_date
+        return getattr(self, "_series_date", None)
 
     @series_date.setter
     def series_date(self, val):
         self._series_date = val
 
     @property
     def series_time(self):
-        return self._series_time
+        return getattr(self, "_series_time", None)
 
     @series_time.setter
     def series_time(self, val):
         self._series_time = val
 
     @property
     def modality(self):
-        return self._modality
+        return getattr(self, "_modality", None)
 
     @modality.setter
     def modality(self, val):
         self._modality = val
 
     @property
     def series_description(self):
-        return self._series_description
+        return getattr(self, "_series_description", None)
 
     @series_description.setter
     def series_description(self, val):
         self._series_description = val
 
     @property
     def body_part_examined(self):
-        return self._body_part_examined
+        return getattr(self, "_body_part_examined", None)
 
     @body_part_examined.setter
     def body_part_examined(self, val):
         self._body_part_examined = val
 
     @property
     def patient_position(self):
-        return self._patient_position
+        return getattr(self, "_patient_position", None)
 
     @patient_position.setter
     def patient_position(self, val):
         self._patient_position = val
 
     @property
     def series_number(self):
-        return self._series_number
+        return getattr(self, "_series_number", None)
 
     @series_number.setter
     def series_number(self, val):
         self._series_number = val
 
     @property
     def laterality(self):
-        return self._laterality
+        return getattr(self, "_laterality", None)
 
     @laterality.setter
     def laterality(self, val):
         self._laterality = val
 
     @property
     def row_pixel_spacing(self):
-        return self._row_pixel_spacing
+        return getattr(self, "_row_pixel_spacing", None)
 
     @row_pixel_spacing.setter
     def row_pixel_spacing(self, val):
         self._row_pixel_spacing = val
 
     @property
     def col_pixel_spacing(self):
-        return self._col_pixel_spacing
+        return getattr(self, "_col_pixel_spacing", None)
 
     @col_pixel_spacing.setter
     def col_pixel_spacing(self, val):
         self._col_pixel_spacing = val
 
     @property
     def depth_pixel_spacing(self):
-        return self._depth_pixel_spacing
+        return getattr(self, "_depth_pixel_spacing", None)
 
     @depth_pixel_spacing.setter
     def depth_pixel_spacing(self, val):
         self._depth_pixel_spacing = val
 
     @property
     def row_direction_cosine(self):
-        return self._row_direction_cosine
+        return getattr(self, "_row_direction_cosine", None)
 
     @row_direction_cosine.setter
     def row_direction_cosine(self, val):
         self._row_direction_cosine = val
 
     @property
     def col_direction_cosine(self):
-        return self._col_direction_cosine
+        return getattr(self, "_col_direction_cosine", None)
 
     @col_direction_cosine.setter
     def col_direction_cosine(self, val):
         self._col_direction_cosine = val
 
     @property
     def depth_direction_cosine(self):
-        return self._depth_direction_cosine
+        return getattr(self, "_depth_direction_cosine", None)
 
     @depth_direction_cosine.setter
     def depth_direction_cosine(self, val):
         self._depth_direction_cosine = val
 
     @property
     def dicom_affine_transform(self):
-        return self._dicom_affine_transform
+        return getattr(self, "_dicom_affine_transform", None)
 
     @dicom_affine_transform.setter
     def dicom_affine_transform(self, val):
         self._dicom_affine_transform = val
 
     @property
     def nifti_affine_transform(self):
-        return self._nifti_affine_transform
+        return getattr(self, "_nifti_affine_transform", None)
 
     @nifti_affine_transform.setter
     def nifti_affine_transform(self, val):
@@ -184,83 +184,56 @@ def __str__(self):
         series_instance_uid_attr = "Series Instance UID: " + self._series_instance_uid + "\n"
         result += series_instance_uid_attr
 
-        try:
-            num_sop_instances = "Num SOP Instances: " + str(len(self._sop_instances)) + "\n"
-            result += num_sop_instances
-        except AttributeError:
-            pass
+        num_sop_instances = "Num SOP Instances: " + str(len(self._sop_instances)) + "\n"
+        result += num_sop_instances
 
-        try:
+        if self.series_date is not None:
             series_date_attr = "Series Date: " + self.series_date + "\n"
             result += series_date_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.series_time is not None:
             series_time_attr = "Series Time: " + self.series_time + "\n"
             result += series_time_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.modality is not None:
             modality_attr = "Modality: " + self.modality + "\n"
             result += modality_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.series_description is not None:
             series_desc_attr = "Series Description: " + self.series_description + "\n"
             result += series_desc_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.row_pixel_spacing is not None:
             row_pixel_spacing_attr = "Row Pixel Spacing: " + str(self.row_pixel_spacing) + "\n"
             result += row_pixel_spacing_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.col_pixel_spacing is not None:
             col_pixel_spacing_attr = "Column Pixel Spacing: " + str(self.col_pixel_spacing) + "\n"
             result += col_pixel_spacing_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.depth_pixel_spacing is not None:
             depth_pixel_spacing_attr = "Depth Pixel Spacing: " + str(self.depth_pixel_spacing) + "\n"
             result += depth_pixel_spacing_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.row_direction_cosine is not None:
             row_direction_cosine_attr = "Row Direction Cosine: " + str(self.row_direction_cosine) + "\n"
             result += row_direction_cosine_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.col_direction_cosine is not None:
             col_direction_cosine_attr = "Column Direction Cosine: " + str(self.col_direction_cosine) + "\n"
             result += col_direction_cosine_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.depth_direction_cosine is not None:
             depth_direction_cosine_attr = "Depth Direction Cosine: " + str(self.depth_direction_cosine) + "\n"
             result += depth_direction_cosine_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.dicom_affine_transform is not None:
             dicom_affine_transform_attr = "DICOM affine transform: " + "\n" + str(self.dicom_affine_transform) + "\n"
             result += dicom_affine_transform_attr
-        except AttributeError:
-            pass
 
-        try:
+        if self.nifti_affine_transform is not None:
             nifti_affine_transform_attr = "NIFTI affine transform: " + "\n" + str(self.nifti_affine_transform) + "\n"
             result += nifti_affine_transform_attr
-        except AttributeError:
-            pass
 
         result += "---------------" + "\n"